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/in_out_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>
53 #include <vnet/bonding/node.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 action %d \n",
1352 i + 1, ntohl (mac->sw_if_index),
1353 format_ethernet_address, mac->mac_addr, mac->action);
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;
1779 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1781 vat_main_t *vam = &vat_main;
1782 i32 retval = ntohl (mp->retval);
1784 if (vam->async_mode)
1786 vam->async_errors += (retval < 0);
1790 vam->retval = retval;
1791 vam->sw_if_index = ntohl (mp->sw_if_index);
1792 vam->result_ready = 1;
1796 static void vl_api_bond_create_reply_t_handler_json
1797 (vl_api_bond_create_reply_t * mp)
1799 vat_main_t *vam = &vat_main;
1800 vat_json_node_t node;
1802 vat_json_init_object (&node);
1803 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1804 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1806 vat_json_print (vam->ofp, &node);
1807 vat_json_free (&node);
1809 vam->retval = ntohl (mp->retval);
1810 vam->result_ready = 1;
1814 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1816 vat_main_t *vam = &vat_main;
1817 i32 retval = ntohl (mp->retval);
1819 if (vam->async_mode)
1821 vam->async_errors += (retval < 0);
1825 vam->retval = retval;
1826 vam->result_ready = 1;
1830 static void vl_api_bond_delete_reply_t_handler_json
1831 (vl_api_bond_delete_reply_t * mp)
1833 vat_main_t *vam = &vat_main;
1834 vat_json_node_t node;
1836 vat_json_init_object (&node);
1837 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1839 vat_json_print (vam->ofp, &node);
1840 vat_json_free (&node);
1842 vam->retval = ntohl (mp->retval);
1843 vam->result_ready = 1;
1847 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1849 vat_main_t *vam = &vat_main;
1850 i32 retval = ntohl (mp->retval);
1852 if (vam->async_mode)
1854 vam->async_errors += (retval < 0);
1858 vam->retval = retval;
1859 vam->result_ready = 1;
1863 static void vl_api_bond_enslave_reply_t_handler_json
1864 (vl_api_bond_enslave_reply_t * mp)
1866 vat_main_t *vam = &vat_main;
1867 vat_json_node_t node;
1869 vat_json_init_object (&node);
1870 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1872 vat_json_print (vam->ofp, &node);
1873 vat_json_free (&node);
1875 vam->retval = ntohl (mp->retval);
1876 vam->result_ready = 1;
1880 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1883 vat_main_t *vam = &vat_main;
1884 i32 retval = ntohl (mp->retval);
1886 if (vam->async_mode)
1888 vam->async_errors += (retval < 0);
1892 vam->retval = retval;
1893 vam->result_ready = 1;
1897 static void vl_api_bond_detach_slave_reply_t_handler_json
1898 (vl_api_bond_detach_slave_reply_t * mp)
1900 vat_main_t *vam = &vat_main;
1901 vat_json_node_t node;
1903 vat_json_init_object (&node);
1904 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1906 vat_json_print (vam->ofp, &node);
1907 vat_json_free (&node);
1909 vam->retval = ntohl (mp->retval);
1910 vam->result_ready = 1;
1913 static void vl_api_sw_interface_bond_details_t_handler
1914 (vl_api_sw_interface_bond_details_t * mp)
1916 vat_main_t *vam = &vat_main;
1919 "%-16s %-12d %-12U %-13U %-14u %-14u",
1920 mp->interface_name, ntohl (mp->sw_if_index),
1921 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
1922 ntohl (mp->active_slaves), ntohl (mp->slaves));
1925 static void vl_api_sw_interface_bond_details_t_handler_json
1926 (vl_api_sw_interface_bond_details_t * mp)
1928 vat_main_t *vam = &vat_main;
1929 vat_json_node_t *node = NULL;
1931 if (VAT_JSON_ARRAY != vam->json_tree.type)
1933 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1934 vat_json_init_array (&vam->json_tree);
1936 node = vat_json_array_add (&vam->json_tree);
1938 vat_json_init_object (node);
1939 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1940 vat_json_object_add_string_copy (node, "interface_name",
1941 mp->interface_name);
1942 vat_json_object_add_uint (node, "mode", mp->mode);
1943 vat_json_object_add_uint (node, "load_balance", mp->lb);
1944 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
1945 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
1949 api_sw_interface_bond_dump (vat_main_t * vam)
1951 vl_api_sw_interface_bond_dump_t *mp;
1952 vl_api_control_ping_t *mp_ping;
1956 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
1957 "interface name", "sw_if_index", "mode", "load balance",
1958 "active slaves", "slaves");
1960 /* Get list of bond interfaces */
1961 M (SW_INTERFACE_BOND_DUMP, mp);
1964 /* Use a control ping for synchronization */
1965 MPING (CONTROL_PING, mp_ping);
1972 static void vl_api_sw_interface_slave_details_t_handler
1973 (vl_api_sw_interface_slave_details_t * mp)
1975 vat_main_t *vam = &vat_main;
1978 "%-25s %-12d %-12d %d", mp->interface_name,
1979 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
1982 static void vl_api_sw_interface_slave_details_t_handler_json
1983 (vl_api_sw_interface_slave_details_t * mp)
1985 vat_main_t *vam = &vat_main;
1986 vat_json_node_t *node = NULL;
1988 if (VAT_JSON_ARRAY != vam->json_tree.type)
1990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1991 vat_json_init_array (&vam->json_tree);
1993 node = vat_json_array_add (&vam->json_tree);
1995 vat_json_init_object (node);
1996 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1997 vat_json_object_add_string_copy (node, "interface_name",
1998 mp->interface_name);
1999 vat_json_object_add_uint (node, "passive", mp->is_passive);
2000 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2004 api_sw_interface_slave_dump (vat_main_t * vam)
2006 unformat_input_t *i = vam->input;
2007 vl_api_sw_interface_slave_dump_t *mp;
2008 vl_api_control_ping_t *mp_ping;
2009 u32 sw_if_index = ~0;
2010 u8 sw_if_index_set = 0;
2013 /* Parse args required to build the message */
2014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2016 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2017 sw_if_index_set = 1;
2018 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2019 sw_if_index_set = 1;
2024 if (sw_if_index_set == 0)
2026 errmsg ("missing vpp interface name. ");
2031 "\n%-25s %-12s %-12s %s",
2032 "slave interface name", "sw_if_index", "passive", "long_timeout");
2034 /* Get list of bond interfaces */
2035 M (SW_INTERFACE_SLAVE_DUMP, mp);
2036 mp->sw_if_index = ntohl (sw_if_index);
2039 /* Use a control ping for synchronization */
2040 MPING (CONTROL_PING, mp_ping);
2047 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2048 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2050 vat_main_t *vam = &vat_main;
2051 i32 retval = ntohl (mp->retval);
2052 if (vam->async_mode)
2054 vam->async_errors += (retval < 0);
2058 vam->retval = retval;
2059 vam->result_ready = 1;
2063 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2064 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2066 vat_main_t *vam = &vat_main;
2067 vat_json_node_t node;
2069 vat_json_init_object (&node);
2070 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2071 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2072 ntohl (mp->sw_if_index));
2074 vat_json_print (vam->ofp, &node);
2075 vat_json_free (&node);
2077 vam->retval = ntohl (mp->retval);
2078 vam->result_ready = 1;
2081 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2082 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2084 vat_main_t *vam = &vat_main;
2085 i32 retval = ntohl (mp->retval);
2086 if (vam->async_mode)
2088 vam->async_errors += (retval < 0);
2092 vam->retval = retval;
2093 vam->sw_if_index = ntohl (mp->sw_if_index);
2094 vam->result_ready = 1;
2098 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2099 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2101 vat_main_t *vam = &vat_main;
2102 vat_json_node_t node;
2104 vat_json_init_object (&node);
2105 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2106 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2108 vat_json_print (vam->ofp, &node);
2109 vat_json_free (&node);
2111 vam->retval = ntohl (mp->retval);
2112 vam->result_ready = 1;
2115 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2116 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2118 vat_main_t *vam = &vat_main;
2119 i32 retval = ntohl (mp->retval);
2120 if (vam->async_mode)
2122 vam->async_errors += (retval < 0);
2126 vam->retval = retval;
2127 vam->result_ready = 1;
2131 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2132 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2134 vat_main_t *vam = &vat_main;
2135 vat_json_node_t node;
2137 vat_json_init_object (&node);
2138 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2139 vat_json_object_add_uint (&node, "fwd_entry_index",
2140 clib_net_to_host_u32 (mp->fwd_entry_index));
2142 vat_json_print (vam->ofp, &node);
2143 vat_json_free (&node);
2145 vam->retval = ntohl (mp->retval);
2146 vam->result_ready = 1;
2150 format_lisp_transport_protocol (u8 * s, va_list * args)
2152 u32 proto = va_arg (*args, u32);
2157 return format (s, "udp");
2159 return format (s, "api");
2166 static void vl_api_one_get_transport_protocol_reply_t_handler
2167 (vl_api_one_get_transport_protocol_reply_t * mp)
2169 vat_main_t *vam = &vat_main;
2170 i32 retval = ntohl (mp->retval);
2171 if (vam->async_mode)
2173 vam->async_errors += (retval < 0);
2177 u32 proto = mp->protocol;
2178 print (vam->ofp, "Transport protocol: %U",
2179 format_lisp_transport_protocol, proto);
2180 vam->retval = retval;
2181 vam->result_ready = 1;
2185 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2186 (vl_api_one_get_transport_protocol_reply_t * mp)
2188 vat_main_t *vam = &vat_main;
2189 vat_json_node_t node;
2192 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2195 vat_json_init_object (&node);
2196 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2197 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2200 vat_json_print (vam->ofp, &node);
2201 vat_json_free (&node);
2203 vam->retval = ntohl (mp->retval);
2204 vam->result_ready = 1;
2207 static void vl_api_one_add_del_locator_set_reply_t_handler
2208 (vl_api_one_add_del_locator_set_reply_t * mp)
2210 vat_main_t *vam = &vat_main;
2211 i32 retval = ntohl (mp->retval);
2212 if (vam->async_mode)
2214 vam->async_errors += (retval < 0);
2218 vam->retval = retval;
2219 vam->result_ready = 1;
2223 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2224 (vl_api_one_add_del_locator_set_reply_t * mp)
2226 vat_main_t *vam = &vat_main;
2227 vat_json_node_t node;
2229 vat_json_init_object (&node);
2230 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2231 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2233 vat_json_print (vam->ofp, &node);
2234 vat_json_free (&node);
2236 vam->retval = ntohl (mp->retval);
2237 vam->result_ready = 1;
2240 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2241 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2243 vat_main_t *vam = &vat_main;
2244 i32 retval = ntohl (mp->retval);
2245 if (vam->async_mode)
2247 vam->async_errors += (retval < 0);
2251 vam->retval = retval;
2252 vam->sw_if_index = ntohl (mp->sw_if_index);
2253 vam->result_ready = 1;
2255 vam->regenerate_interface_table = 1;
2258 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2259 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2261 vat_main_t *vam = &vat_main;
2262 vat_json_node_t node;
2264 vat_json_init_object (&node);
2265 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2266 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2268 vat_json_print (vam->ofp, &node);
2269 vat_json_free (&node);
2271 vam->retval = ntohl (mp->retval);
2272 vam->result_ready = 1;
2275 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2276 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2278 vat_main_t *vam = &vat_main;
2279 i32 retval = ntohl (mp->retval);
2280 if (vam->async_mode)
2282 vam->async_errors += (retval < 0);
2286 vam->retval = retval;
2287 vam->sw_if_index = ntohl (mp->sw_if_index);
2288 vam->result_ready = 1;
2292 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2293 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2295 vat_main_t *vam = &vat_main;
2296 vat_json_node_t node;
2298 vat_json_init_object (&node);
2299 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2300 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2302 vat_json_print (vam->ofp, &node);
2303 vat_json_free (&node);
2305 vam->retval = ntohl (mp->retval);
2306 vam->result_ready = 1;
2309 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2310 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2312 vat_main_t *vam = &vat_main;
2313 i32 retval = ntohl (mp->retval);
2314 if (vam->async_mode)
2316 vam->async_errors += (retval < 0);
2320 vam->retval = retval;
2321 vam->sw_if_index = ntohl (mp->sw_if_index);
2322 vam->result_ready = 1;
2324 vam->regenerate_interface_table = 1;
2327 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2328 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2330 vat_main_t *vam = &vat_main;
2331 vat_json_node_t node;
2333 vat_json_init_object (&node);
2334 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2335 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2337 vat_json_print (vam->ofp, &node);
2338 vat_json_free (&node);
2340 vam->retval = ntohl (mp->retval);
2341 vam->result_ready = 1;
2344 static void vl_api_gre_add_del_tunnel_reply_t_handler
2345 (vl_api_gre_add_del_tunnel_reply_t * mp)
2347 vat_main_t *vam = &vat_main;
2348 i32 retval = ntohl (mp->retval);
2349 if (vam->async_mode)
2351 vam->async_errors += (retval < 0);
2355 vam->retval = retval;
2356 vam->sw_if_index = ntohl (mp->sw_if_index);
2357 vam->result_ready = 1;
2361 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2362 (vl_api_gre_add_del_tunnel_reply_t * mp)
2364 vat_main_t *vam = &vat_main;
2365 vat_json_node_t node;
2367 vat_json_init_object (&node);
2368 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2369 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2371 vat_json_print (vam->ofp, &node);
2372 vat_json_free (&node);
2374 vam->retval = ntohl (mp->retval);
2375 vam->result_ready = 1;
2378 static void vl_api_create_vhost_user_if_reply_t_handler
2379 (vl_api_create_vhost_user_if_reply_t * mp)
2381 vat_main_t *vam = &vat_main;
2382 i32 retval = ntohl (mp->retval);
2383 if (vam->async_mode)
2385 vam->async_errors += (retval < 0);
2389 vam->retval = retval;
2390 vam->sw_if_index = ntohl (mp->sw_if_index);
2391 vam->result_ready = 1;
2393 vam->regenerate_interface_table = 1;
2396 static void vl_api_create_vhost_user_if_reply_t_handler_json
2397 (vl_api_create_vhost_user_if_reply_t * mp)
2399 vat_main_t *vam = &vat_main;
2400 vat_json_node_t node;
2402 vat_json_init_object (&node);
2403 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2404 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2406 vat_json_print (vam->ofp, &node);
2407 vat_json_free (&node);
2409 vam->retval = ntohl (mp->retval);
2410 vam->result_ready = 1;
2413 static clib_error_t *
2414 receive_fd_msg (int socket_fd, int *my_fd)
2417 char ctl[CMSG_SPACE (sizeof (int)) + CMSG_SPACE (sizeof (struct ucred))];
2418 struct msghdr mh = { 0 };
2419 struct iovec iov[1];
2421 struct ucred *cr = 0;
2422 struct cmsghdr *cmsg;
2423 pid_t pid __attribute__ ((unused));
2424 uid_t uid __attribute__ ((unused));
2425 gid_t gid __attribute__ ((unused));
2427 iov[0].iov_base = msgbuf;
2431 mh.msg_control = ctl;
2432 mh.msg_controllen = sizeof (ctl);
2434 memset (ctl, 0, sizeof (ctl));
2436 /* receive the incoming message */
2437 size = recvmsg (socket_fd, &mh, 0);
2440 return (size == 0) ? clib_error_return (0, "disconnected") :
2441 clib_error_return_unix (0, "recvmsg: malformed message (fd %d)",
2445 cmsg = CMSG_FIRSTHDR (&mh);
2448 if (cmsg->cmsg_level == SOL_SOCKET)
2450 if (cmsg->cmsg_type == SCM_CREDENTIALS)
2452 cr = (struct ucred *) CMSG_DATA (cmsg);
2457 else if (cmsg->cmsg_type == SCM_RIGHTS)
2459 clib_memcpy (my_fd, CMSG_DATA (cmsg), sizeof (int));
2462 cmsg = CMSG_NXTHDR (&mh, cmsg);
2467 static void vl_api_memfd_segment_create_reply_t_handler
2468 (vl_api_memfd_segment_create_reply_t * mp)
2470 /* Dont bother in the builtin version */
2471 #if VPP_API_TEST_BUILTIN == 0
2472 vat_main_t *vam = &vat_main;
2473 api_main_t *am = &api_main;
2474 socket_client_main_t *scm = vam->socket_client_main;
2476 clib_error_t *error;
2477 ssvm_private_t memfd;
2478 i32 retval = ntohl (mp->retval);
2482 error = receive_fd_msg (scm->socket_fd, &my_fd);
2489 memset (&memfd, 0, sizeof (memfd));
2492 vam->client_index_invalid = 1;
2494 /* Note: this closes memfd.fd */
2495 retval = ssvm_slave_init_memfd (&memfd);
2497 clib_warning ("WARNING: segment map returned %d", retval);
2499 /* Pivot to the memory client segment that vpp just created */
2501 am->vlib_rp = (void *) (memfd.requested_va + MMAP_PAGESIZE);
2503 am->shmem_hdr = (void *) am->vlib_rp->user_ctx;
2505 vl_client_install_client_message_handlers ();
2507 vl_client_connect_to_vlib_no_map ("pvt",
2509 32 /* input_queue_length */ );
2510 vam->vl_input_queue = am->shmem_hdr->vl_input_queue;
2512 vl_socket_client_enable_disable (0 /* disable socket */ );
2516 if (vam->async_mode)
2518 vam->async_errors += (retval < 0);
2522 vam->retval = retval;
2523 vam->result_ready = 1;
2528 static void vl_api_memfd_segment_create_reply_t_handler_json
2529 (vl_api_memfd_segment_create_reply_t * mp)
2531 clib_warning ("no");
2534 static void vl_api_dns_resolve_name_reply_t_handler
2535 (vl_api_dns_resolve_name_reply_t * mp)
2537 vat_main_t *vam = &vat_main;
2538 i32 retval = ntohl (mp->retval);
2539 if (vam->async_mode)
2541 vam->async_errors += (retval < 0);
2545 vam->retval = retval;
2546 vam->result_ready = 1;
2551 clib_warning ("ip4 address %U", format_ip4_address,
2552 (ip4_address_t *) mp->ip4_address);
2554 clib_warning ("ip6 address %U", format_ip6_address,
2555 (ip6_address_t *) mp->ip6_address);
2558 clib_warning ("retval %d", retval);
2562 static void vl_api_dns_resolve_name_reply_t_handler_json
2563 (vl_api_dns_resolve_name_reply_t * mp)
2565 clib_warning ("not implemented");
2568 static void vl_api_dns_resolve_ip_reply_t_handler
2569 (vl_api_dns_resolve_ip_reply_t * mp)
2571 vat_main_t *vam = &vat_main;
2572 i32 retval = ntohl (mp->retval);
2573 if (vam->async_mode)
2575 vam->async_errors += (retval < 0);
2579 vam->retval = retval;
2580 vam->result_ready = 1;
2584 clib_warning ("canonical name %s", mp->name);
2587 clib_warning ("retval %d", retval);
2591 static void vl_api_dns_resolve_ip_reply_t_handler_json
2592 (vl_api_dns_resolve_ip_reply_t * mp)
2594 clib_warning ("not implemented");
2598 static void vl_api_ip_address_details_t_handler
2599 (vl_api_ip_address_details_t * mp)
2601 vat_main_t *vam = &vat_main;
2602 static ip_address_details_t empty_ip_address_details = { {0} };
2603 ip_address_details_t *address = NULL;
2604 ip_details_t *current_ip_details = NULL;
2605 ip_details_t *details = NULL;
2607 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2609 if (!details || vam->current_sw_if_index >= vec_len (details)
2610 || !details[vam->current_sw_if_index].present)
2612 errmsg ("ip address details arrived but not stored");
2613 errmsg ("ip_dump should be called first");
2617 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2619 #define addresses (current_ip_details->addr)
2621 vec_validate_init_empty (addresses, vec_len (addresses),
2622 empty_ip_address_details);
2624 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2626 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2627 address->prefix_length = mp->prefix_length;
2631 static void vl_api_ip_address_details_t_handler_json
2632 (vl_api_ip_address_details_t * mp)
2634 vat_main_t *vam = &vat_main;
2635 vat_json_node_t *node = NULL;
2636 struct in6_addr ip6;
2639 if (VAT_JSON_ARRAY != vam->json_tree.type)
2641 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2642 vat_json_init_array (&vam->json_tree);
2644 node = vat_json_array_add (&vam->json_tree);
2646 vat_json_init_object (node);
2649 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2650 vat_json_object_add_ip6 (node, "ip", ip6);
2654 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2655 vat_json_object_add_ip4 (node, "ip", ip4);
2657 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2661 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2663 vat_main_t *vam = &vat_main;
2664 static ip_details_t empty_ip_details = { 0 };
2665 ip_details_t *ip = NULL;
2666 u32 sw_if_index = ~0;
2668 sw_if_index = ntohl (mp->sw_if_index);
2670 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2671 sw_if_index, empty_ip_details);
2673 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2680 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2682 vat_main_t *vam = &vat_main;
2684 if (VAT_JSON_ARRAY != vam->json_tree.type)
2686 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2687 vat_json_init_array (&vam->json_tree);
2689 vat_json_array_add_uint (&vam->json_tree,
2690 clib_net_to_host_u32 (mp->sw_if_index));
2693 static void vl_api_map_domain_details_t_handler_json
2694 (vl_api_map_domain_details_t * mp)
2696 vat_json_node_t *node = NULL;
2697 vat_main_t *vam = &vat_main;
2698 struct in6_addr ip6;
2701 if (VAT_JSON_ARRAY != vam->json_tree.type)
2703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2704 vat_json_init_array (&vam->json_tree);
2707 node = vat_json_array_add (&vam->json_tree);
2708 vat_json_init_object (node);
2710 vat_json_object_add_uint (node, "domain_index",
2711 clib_net_to_host_u32 (mp->domain_index));
2712 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
2713 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
2714 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
2715 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
2716 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
2717 vat_json_object_add_ip6 (node, "ip6_src", ip6);
2718 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
2719 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
2720 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
2721 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
2722 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
2723 vat_json_object_add_int (node, "psid_length", mp->psid_length);
2724 vat_json_object_add_uint (node, "flags", mp->flags);
2725 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
2726 vat_json_object_add_int (node, "is_translation", mp->is_translation);
2729 static void vl_api_map_domain_details_t_handler
2730 (vl_api_map_domain_details_t * mp)
2732 vat_main_t *vam = &vat_main;
2734 if (mp->is_translation)
2737 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2738 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2739 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2740 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2741 clib_net_to_host_u32 (mp->domain_index));
2746 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2747 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2748 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2749 format_ip6_address, mp->ip6_src,
2750 clib_net_to_host_u32 (mp->domain_index));
2752 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2753 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2754 mp->is_translation ? "map-t" : "");
2757 static void vl_api_map_rule_details_t_handler_json
2758 (vl_api_map_rule_details_t * mp)
2760 struct in6_addr ip6;
2761 vat_json_node_t *node = NULL;
2762 vat_main_t *vam = &vat_main;
2764 if (VAT_JSON_ARRAY != vam->json_tree.type)
2766 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2767 vat_json_init_array (&vam->json_tree);
2770 node = vat_json_array_add (&vam->json_tree);
2771 vat_json_init_object (node);
2773 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2774 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2775 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2779 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2781 vat_main_t *vam = &vat_main;
2782 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2783 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2787 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2789 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2790 "router_addr %U host_mac %U",
2791 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2792 format_ip4_address, &mp->host_address,
2793 format_ip4_address, &mp->router_address,
2794 format_ethernet_address, mp->host_mac);
2797 static void vl_api_dhcp_compl_event_t_handler_json
2798 (vl_api_dhcp_compl_event_t * mp)
2800 /* JSON output not supported */
2804 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2807 vat_main_t *vam = &vat_main;
2808 static u64 default_counter = 0;
2810 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2812 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2813 sw_if_index, default_counter);
2814 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2818 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2819 interface_counter_t counter)
2821 vat_main_t *vam = &vat_main;
2822 static interface_counter_t default_counter = { 0, };
2824 vec_validate_init_empty (vam->combined_interface_counters,
2825 vnet_counter_type, NULL);
2826 vec_validate_init_empty (vam->combined_interface_counters
2827 [vnet_counter_type], sw_if_index, default_counter);
2828 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2831 static void vl_api_vnet_interface_simple_counters_t_handler
2832 (vl_api_vnet_interface_simple_counters_t * mp)
2837 static void vl_api_vnet_interface_combined_counters_t_handler
2838 (vl_api_vnet_interface_combined_counters_t * mp)
2843 static void vl_api_vnet_interface_simple_counters_t_handler_json
2844 (vl_api_vnet_interface_simple_counters_t * mp)
2849 u32 first_sw_if_index;
2852 count = ntohl (mp->count);
2853 first_sw_if_index = ntohl (mp->first_sw_if_index);
2855 v_packets = (u64 *) & mp->data;
2856 for (i = 0; i < count; i++)
2858 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2859 set_simple_interface_counter (mp->vnet_counter_type,
2860 first_sw_if_index + i, packets);
2865 static void vl_api_vnet_interface_combined_counters_t_handler_json
2866 (vl_api_vnet_interface_combined_counters_t * mp)
2868 interface_counter_t counter;
2870 u32 first_sw_if_index;
2874 count = ntohl (mp->count);
2875 first_sw_if_index = ntohl (mp->first_sw_if_index);
2877 v = (vlib_counter_t *) & mp->data;
2878 for (i = 0; i < count; i++)
2881 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2883 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2884 set_combined_interface_counter (mp->vnet_counter_type,
2885 first_sw_if_index + i, counter);
2891 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2893 vat_main_t *vam = &vat_main;
2896 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2898 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2907 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2909 vat_main_t *vam = &vat_main;
2912 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2914 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2922 static void vl_api_vnet_ip4_fib_counters_t_handler
2923 (vl_api_vnet_ip4_fib_counters_t * mp)
2928 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2929 (vl_api_vnet_ip4_fib_counters_t * mp)
2931 vat_main_t *vam = &vat_main;
2932 vl_api_ip4_fib_counter_t *v;
2933 ip4_fib_counter_t *counter;
2940 vrf_id = ntohl (mp->vrf_id);
2941 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2942 if (~0 == vrf_index)
2944 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2945 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2946 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2947 vec_validate (vam->ip4_fib_counters, vrf_index);
2948 vam->ip4_fib_counters[vrf_index] = NULL;
2951 vec_free (vam->ip4_fib_counters[vrf_index]);
2952 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2953 count = ntohl (mp->count);
2954 for (i = 0; i < count; i++)
2956 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2957 counter = &vam->ip4_fib_counters[vrf_index][i];
2958 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2959 counter->address = ip4;
2960 counter->address_length = v->address_length;
2961 counter->packets = clib_net_to_host_u64 (v->packets);
2962 counter->bytes = clib_net_to_host_u64 (v->bytes);
2967 static void vl_api_vnet_ip4_nbr_counters_t_handler
2968 (vl_api_vnet_ip4_nbr_counters_t * mp)
2973 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2974 (vl_api_vnet_ip4_nbr_counters_t * mp)
2976 vat_main_t *vam = &vat_main;
2977 vl_api_ip4_nbr_counter_t *v;
2978 ip4_nbr_counter_t *counter;
2983 sw_if_index = ntohl (mp->sw_if_index);
2984 count = ntohl (mp->count);
2985 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2988 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2990 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2991 for (i = 0; i < count; i++)
2993 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2994 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2995 counter->address.s_addr = v->address;
2996 counter->packets = clib_net_to_host_u64 (v->packets);
2997 counter->bytes = clib_net_to_host_u64 (v->bytes);
2998 counter->linkt = v->link_type;
3003 static void vl_api_vnet_ip6_fib_counters_t_handler
3004 (vl_api_vnet_ip6_fib_counters_t * mp)
3009 static void vl_api_vnet_ip6_fib_counters_t_handler_json
3010 (vl_api_vnet_ip6_fib_counters_t * mp)
3012 vat_main_t *vam = &vat_main;
3013 vl_api_ip6_fib_counter_t *v;
3014 ip6_fib_counter_t *counter;
3015 struct in6_addr ip6;
3021 vrf_id = ntohl (mp->vrf_id);
3022 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
3023 if (~0 == vrf_index)
3025 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
3026 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
3027 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
3028 vec_validate (vam->ip6_fib_counters, vrf_index);
3029 vam->ip6_fib_counters[vrf_index] = NULL;
3032 vec_free (vam->ip6_fib_counters[vrf_index]);
3033 v = (vl_api_ip6_fib_counter_t *) & mp->c;
3034 count = ntohl (mp->count);
3035 for (i = 0; i < count; i++)
3037 vec_validate (vam->ip6_fib_counters[vrf_index], i);
3038 counter = &vam->ip6_fib_counters[vrf_index][i];
3039 clib_memcpy (&ip6, &v->address, sizeof (ip6));
3040 counter->address = ip6;
3041 counter->address_length = v->address_length;
3042 counter->packets = clib_net_to_host_u64 (v->packets);
3043 counter->bytes = clib_net_to_host_u64 (v->bytes);
3048 static void vl_api_vnet_ip6_nbr_counters_t_handler
3049 (vl_api_vnet_ip6_nbr_counters_t * mp)
3054 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
3055 (vl_api_vnet_ip6_nbr_counters_t * mp)
3057 vat_main_t *vam = &vat_main;
3058 vl_api_ip6_nbr_counter_t *v;
3059 ip6_nbr_counter_t *counter;
3060 struct in6_addr ip6;
3065 sw_if_index = ntohl (mp->sw_if_index);
3066 count = ntohl (mp->count);
3067 vec_validate (vam->ip6_nbr_counters, sw_if_index);
3070 vec_free (vam->ip6_nbr_counters[sw_if_index]);
3072 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
3073 for (i = 0; i < count; i++)
3075 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
3076 counter = &vam->ip6_nbr_counters[sw_if_index][i];
3077 clib_memcpy (&ip6, &v->address, sizeof (ip6));
3078 counter->address = ip6;
3079 counter->packets = clib_net_to_host_u64 (v->packets);
3080 counter->bytes = clib_net_to_host_u64 (v->bytes);
3085 static void vl_api_get_first_msg_id_reply_t_handler
3086 (vl_api_get_first_msg_id_reply_t * mp)
3088 vat_main_t *vam = &vat_main;
3089 i32 retval = ntohl (mp->retval);
3091 if (vam->async_mode)
3093 vam->async_errors += (retval < 0);
3097 vam->retval = retval;
3098 vam->result_ready = 1;
3102 errmsg ("first message id %d", ntohs (mp->first_msg_id));
3106 static void vl_api_get_first_msg_id_reply_t_handler_json
3107 (vl_api_get_first_msg_id_reply_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t node;
3112 vat_json_init_object (&node);
3113 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3114 vat_json_object_add_uint (&node, "first_msg_id",
3115 (uint) ntohs (mp->first_msg_id));
3117 vat_json_print (vam->ofp, &node);
3118 vat_json_free (&node);
3120 vam->retval = ntohl (mp->retval);
3121 vam->result_ready = 1;
3124 static void vl_api_get_node_graph_reply_t_handler
3125 (vl_api_get_node_graph_reply_t * mp)
3127 vat_main_t *vam = &vat_main;
3128 api_main_t *am = &api_main;
3129 i32 retval = ntohl (mp->retval);
3130 u8 *pvt_copy, *reply;
3135 if (vam->async_mode)
3137 vam->async_errors += (retval < 0);
3141 vam->retval = retval;
3142 vam->result_ready = 1;
3145 /* "Should never happen..." */
3149 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
3150 pvt_copy = vec_dup (reply);
3152 /* Toss the shared-memory original... */
3153 pthread_mutex_lock (&am->vlib_rp->mutex);
3154 oldheap = svm_push_data_heap (am->vlib_rp);
3158 svm_pop_heap (oldheap);
3159 pthread_mutex_unlock (&am->vlib_rp->mutex);
3161 if (vam->graph_nodes)
3163 hash_free (vam->graph_node_index_by_name);
3165 for (i = 0; i < vec_len (vam->graph_nodes); i++)
3167 node = vam->graph_nodes[i];
3168 vec_free (node->name);
3169 vec_free (node->next_nodes);
3172 vec_free (vam->graph_nodes);
3175 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
3176 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
3177 vec_free (pvt_copy);
3179 for (i = 0; i < vec_len (vam->graph_nodes); i++)
3181 node = vam->graph_nodes[i];
3182 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
3186 static void vl_api_get_node_graph_reply_t_handler_json
3187 (vl_api_get_node_graph_reply_t * mp)
3189 vat_main_t *vam = &vat_main;
3190 api_main_t *am = &api_main;
3192 vat_json_node_t node;
3195 /* $$$$ make this real? */
3196 vat_json_init_object (&node);
3197 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3198 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
3200 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
3202 /* Toss the shared-memory original... */
3203 pthread_mutex_lock (&am->vlib_rp->mutex);
3204 oldheap = svm_push_data_heap (am->vlib_rp);
3208 svm_pop_heap (oldheap);
3209 pthread_mutex_unlock (&am->vlib_rp->mutex);
3211 vat_json_print (vam->ofp, &node);
3212 vat_json_free (&node);
3214 vam->retval = ntohl (mp->retval);
3215 vam->result_ready = 1;
3219 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
3221 vat_main_t *vam = &vat_main;
3226 s = format (s, "%=16d%=16d%=16d",
3227 ntohl (mp->sw_if_index), mp->priority, mp->weight);
3231 s = format (s, "%=16U%=16d%=16d",
3232 mp->is_ipv6 ? format_ip6_address :
3234 mp->ip_address, mp->priority, mp->weight);
3237 print (vam->ofp, "%v", s);
3242 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
3244 vat_main_t *vam = &vat_main;
3245 vat_json_node_t *node = NULL;
3246 struct in6_addr ip6;
3249 if (VAT_JSON_ARRAY != vam->json_tree.type)
3251 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3252 vat_json_init_array (&vam->json_tree);
3254 node = vat_json_array_add (&vam->json_tree);
3255 vat_json_init_object (node);
3257 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
3258 vat_json_object_add_uint (node, "priority", mp->priority);
3259 vat_json_object_add_uint (node, "weight", mp->weight);
3262 vat_json_object_add_uint (node, "sw_if_index",
3263 clib_net_to_host_u32 (mp->sw_if_index));
3268 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3269 vat_json_object_add_ip6 (node, "address", ip6);
3273 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3274 vat_json_object_add_ip4 (node, "address", ip4);
3280 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
3283 vat_main_t *vam = &vat_main;
3286 ls_name = format (0, "%s", mp->ls_name);
3288 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
3294 vl_api_one_locator_set_details_t_handler_json
3295 (vl_api_one_locator_set_details_t * mp)
3297 vat_main_t *vam = &vat_main;
3298 vat_json_node_t *node = 0;
3301 ls_name = format (0, "%s", mp->ls_name);
3302 vec_add1 (ls_name, 0);
3304 if (VAT_JSON_ARRAY != vam->json_tree.type)
3306 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3307 vat_json_init_array (&vam->json_tree);
3309 node = vat_json_array_add (&vam->json_tree);
3311 vat_json_init_object (node);
3312 vat_json_object_add_string_copy (node, "ls_name", ls_name);
3313 vat_json_object_add_uint (node, "ls_index",
3314 clib_net_to_host_u32 (mp->ls_index));
3322 } __attribute__ ((__packed__)) lisp_nsh_api_t;
3325 unformat_nsh_address (unformat_input_t * input, va_list * args)
3327 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
3328 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
3332 format_nsh_address_vat (u8 * s, va_list * args)
3334 nsh_t *a = va_arg (*args, nsh_t *);
3335 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
3339 format_lisp_flat_eid (u8 * s, va_list * args)
3341 u32 type = va_arg (*args, u32);
3342 u8 *eid = va_arg (*args, u8 *);
3343 u32 eid_len = va_arg (*args, u32);
3348 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3350 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3352 return format (s, "%U", format_ethernet_address, eid);
3354 return format (s, "%U", format_nsh_address_vat, eid);
3360 format_lisp_eid_vat (u8 * s, va_list * args)
3362 u32 type = va_arg (*args, u32);
3363 u8 *eid = va_arg (*args, u8 *);
3364 u32 eid_len = va_arg (*args, u32);
3365 u8 *seid = va_arg (*args, u8 *);
3366 u32 seid_len = va_arg (*args, u32);
3367 u32 is_src_dst = va_arg (*args, u32);
3370 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3372 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3378 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3380 vat_main_t *vam = &vat_main;
3381 u8 *s = 0, *eid = 0;
3383 if (~0 == mp->locator_set_index)
3384 s = format (0, "action: %d", mp->action);
3386 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3388 eid = format (0, "%U", format_lisp_eid_vat,
3392 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3395 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3396 clib_net_to_host_u32 (mp->vni),
3398 mp->is_local ? "local" : "remote",
3399 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3400 clib_net_to_host_u16 (mp->key_id), mp->key);
3407 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3410 vat_main_t *vam = &vat_main;
3411 vat_json_node_t *node = 0;
3414 if (VAT_JSON_ARRAY != vam->json_tree.type)
3416 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3417 vat_json_init_array (&vam->json_tree);
3419 node = vat_json_array_add (&vam->json_tree);
3421 vat_json_init_object (node);
3422 if (~0 == mp->locator_set_index)
3423 vat_json_object_add_uint (node, "action", mp->action);
3425 vat_json_object_add_uint (node, "locator_set_index",
3426 clib_net_to_host_u32 (mp->locator_set_index));
3428 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3429 if (mp->eid_type == 3)
3431 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3432 vat_json_init_object (nsh_json);
3433 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3434 vat_json_object_add_uint (nsh_json, "spi",
3435 clib_net_to_host_u32 (nsh->spi));
3436 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3440 eid = format (0, "%U", format_lisp_eid_vat,
3444 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3446 vat_json_object_add_string_copy (node, "eid", eid);
3449 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3450 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3451 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3455 vat_json_object_add_uint (node, "key_id",
3456 clib_net_to_host_u16 (mp->key_id));
3457 vat_json_object_add_string_copy (node, "key", mp->key);
3462 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3464 vat_main_t *vam = &vat_main;
3465 u8 *seid = 0, *deid = 0;
3466 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3468 deid = format (0, "%U", format_lisp_eid_vat,
3469 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3471 seid = format (0, "%U", format_lisp_eid_vat,
3472 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3478 format_ip_address_fcn = format_ip4_address;
3480 format_ip_address_fcn = format_ip6_address;
3483 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3484 clib_net_to_host_u32 (mp->vni),
3486 format_ip_address_fcn, mp->lloc,
3487 format_ip_address_fcn, mp->rloc,
3488 clib_net_to_host_u32 (mp->pkt_count),
3489 clib_net_to_host_u32 (mp->bytes));
3496 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3498 struct in6_addr ip6;
3500 vat_main_t *vam = &vat_main;
3501 vat_json_node_t *node = 0;
3502 u8 *deid = 0, *seid = 0;
3504 if (VAT_JSON_ARRAY != vam->json_tree.type)
3506 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3507 vat_json_init_array (&vam->json_tree);
3509 node = vat_json_array_add (&vam->json_tree);
3511 vat_json_init_object (node);
3512 deid = format (0, "%U", format_lisp_eid_vat,
3513 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3515 seid = format (0, "%U", format_lisp_eid_vat,
3516 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3521 vat_json_object_add_string_copy (node, "seid", seid);
3522 vat_json_object_add_string_copy (node, "deid", deid);
3523 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3527 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3528 vat_json_object_add_ip4 (node, "lloc", ip4);
3529 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3530 vat_json_object_add_ip4 (node, "rloc", ip4);
3534 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3535 vat_json_object_add_ip6 (node, "lloc", ip6);
3536 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3537 vat_json_object_add_ip6 (node, "rloc", ip6);
3539 vat_json_object_add_uint (node, "pkt_count",
3540 clib_net_to_host_u32 (mp->pkt_count));
3541 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3548 vl_api_one_eid_table_map_details_t_handler
3549 (vl_api_one_eid_table_map_details_t * mp)
3551 vat_main_t *vam = &vat_main;
3553 u8 *line = format (0, "%=10d%=10d",
3554 clib_net_to_host_u32 (mp->vni),
3555 clib_net_to_host_u32 (mp->dp_table));
3556 print (vam->ofp, "%v", line);
3561 vl_api_one_eid_table_map_details_t_handler_json
3562 (vl_api_one_eid_table_map_details_t * mp)
3564 vat_main_t *vam = &vat_main;
3565 vat_json_node_t *node = NULL;
3567 if (VAT_JSON_ARRAY != vam->json_tree.type)
3569 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3570 vat_json_init_array (&vam->json_tree);
3572 node = vat_json_array_add (&vam->json_tree);
3573 vat_json_init_object (node);
3574 vat_json_object_add_uint (node, "dp_table",
3575 clib_net_to_host_u32 (mp->dp_table));
3576 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3580 vl_api_one_eid_table_vni_details_t_handler
3581 (vl_api_one_eid_table_vni_details_t * mp)
3583 vat_main_t *vam = &vat_main;
3585 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3586 print (vam->ofp, "%v", line);
3591 vl_api_one_eid_table_vni_details_t_handler_json
3592 (vl_api_one_eid_table_vni_details_t * mp)
3594 vat_main_t *vam = &vat_main;
3595 vat_json_node_t *node = NULL;
3597 if (VAT_JSON_ARRAY != vam->json_tree.type)
3599 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3600 vat_json_init_array (&vam->json_tree);
3602 node = vat_json_array_add (&vam->json_tree);
3603 vat_json_init_object (node);
3604 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3608 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3609 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3611 vat_main_t *vam = &vat_main;
3612 int retval = clib_net_to_host_u32 (mp->retval);
3614 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3615 print (vam->ofp, "fallback threshold value: %d", mp->value);
3617 vam->retval = retval;
3618 vam->result_ready = 1;
3622 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3623 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3625 vat_main_t *vam = &vat_main;
3626 vat_json_node_t _node, *node = &_node;
3627 int retval = clib_net_to_host_u32 (mp->retval);
3629 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3630 vat_json_init_object (node);
3631 vat_json_object_add_uint (node, "value", mp->value);
3633 vat_json_print (vam->ofp, node);
3634 vat_json_free (node);
3636 vam->retval = retval;
3637 vam->result_ready = 1;
3641 vl_api_show_one_map_register_state_reply_t_handler
3642 (vl_api_show_one_map_register_state_reply_t * mp)
3644 vat_main_t *vam = &vat_main;
3645 int retval = clib_net_to_host_u32 (mp->retval);
3647 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3649 vam->retval = retval;
3650 vam->result_ready = 1;
3654 vl_api_show_one_map_register_state_reply_t_handler_json
3655 (vl_api_show_one_map_register_state_reply_t * mp)
3657 vat_main_t *vam = &vat_main;
3658 vat_json_node_t _node, *node = &_node;
3659 int retval = clib_net_to_host_u32 (mp->retval);
3661 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3663 vat_json_init_object (node);
3664 vat_json_object_add_string_copy (node, "state", s);
3666 vat_json_print (vam->ofp, node);
3667 vat_json_free (node);
3669 vam->retval = retval;
3670 vam->result_ready = 1;
3675 vl_api_show_one_rloc_probe_state_reply_t_handler
3676 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3678 vat_main_t *vam = &vat_main;
3679 int retval = clib_net_to_host_u32 (mp->retval);
3684 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3686 vam->retval = retval;
3687 vam->result_ready = 1;
3691 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3692 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3694 vat_main_t *vam = &vat_main;
3695 vat_json_node_t _node, *node = &_node;
3696 int retval = clib_net_to_host_u32 (mp->retval);
3698 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3699 vat_json_init_object (node);
3700 vat_json_object_add_string_copy (node, "state", s);
3702 vat_json_print (vam->ofp, node);
3703 vat_json_free (node);
3705 vam->retval = retval;
3706 vam->result_ready = 1;
3711 vl_api_show_one_stats_enable_disable_reply_t_handler
3712 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3714 vat_main_t *vam = &vat_main;
3715 int retval = clib_net_to_host_u32 (mp->retval);
3720 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3722 vam->retval = retval;
3723 vam->result_ready = 1;
3727 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3728 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3730 vat_main_t *vam = &vat_main;
3731 vat_json_node_t _node, *node = &_node;
3732 int retval = clib_net_to_host_u32 (mp->retval);
3734 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3735 vat_json_init_object (node);
3736 vat_json_object_add_string_copy (node, "state", s);
3738 vat_json_print (vam->ofp, node);
3739 vat_json_free (node);
3741 vam->retval = retval;
3742 vam->result_ready = 1;
3747 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3749 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3750 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3751 e->vni = clib_net_to_host_u32 (e->vni);
3755 gpe_fwd_entries_get_reply_t_net_to_host
3756 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3760 mp->count = clib_net_to_host_u32 (mp->count);
3761 for (i = 0; i < mp->count; i++)
3763 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3768 format_gpe_encap_mode (u8 * s, va_list * args)
3770 u32 mode = va_arg (*args, u32);
3775 return format (s, "lisp");
3777 return format (s, "vxlan");
3783 vl_api_gpe_get_encap_mode_reply_t_handler
3784 (vl_api_gpe_get_encap_mode_reply_t * mp)
3786 vat_main_t *vam = &vat_main;
3788 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3789 vam->retval = ntohl (mp->retval);
3790 vam->result_ready = 1;
3794 vl_api_gpe_get_encap_mode_reply_t_handler_json
3795 (vl_api_gpe_get_encap_mode_reply_t * mp)
3797 vat_main_t *vam = &vat_main;
3798 vat_json_node_t node;
3800 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3801 vec_add1 (encap_mode, 0);
3803 vat_json_init_object (&node);
3804 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3806 vec_free (encap_mode);
3807 vat_json_print (vam->ofp, &node);
3808 vat_json_free (&node);
3810 vam->retval = ntohl (mp->retval);
3811 vam->result_ready = 1;
3815 vl_api_gpe_fwd_entry_path_details_t_handler
3816 (vl_api_gpe_fwd_entry_path_details_t * mp)
3818 vat_main_t *vam = &vat_main;
3819 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3821 if (mp->lcl_loc.is_ip4)
3822 format_ip_address_fcn = format_ip4_address;
3824 format_ip_address_fcn = format_ip6_address;
3826 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3827 format_ip_address_fcn, &mp->lcl_loc,
3828 format_ip_address_fcn, &mp->rmt_loc);
3832 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3834 struct in6_addr ip6;
3839 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3840 vat_json_object_add_ip4 (n, "address", ip4);
3844 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3845 vat_json_object_add_ip6 (n, "address", ip6);
3847 vat_json_object_add_uint (n, "weight", loc->weight);
3851 vl_api_gpe_fwd_entry_path_details_t_handler_json
3852 (vl_api_gpe_fwd_entry_path_details_t * mp)
3854 vat_main_t *vam = &vat_main;
3855 vat_json_node_t *node = NULL;
3856 vat_json_node_t *loc_node;
3858 if (VAT_JSON_ARRAY != vam->json_tree.type)
3860 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3861 vat_json_init_array (&vam->json_tree);
3863 node = vat_json_array_add (&vam->json_tree);
3864 vat_json_init_object (node);
3866 loc_node = vat_json_object_add (node, "local_locator");
3867 vat_json_init_object (loc_node);
3868 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3870 loc_node = vat_json_object_add (node, "remote_locator");
3871 vat_json_init_object (loc_node);
3872 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3876 vl_api_gpe_fwd_entries_get_reply_t_handler
3877 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3879 vat_main_t *vam = &vat_main;
3881 int retval = clib_net_to_host_u32 (mp->retval);
3882 vl_api_gpe_fwd_entry_t *e;
3887 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3889 for (i = 0; i < mp->count; i++)
3891 e = &mp->entries[i];
3892 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3893 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3894 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3898 vam->retval = retval;
3899 vam->result_ready = 1;
3903 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3904 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3907 vat_main_t *vam = &vat_main;
3908 vat_json_node_t *e = 0, root;
3910 int retval = clib_net_to_host_u32 (mp->retval);
3911 vl_api_gpe_fwd_entry_t *fwd;
3916 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3917 vat_json_init_array (&root);
3919 for (i = 0; i < mp->count; i++)
3921 e = vat_json_array_add (&root);
3922 fwd = &mp->entries[i];
3924 vat_json_init_object (e);
3925 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3926 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3927 vat_json_object_add_int (e, "vni", fwd->vni);
3928 vat_json_object_add_int (e, "action", fwd->action);
3930 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3931 fwd->leid_prefix_len);
3933 vat_json_object_add_string_copy (e, "leid", s);
3936 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3937 fwd->reid_prefix_len);
3939 vat_json_object_add_string_copy (e, "reid", s);
3943 vat_json_print (vam->ofp, &root);
3944 vat_json_free (&root);
3947 vam->retval = retval;
3948 vam->result_ready = 1;
3952 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3953 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3955 vat_main_t *vam = &vat_main;
3957 int retval = clib_net_to_host_u32 (mp->retval);
3958 vl_api_gpe_native_fwd_rpath_t *r;
3963 n = clib_net_to_host_u32 (mp->count);
3965 for (i = 0; i < n; i++)
3967 r = &mp->entries[i];
3968 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3969 clib_net_to_host_u32 (r->fib_index),
3970 clib_net_to_host_u32 (r->nh_sw_if_index),
3971 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3975 vam->retval = retval;
3976 vam->result_ready = 1;
3980 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3981 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3983 vat_main_t *vam = &vat_main;
3984 vat_json_node_t root, *e;
3986 int retval = clib_net_to_host_u32 (mp->retval);
3987 vl_api_gpe_native_fwd_rpath_t *r;
3993 n = clib_net_to_host_u32 (mp->count);
3994 vat_json_init_array (&root);
3996 for (i = 0; i < n; i++)
3998 e = vat_json_array_add (&root);
3999 vat_json_init_object (e);
4000 r = &mp->entries[i];
4002 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
4005 vat_json_object_add_string_copy (e, "ip4", s);
4008 vat_json_object_add_uint (e, "fib_index",
4009 clib_net_to_host_u32 (r->fib_index));
4010 vat_json_object_add_uint (e, "nh_sw_if_index",
4011 clib_net_to_host_u32 (r->nh_sw_if_index));
4014 vat_json_print (vam->ofp, &root);
4015 vat_json_free (&root);
4018 vam->retval = retval;
4019 vam->result_ready = 1;
4023 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
4024 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
4026 vat_main_t *vam = &vat_main;
4028 int retval = clib_net_to_host_u32 (mp->retval);
4033 n = clib_net_to_host_u32 (mp->count);
4035 for (i = 0; i < n; i++)
4036 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
4039 vam->retval = retval;
4040 vam->result_ready = 1;
4044 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
4045 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
4047 vat_main_t *vam = &vat_main;
4048 vat_json_node_t root;
4050 int retval = clib_net_to_host_u32 (mp->retval);
4055 n = clib_net_to_host_u32 (mp->count);
4056 vat_json_init_array (&root);
4058 for (i = 0; i < n; i++)
4059 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
4061 vat_json_print (vam->ofp, &root);
4062 vat_json_free (&root);
4065 vam->retval = retval;
4066 vam->result_ready = 1;
4070 vl_api_one_ndp_entries_get_reply_t_handler
4071 (vl_api_one_ndp_entries_get_reply_t * mp)
4073 vat_main_t *vam = &vat_main;
4075 int retval = clib_net_to_host_u32 (mp->retval);
4080 n = clib_net_to_host_u32 (mp->count);
4082 for (i = 0; i < n; i++)
4083 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
4084 format_ethernet_address, mp->entries[i].mac);
4087 vam->retval = retval;
4088 vam->result_ready = 1;
4092 vl_api_one_ndp_entries_get_reply_t_handler_json
4093 (vl_api_one_ndp_entries_get_reply_t * mp)
4096 vat_main_t *vam = &vat_main;
4097 vat_json_node_t *e = 0, root;
4099 int retval = clib_net_to_host_u32 (mp->retval);
4100 vl_api_one_ndp_entry_t *arp_entry;
4105 n = clib_net_to_host_u32 (mp->count);
4106 vat_json_init_array (&root);
4108 for (i = 0; i < n; i++)
4110 e = vat_json_array_add (&root);
4111 arp_entry = &mp->entries[i];
4113 vat_json_init_object (e);
4114 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
4117 vat_json_object_add_string_copy (e, "mac", s);
4120 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
4122 vat_json_object_add_string_copy (e, "ip6", s);
4126 vat_json_print (vam->ofp, &root);
4127 vat_json_free (&root);
4130 vam->retval = retval;
4131 vam->result_ready = 1;
4135 vl_api_one_l2_arp_entries_get_reply_t_handler
4136 (vl_api_one_l2_arp_entries_get_reply_t * mp)
4138 vat_main_t *vam = &vat_main;
4140 int retval = clib_net_to_host_u32 (mp->retval);
4145 n = clib_net_to_host_u32 (mp->count);
4147 for (i = 0; i < n; i++)
4148 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
4149 format_ethernet_address, mp->entries[i].mac);
4152 vam->retval = retval;
4153 vam->result_ready = 1;
4157 vl_api_one_l2_arp_entries_get_reply_t_handler_json
4158 (vl_api_one_l2_arp_entries_get_reply_t * mp)
4161 vat_main_t *vam = &vat_main;
4162 vat_json_node_t *e = 0, root;
4164 int retval = clib_net_to_host_u32 (mp->retval);
4165 vl_api_one_l2_arp_entry_t *arp_entry;
4170 n = clib_net_to_host_u32 (mp->count);
4171 vat_json_init_array (&root);
4173 for (i = 0; i < n; i++)
4175 e = vat_json_array_add (&root);
4176 arp_entry = &mp->entries[i];
4178 vat_json_init_object (e);
4179 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
4182 vat_json_object_add_string_copy (e, "mac", s);
4185 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
4187 vat_json_object_add_string_copy (e, "ip4", s);
4191 vat_json_print (vam->ofp, &root);
4192 vat_json_free (&root);
4195 vam->retval = retval;
4196 vam->result_ready = 1;
4200 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
4202 vat_main_t *vam = &vat_main;
4204 int retval = clib_net_to_host_u32 (mp->retval);
4209 n = clib_net_to_host_u32 (mp->count);
4211 for (i = 0; i < n; i++)
4213 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
4217 vam->retval = retval;
4218 vam->result_ready = 1;
4222 vl_api_one_ndp_bd_get_reply_t_handler_json
4223 (vl_api_one_ndp_bd_get_reply_t * mp)
4225 vat_main_t *vam = &vat_main;
4226 vat_json_node_t root;
4228 int retval = clib_net_to_host_u32 (mp->retval);
4233 n = clib_net_to_host_u32 (mp->count);
4234 vat_json_init_array (&root);
4236 for (i = 0; i < n; i++)
4238 vat_json_array_add_uint (&root,
4239 clib_net_to_host_u32 (mp->bridge_domains[i]));
4242 vat_json_print (vam->ofp, &root);
4243 vat_json_free (&root);
4246 vam->retval = retval;
4247 vam->result_ready = 1;
4251 vl_api_one_l2_arp_bd_get_reply_t_handler
4252 (vl_api_one_l2_arp_bd_get_reply_t * mp)
4254 vat_main_t *vam = &vat_main;
4256 int retval = clib_net_to_host_u32 (mp->retval);
4261 n = clib_net_to_host_u32 (mp->count);
4263 for (i = 0; i < n; i++)
4265 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
4269 vam->retval = retval;
4270 vam->result_ready = 1;
4274 vl_api_one_l2_arp_bd_get_reply_t_handler_json
4275 (vl_api_one_l2_arp_bd_get_reply_t * mp)
4277 vat_main_t *vam = &vat_main;
4278 vat_json_node_t root;
4280 int retval = clib_net_to_host_u32 (mp->retval);
4285 n = clib_net_to_host_u32 (mp->count);
4286 vat_json_init_array (&root);
4288 for (i = 0; i < n; i++)
4290 vat_json_array_add_uint (&root,
4291 clib_net_to_host_u32 (mp->bridge_domains[i]));
4294 vat_json_print (vam->ofp, &root);
4295 vat_json_free (&root);
4298 vam->retval = retval;
4299 vam->result_ready = 1;
4303 vl_api_one_adjacencies_get_reply_t_handler
4304 (vl_api_one_adjacencies_get_reply_t * mp)
4306 vat_main_t *vam = &vat_main;
4308 int retval = clib_net_to_host_u32 (mp->retval);
4309 vl_api_one_adjacency_t *a;
4314 n = clib_net_to_host_u32 (mp->count);
4316 for (i = 0; i < n; i++)
4318 a = &mp->adjacencies[i];
4319 print (vam->ofp, "%U %40U",
4320 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
4321 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
4325 vam->retval = retval;
4326 vam->result_ready = 1;
4330 vl_api_one_adjacencies_get_reply_t_handler_json
4331 (vl_api_one_adjacencies_get_reply_t * mp)
4334 vat_main_t *vam = &vat_main;
4335 vat_json_node_t *e = 0, root;
4337 int retval = clib_net_to_host_u32 (mp->retval);
4338 vl_api_one_adjacency_t *a;
4343 n = clib_net_to_host_u32 (mp->count);
4344 vat_json_init_array (&root);
4346 for (i = 0; i < n; i++)
4348 e = vat_json_array_add (&root);
4349 a = &mp->adjacencies[i];
4351 vat_json_init_object (e);
4352 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4353 a->leid_prefix_len);
4355 vat_json_object_add_string_copy (e, "leid", s);
4358 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4359 a->reid_prefix_len);
4361 vat_json_object_add_string_copy (e, "reid", s);
4365 vat_json_print (vam->ofp, &root);
4366 vat_json_free (&root);
4369 vam->retval = retval;
4370 vam->result_ready = 1;
4374 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4376 vat_main_t *vam = &vat_main;
4378 print (vam->ofp, "%=20U",
4379 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4384 vl_api_one_map_server_details_t_handler_json
4385 (vl_api_one_map_server_details_t * mp)
4387 vat_main_t *vam = &vat_main;
4388 vat_json_node_t *node = NULL;
4389 struct in6_addr ip6;
4392 if (VAT_JSON_ARRAY != vam->json_tree.type)
4394 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4395 vat_json_init_array (&vam->json_tree);
4397 node = vat_json_array_add (&vam->json_tree);
4399 vat_json_init_object (node);
4402 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4403 vat_json_object_add_ip6 (node, "map-server", ip6);
4407 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4408 vat_json_object_add_ip4 (node, "map-server", ip4);
4413 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4416 vat_main_t *vam = &vat_main;
4418 print (vam->ofp, "%=20U",
4419 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4424 vl_api_one_map_resolver_details_t_handler_json
4425 (vl_api_one_map_resolver_details_t * mp)
4427 vat_main_t *vam = &vat_main;
4428 vat_json_node_t *node = NULL;
4429 struct in6_addr ip6;
4432 if (VAT_JSON_ARRAY != vam->json_tree.type)
4434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4435 vat_json_init_array (&vam->json_tree);
4437 node = vat_json_array_add (&vam->json_tree);
4439 vat_json_init_object (node);
4442 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4443 vat_json_object_add_ip6 (node, "map resolver", ip6);
4447 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4448 vat_json_object_add_ip4 (node, "map resolver", ip4);
4453 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4455 vat_main_t *vam = &vat_main;
4456 i32 retval = ntohl (mp->retval);
4460 print (vam->ofp, "feature: %s\ngpe: %s",
4461 mp->feature_status ? "enabled" : "disabled",
4462 mp->gpe_status ? "enabled" : "disabled");
4465 vam->retval = retval;
4466 vam->result_ready = 1;
4470 vl_api_show_one_status_reply_t_handler_json
4471 (vl_api_show_one_status_reply_t * mp)
4473 vat_main_t *vam = &vat_main;
4474 vat_json_node_t node;
4475 u8 *gpe_status = NULL;
4476 u8 *feature_status = NULL;
4478 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4479 feature_status = format (0, "%s",
4480 mp->feature_status ? "enabled" : "disabled");
4481 vec_add1 (gpe_status, 0);
4482 vec_add1 (feature_status, 0);
4484 vat_json_init_object (&node);
4485 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4486 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4488 vec_free (gpe_status);
4489 vec_free (feature_status);
4491 vat_json_print (vam->ofp, &node);
4492 vat_json_free (&node);
4494 vam->retval = ntohl (mp->retval);
4495 vam->result_ready = 1;
4499 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4500 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4502 vat_main_t *vam = &vat_main;
4503 i32 retval = ntohl (mp->retval);
4507 print (vam->ofp, "%=20s", mp->locator_set_name);
4510 vam->retval = retval;
4511 vam->result_ready = 1;
4515 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4516 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4518 vat_main_t *vam = &vat_main;
4519 vat_json_node_t *node = NULL;
4521 if (VAT_JSON_ARRAY != vam->json_tree.type)
4523 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4524 vat_json_init_array (&vam->json_tree);
4526 node = vat_json_array_add (&vam->json_tree);
4528 vat_json_init_object (node);
4529 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4531 vat_json_print (vam->ofp, node);
4532 vat_json_free (node);
4534 vam->retval = ntohl (mp->retval);
4535 vam->result_ready = 1;
4539 format_lisp_map_request_mode (u8 * s, va_list * args)
4541 u32 mode = va_arg (*args, u32);
4546 return format (0, "dst-only");
4548 return format (0, "src-dst");
4554 vl_api_show_one_map_request_mode_reply_t_handler
4555 (vl_api_show_one_map_request_mode_reply_t * mp)
4557 vat_main_t *vam = &vat_main;
4558 i32 retval = ntohl (mp->retval);
4562 u32 mode = mp->mode;
4563 print (vam->ofp, "map_request_mode: %U",
4564 format_lisp_map_request_mode, mode);
4567 vam->retval = retval;
4568 vam->result_ready = 1;
4572 vl_api_show_one_map_request_mode_reply_t_handler_json
4573 (vl_api_show_one_map_request_mode_reply_t * mp)
4575 vat_main_t *vam = &vat_main;
4576 vat_json_node_t node;
4581 s = format (0, "%U", format_lisp_map_request_mode, mode);
4584 vat_json_init_object (&node);
4585 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4586 vat_json_print (vam->ofp, &node);
4587 vat_json_free (&node);
4590 vam->retval = ntohl (mp->retval);
4591 vam->result_ready = 1;
4595 vl_api_one_show_xtr_mode_reply_t_handler
4596 (vl_api_one_show_xtr_mode_reply_t * mp)
4598 vat_main_t *vam = &vat_main;
4599 i32 retval = ntohl (mp->retval);
4603 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4606 vam->retval = retval;
4607 vam->result_ready = 1;
4611 vl_api_one_show_xtr_mode_reply_t_handler_json
4612 (vl_api_one_show_xtr_mode_reply_t * mp)
4614 vat_main_t *vam = &vat_main;
4615 vat_json_node_t node;
4618 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4619 vec_add1 (status, 0);
4621 vat_json_init_object (&node);
4622 vat_json_object_add_string_copy (&node, "status", status);
4626 vat_json_print (vam->ofp, &node);
4627 vat_json_free (&node);
4629 vam->retval = ntohl (mp->retval);
4630 vam->result_ready = 1;
4634 vl_api_one_show_pitr_mode_reply_t_handler
4635 (vl_api_one_show_pitr_mode_reply_t * mp)
4637 vat_main_t *vam = &vat_main;
4638 i32 retval = ntohl (mp->retval);
4642 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4645 vam->retval = retval;
4646 vam->result_ready = 1;
4650 vl_api_one_show_pitr_mode_reply_t_handler_json
4651 (vl_api_one_show_pitr_mode_reply_t * mp)
4653 vat_main_t *vam = &vat_main;
4654 vat_json_node_t node;
4657 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4658 vec_add1 (status, 0);
4660 vat_json_init_object (&node);
4661 vat_json_object_add_string_copy (&node, "status", status);
4665 vat_json_print (vam->ofp, &node);
4666 vat_json_free (&node);
4668 vam->retval = ntohl (mp->retval);
4669 vam->result_ready = 1;
4673 vl_api_one_show_petr_mode_reply_t_handler
4674 (vl_api_one_show_petr_mode_reply_t * mp)
4676 vat_main_t *vam = &vat_main;
4677 i32 retval = ntohl (mp->retval);
4681 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4684 vam->retval = retval;
4685 vam->result_ready = 1;
4689 vl_api_one_show_petr_mode_reply_t_handler_json
4690 (vl_api_one_show_petr_mode_reply_t * mp)
4692 vat_main_t *vam = &vat_main;
4693 vat_json_node_t node;
4696 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4697 vec_add1 (status, 0);
4699 vat_json_init_object (&node);
4700 vat_json_object_add_string_copy (&node, "status", status);
4704 vat_json_print (vam->ofp, &node);
4705 vat_json_free (&node);
4707 vam->retval = ntohl (mp->retval);
4708 vam->result_ready = 1;
4712 vl_api_show_one_use_petr_reply_t_handler
4713 (vl_api_show_one_use_petr_reply_t * mp)
4715 vat_main_t *vam = &vat_main;
4716 i32 retval = ntohl (mp->retval);
4720 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4723 print (vam->ofp, "Proxy-ETR address; %U",
4724 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4729 vam->retval = retval;
4730 vam->result_ready = 1;
4734 vl_api_show_one_use_petr_reply_t_handler_json
4735 (vl_api_show_one_use_petr_reply_t * mp)
4737 vat_main_t *vam = &vat_main;
4738 vat_json_node_t node;
4741 struct in6_addr ip6;
4743 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4744 vec_add1 (status, 0);
4746 vat_json_init_object (&node);
4747 vat_json_object_add_string_copy (&node, "status", status);
4752 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4753 vat_json_object_add_ip6 (&node, "address", ip6);
4757 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4758 vat_json_object_add_ip4 (&node, "address", ip4);
4764 vat_json_print (vam->ofp, &node);
4765 vat_json_free (&node);
4767 vam->retval = ntohl (mp->retval);
4768 vam->result_ready = 1;
4772 vl_api_show_one_nsh_mapping_reply_t_handler
4773 (vl_api_show_one_nsh_mapping_reply_t * mp)
4775 vat_main_t *vam = &vat_main;
4776 i32 retval = ntohl (mp->retval);
4780 print (vam->ofp, "%-20s%-16s",
4781 mp->is_set ? "set" : "not-set",
4782 mp->is_set ? (char *) mp->locator_set_name : "");
4785 vam->retval = retval;
4786 vam->result_ready = 1;
4790 vl_api_show_one_nsh_mapping_reply_t_handler_json
4791 (vl_api_show_one_nsh_mapping_reply_t * mp)
4793 vat_main_t *vam = &vat_main;
4794 vat_json_node_t node;
4797 status = format (0, "%s", mp->is_set ? "yes" : "no");
4798 vec_add1 (status, 0);
4800 vat_json_init_object (&node);
4801 vat_json_object_add_string_copy (&node, "is_set", status);
4804 vat_json_object_add_string_copy (&node, "locator_set",
4805 mp->locator_set_name);
4810 vat_json_print (vam->ofp, &node);
4811 vat_json_free (&node);
4813 vam->retval = ntohl (mp->retval);
4814 vam->result_ready = 1;
4818 vl_api_show_one_map_register_ttl_reply_t_handler
4819 (vl_api_show_one_map_register_ttl_reply_t * mp)
4821 vat_main_t *vam = &vat_main;
4822 i32 retval = ntohl (mp->retval);
4824 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4828 print (vam->ofp, "ttl: %u", mp->ttl);
4831 vam->retval = retval;
4832 vam->result_ready = 1;
4836 vl_api_show_one_map_register_ttl_reply_t_handler_json
4837 (vl_api_show_one_map_register_ttl_reply_t * mp)
4839 vat_main_t *vam = &vat_main;
4840 vat_json_node_t node;
4842 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4843 vat_json_init_object (&node);
4844 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4846 vat_json_print (vam->ofp, &node);
4847 vat_json_free (&node);
4849 vam->retval = ntohl (mp->retval);
4850 vam->result_ready = 1;
4854 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4856 vat_main_t *vam = &vat_main;
4857 i32 retval = ntohl (mp->retval);
4861 print (vam->ofp, "%-20s%-16s",
4862 mp->status ? "enabled" : "disabled",
4863 mp->status ? (char *) mp->locator_set_name : "");
4866 vam->retval = retval;
4867 vam->result_ready = 1;
4871 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4873 vat_main_t *vam = &vat_main;
4874 vat_json_node_t node;
4877 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4878 vec_add1 (status, 0);
4880 vat_json_init_object (&node);
4881 vat_json_object_add_string_copy (&node, "status", status);
4884 vat_json_object_add_string_copy (&node, "locator_set",
4885 mp->locator_set_name);
4890 vat_json_print (vam->ofp, &node);
4891 vat_json_free (&node);
4893 vam->retval = ntohl (mp->retval);
4894 vam->result_ready = 1;
4898 format_policer_type (u8 * s, va_list * va)
4900 u32 i = va_arg (*va, u32);
4902 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4903 s = format (s, "1r2c");
4904 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4905 s = format (s, "1r3c");
4906 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4907 s = format (s, "2r3c-2698");
4908 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4909 s = format (s, "2r3c-4115");
4910 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4911 s = format (s, "2r3c-mef5cf1");
4913 s = format (s, "ILLEGAL");
4918 format_policer_rate_type (u8 * s, va_list * va)
4920 u32 i = va_arg (*va, u32);
4922 if (i == SSE2_QOS_RATE_KBPS)
4923 s = format (s, "kbps");
4924 else if (i == SSE2_QOS_RATE_PPS)
4925 s = format (s, "pps");
4927 s = format (s, "ILLEGAL");
4932 format_policer_round_type (u8 * s, va_list * va)
4934 u32 i = va_arg (*va, u32);
4936 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4937 s = format (s, "closest");
4938 else if (i == SSE2_QOS_ROUND_TO_UP)
4939 s = format (s, "up");
4940 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4941 s = format (s, "down");
4943 s = format (s, "ILLEGAL");
4948 format_policer_action_type (u8 * s, va_list * va)
4950 u32 i = va_arg (*va, u32);
4952 if (i == SSE2_QOS_ACTION_DROP)
4953 s = format (s, "drop");
4954 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4955 s = format (s, "transmit");
4956 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4957 s = format (s, "mark-and-transmit");
4959 s = format (s, "ILLEGAL");
4964 format_dscp (u8 * s, va_list * va)
4966 u32 i = va_arg (*va, u32);
4971 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4975 return format (s, "ILLEGAL");
4977 s = format (s, "%s", t);
4982 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4984 vat_main_t *vam = &vat_main;
4985 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4987 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4988 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4990 conform_dscp_str = format (0, "");
4992 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4993 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4995 exceed_dscp_str = format (0, "");
4997 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4998 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
5000 violate_dscp_str = format (0, "");
5002 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
5003 "rate type %U, round type %U, %s rate, %s color-aware, "
5004 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
5005 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
5006 "conform action %U%s, exceed action %U%s, violate action %U%s",
5008 format_policer_type, mp->type,
5011 clib_net_to_host_u64 (mp->cb),
5012 clib_net_to_host_u64 (mp->eb),
5013 format_policer_rate_type, mp->rate_type,
5014 format_policer_round_type, mp->round_type,
5015 mp->single_rate ? "single" : "dual",
5016 mp->color_aware ? "is" : "not",
5017 ntohl (mp->cir_tokens_per_period),
5018 ntohl (mp->pir_tokens_per_period),
5020 ntohl (mp->current_limit),
5021 ntohl (mp->current_bucket),
5022 ntohl (mp->extended_limit),
5023 ntohl (mp->extended_bucket),
5024 clib_net_to_host_u64 (mp->last_update_time),
5025 format_policer_action_type, mp->conform_action_type,
5027 format_policer_action_type, mp->exceed_action_type,
5029 format_policer_action_type, mp->violate_action_type,
5032 vec_free (conform_dscp_str);
5033 vec_free (exceed_dscp_str);
5034 vec_free (violate_dscp_str);
5037 static void vl_api_policer_details_t_handler_json
5038 (vl_api_policer_details_t * mp)
5040 vat_main_t *vam = &vat_main;
5041 vat_json_node_t *node;
5042 u8 *rate_type_str, *round_type_str, *type_str;
5043 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
5045 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
5047 format (0, "%U", format_policer_round_type, mp->round_type);
5048 type_str = format (0, "%U", format_policer_type, mp->type);
5049 conform_action_str = format (0, "%U", format_policer_action_type,
5050 mp->conform_action_type);
5051 exceed_action_str = format (0, "%U", format_policer_action_type,
5052 mp->exceed_action_type);
5053 violate_action_str = format (0, "%U", format_policer_action_type,
5054 mp->violate_action_type);
5056 if (VAT_JSON_ARRAY != vam->json_tree.type)
5058 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5059 vat_json_init_array (&vam->json_tree);
5061 node = vat_json_array_add (&vam->json_tree);
5063 vat_json_init_object (node);
5064 vat_json_object_add_string_copy (node, "name", mp->name);
5065 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
5066 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
5067 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
5068 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
5069 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
5070 vat_json_object_add_string_copy (node, "round_type", round_type_str);
5071 vat_json_object_add_string_copy (node, "type", type_str);
5072 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
5073 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
5074 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
5075 vat_json_object_add_uint (node, "cir_tokens_per_period",
5076 ntohl (mp->cir_tokens_per_period));
5077 vat_json_object_add_uint (node, "eir_tokens_per_period",
5078 ntohl (mp->pir_tokens_per_period));
5079 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
5080 vat_json_object_add_uint (node, "current_bucket",
5081 ntohl (mp->current_bucket));
5082 vat_json_object_add_uint (node, "extended_limit",
5083 ntohl (mp->extended_limit));
5084 vat_json_object_add_uint (node, "extended_bucket",
5085 ntohl (mp->extended_bucket));
5086 vat_json_object_add_uint (node, "last_update_time",
5087 ntohl (mp->last_update_time));
5088 vat_json_object_add_string_copy (node, "conform_action",
5089 conform_action_str);
5090 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5092 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
5093 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
5094 vec_free (dscp_str);
5096 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
5097 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5099 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
5100 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
5101 vec_free (dscp_str);
5103 vat_json_object_add_string_copy (node, "violate_action",
5104 violate_action_str);
5105 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5107 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
5108 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
5109 vec_free (dscp_str);
5112 vec_free (rate_type_str);
5113 vec_free (round_type_str);
5114 vec_free (type_str);
5115 vec_free (conform_action_str);
5116 vec_free (exceed_action_str);
5117 vec_free (violate_action_str);
5121 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
5124 vat_main_t *vam = &vat_main;
5125 int i, count = ntohl (mp->count);
5128 print (vam->ofp, "classify table ids (%d) : ", count);
5129 for (i = 0; i < count; i++)
5131 print (vam->ofp, "%d", ntohl (mp->ids[i]));
5132 print (vam->ofp, (i < count - 1) ? "," : "");
5134 vam->retval = ntohl (mp->retval);
5135 vam->result_ready = 1;
5139 vl_api_classify_table_ids_reply_t_handler_json
5140 (vl_api_classify_table_ids_reply_t * mp)
5142 vat_main_t *vam = &vat_main;
5143 int i, count = ntohl (mp->count);
5147 vat_json_node_t node;
5149 vat_json_init_object (&node);
5150 for (i = 0; i < count; i++)
5152 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
5154 vat_json_print (vam->ofp, &node);
5155 vat_json_free (&node);
5157 vam->retval = ntohl (mp->retval);
5158 vam->result_ready = 1;
5162 vl_api_classify_table_by_interface_reply_t_handler
5163 (vl_api_classify_table_by_interface_reply_t * mp)
5165 vat_main_t *vam = &vat_main;
5168 table_id = ntohl (mp->l2_table_id);
5170 print (vam->ofp, "l2 table id : %d", table_id);
5172 print (vam->ofp, "l2 table id : No input ACL tables configured");
5173 table_id = ntohl (mp->ip4_table_id);
5175 print (vam->ofp, "ip4 table id : %d", table_id);
5177 print (vam->ofp, "ip4 table id : No input ACL tables configured");
5178 table_id = ntohl (mp->ip6_table_id);
5180 print (vam->ofp, "ip6 table id : %d", table_id);
5182 print (vam->ofp, "ip6 table id : No input ACL tables configured");
5183 vam->retval = ntohl (mp->retval);
5184 vam->result_ready = 1;
5188 vl_api_classify_table_by_interface_reply_t_handler_json
5189 (vl_api_classify_table_by_interface_reply_t * mp)
5191 vat_main_t *vam = &vat_main;
5192 vat_json_node_t node;
5194 vat_json_init_object (&node);
5196 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
5197 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
5198 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
5200 vat_json_print (vam->ofp, &node);
5201 vat_json_free (&node);
5203 vam->retval = ntohl (mp->retval);
5204 vam->result_ready = 1;
5207 static void vl_api_policer_add_del_reply_t_handler
5208 (vl_api_policer_add_del_reply_t * mp)
5210 vat_main_t *vam = &vat_main;
5211 i32 retval = ntohl (mp->retval);
5212 if (vam->async_mode)
5214 vam->async_errors += (retval < 0);
5218 vam->retval = retval;
5219 vam->result_ready = 1;
5220 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
5222 * Note: this is just barely thread-safe, depends on
5223 * the main thread spinning waiting for an answer...
5225 errmsg ("policer index %d", ntohl (mp->policer_index));
5229 static void vl_api_policer_add_del_reply_t_handler_json
5230 (vl_api_policer_add_del_reply_t * mp)
5232 vat_main_t *vam = &vat_main;
5233 vat_json_node_t node;
5235 vat_json_init_object (&node);
5236 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5237 vat_json_object_add_uint (&node, "policer_index",
5238 ntohl (mp->policer_index));
5240 vat_json_print (vam->ofp, &node);
5241 vat_json_free (&node);
5243 vam->retval = ntohl (mp->retval);
5244 vam->result_ready = 1;
5247 /* Format hex dump. */
5249 format_hex_bytes (u8 * s, va_list * va)
5251 u8 *bytes = va_arg (*va, u8 *);
5252 int n_bytes = va_arg (*va, int);
5255 /* Print short or long form depending on byte count. */
5256 uword short_form = n_bytes <= 32;
5257 u32 indent = format_get_indent (s);
5262 for (i = 0; i < n_bytes; i++)
5264 if (!short_form && (i % 32) == 0)
5265 s = format (s, "%08x: ", i);
5266 s = format (s, "%02x", bytes[i]);
5267 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
5268 s = format (s, "\n%U", format_white_space, indent);
5275 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
5278 vat_main_t *vam = &vat_main;
5279 i32 retval = ntohl (mp->retval);
5282 print (vam->ofp, "classify table info :");
5283 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
5284 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
5285 ntohl (mp->miss_next_index));
5286 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
5287 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
5288 ntohl (mp->match_n_vectors));
5289 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
5290 ntohl (mp->mask_length));
5292 vam->retval = retval;
5293 vam->result_ready = 1;
5297 vl_api_classify_table_info_reply_t_handler_json
5298 (vl_api_classify_table_info_reply_t * mp)
5300 vat_main_t *vam = &vat_main;
5301 vat_json_node_t node;
5303 i32 retval = ntohl (mp->retval);
5306 vat_json_init_object (&node);
5308 vat_json_object_add_int (&node, "sessions",
5309 ntohl (mp->active_sessions));
5310 vat_json_object_add_int (&node, "nexttbl",
5311 ntohl (mp->next_table_index));
5312 vat_json_object_add_int (&node, "nextnode",
5313 ntohl (mp->miss_next_index));
5314 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
5315 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
5316 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
5317 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
5318 ntohl (mp->mask_length), 0);
5319 vat_json_object_add_string_copy (&node, "mask", s);
5321 vat_json_print (vam->ofp, &node);
5322 vat_json_free (&node);
5324 vam->retval = ntohl (mp->retval);
5325 vam->result_ready = 1;
5329 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
5332 vat_main_t *vam = &vat_main;
5334 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
5335 ntohl (mp->hit_next_index), ntohl (mp->advance),
5336 ntohl (mp->opaque_index));
5337 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
5338 ntohl (mp->match_length));
5342 vl_api_classify_session_details_t_handler_json
5343 (vl_api_classify_session_details_t * mp)
5345 vat_main_t *vam = &vat_main;
5346 vat_json_node_t *node = NULL;
5348 if (VAT_JSON_ARRAY != vam->json_tree.type)
5350 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5351 vat_json_init_array (&vam->json_tree);
5353 node = vat_json_array_add (&vam->json_tree);
5355 vat_json_init_object (node);
5356 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5357 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5358 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5360 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5362 vat_json_object_add_string_copy (node, "match", s);
5365 static void vl_api_pg_create_interface_reply_t_handler
5366 (vl_api_pg_create_interface_reply_t * mp)
5368 vat_main_t *vam = &vat_main;
5370 vam->retval = ntohl (mp->retval);
5371 vam->result_ready = 1;
5374 static void vl_api_pg_create_interface_reply_t_handler_json
5375 (vl_api_pg_create_interface_reply_t * mp)
5377 vat_main_t *vam = &vat_main;
5378 vat_json_node_t node;
5380 i32 retval = ntohl (mp->retval);
5383 vat_json_init_object (&node);
5385 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5387 vat_json_print (vam->ofp, &node);
5388 vat_json_free (&node);
5390 vam->retval = ntohl (mp->retval);
5391 vam->result_ready = 1;
5394 static void vl_api_policer_classify_details_t_handler
5395 (vl_api_policer_classify_details_t * mp)
5397 vat_main_t *vam = &vat_main;
5399 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5400 ntohl (mp->table_index));
5403 static void vl_api_policer_classify_details_t_handler_json
5404 (vl_api_policer_classify_details_t * mp)
5406 vat_main_t *vam = &vat_main;
5407 vat_json_node_t *node;
5409 if (VAT_JSON_ARRAY != vam->json_tree.type)
5411 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5412 vat_json_init_array (&vam->json_tree);
5414 node = vat_json_array_add (&vam->json_tree);
5416 vat_json_init_object (node);
5417 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5418 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5421 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5422 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5424 vat_main_t *vam = &vat_main;
5425 i32 retval = ntohl (mp->retval);
5426 if (vam->async_mode)
5428 vam->async_errors += (retval < 0);
5432 vam->retval = retval;
5433 vam->sw_if_index = ntohl (mp->sw_if_index);
5434 vam->result_ready = 1;
5436 vam->regenerate_interface_table = 1;
5439 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5440 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5442 vat_main_t *vam = &vat_main;
5443 vat_json_node_t node;
5445 vat_json_init_object (&node);
5446 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5447 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5449 vat_json_print (vam->ofp, &node);
5450 vat_json_free (&node);
5452 vam->retval = ntohl (mp->retval);
5453 vam->result_ready = 1;
5456 static void vl_api_flow_classify_details_t_handler
5457 (vl_api_flow_classify_details_t * mp)
5459 vat_main_t *vam = &vat_main;
5461 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5462 ntohl (mp->table_index));
5465 static void vl_api_flow_classify_details_t_handler_json
5466 (vl_api_flow_classify_details_t * mp)
5468 vat_main_t *vam = &vat_main;
5469 vat_json_node_t *node;
5471 if (VAT_JSON_ARRAY != vam->json_tree.type)
5473 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5474 vat_json_init_array (&vam->json_tree);
5476 node = vat_json_array_add (&vam->json_tree);
5478 vat_json_init_object (node);
5479 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5480 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5483 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5484 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5485 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5486 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5487 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5488 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5489 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5490 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5491 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5492 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5493 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5494 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5495 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5496 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5497 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5498 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5499 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5500 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5501 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5502 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5503 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5504 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5507 * Generate boilerplate reply handlers, which
5508 * dig the return value out of the xxx_reply_t API message,
5509 * stick it into vam->retval, and set vam->result_ready
5511 * Could also do this by pointing N message decode slots at
5512 * a single function, but that could break in subtle ways.
5515 #define foreach_standard_reply_retval_handler \
5516 _(sw_interface_set_flags_reply) \
5517 _(sw_interface_add_del_address_reply) \
5518 _(sw_interface_set_rx_mode_reply) \
5519 _(sw_interface_set_table_reply) \
5520 _(sw_interface_set_mpls_enable_reply) \
5521 _(sw_interface_set_vpath_reply) \
5522 _(sw_interface_set_vxlan_bypass_reply) \
5523 _(sw_interface_set_geneve_bypass_reply) \
5524 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5525 _(sw_interface_set_l2_bridge_reply) \
5526 _(bridge_domain_add_del_reply) \
5527 _(sw_interface_set_l2_xconnect_reply) \
5528 _(l2fib_add_del_reply) \
5529 _(l2fib_flush_int_reply) \
5530 _(l2fib_flush_bd_reply) \
5531 _(ip_add_del_route_reply) \
5532 _(ip_table_add_del_reply) \
5533 _(ip_mroute_add_del_reply) \
5534 _(mpls_route_add_del_reply) \
5535 _(mpls_table_add_del_reply) \
5536 _(mpls_ip_bind_unbind_reply) \
5537 _(bier_route_add_del_reply) \
5538 _(bier_table_add_del_reply) \
5539 _(proxy_arp_add_del_reply) \
5540 _(proxy_arp_intfc_enable_disable_reply) \
5541 _(sw_interface_set_unnumbered_reply) \
5542 _(ip_neighbor_add_del_reply) \
5543 _(oam_add_del_reply) \
5544 _(reset_fib_reply) \
5545 _(dhcp_proxy_config_reply) \
5546 _(dhcp_proxy_set_vss_reply) \
5547 _(dhcp_client_config_reply) \
5548 _(set_ip_flow_hash_reply) \
5549 _(sw_interface_ip6_enable_disable_reply) \
5550 _(sw_interface_ip6_set_link_local_address_reply) \
5551 _(ip6nd_proxy_add_del_reply) \
5552 _(sw_interface_ip6nd_ra_prefix_reply) \
5553 _(sw_interface_ip6nd_ra_config_reply) \
5554 _(set_arp_neighbor_limit_reply) \
5555 _(l2_patch_add_del_reply) \
5556 _(sr_policy_add_reply) \
5557 _(sr_policy_mod_reply) \
5558 _(sr_policy_del_reply) \
5559 _(sr_localsid_add_del_reply) \
5560 _(sr_steering_add_del_reply) \
5561 _(classify_add_del_session_reply) \
5562 _(classify_set_interface_ip_table_reply) \
5563 _(classify_set_interface_l2_tables_reply) \
5564 _(l2tpv3_set_tunnel_cookies_reply) \
5565 _(l2tpv3_interface_enable_disable_reply) \
5566 _(l2tpv3_set_lookup_key_reply) \
5567 _(l2_fib_clear_table_reply) \
5568 _(l2_interface_efp_filter_reply) \
5569 _(l2_interface_vlan_tag_rewrite_reply) \
5570 _(modify_vhost_user_if_reply) \
5571 _(delete_vhost_user_if_reply) \
5572 _(want_ip4_arp_events_reply) \
5573 _(want_ip6_nd_events_reply) \
5574 _(want_l2_macs_events_reply) \
5575 _(input_acl_set_interface_reply) \
5576 _(ipsec_spd_add_del_reply) \
5577 _(ipsec_interface_add_del_spd_reply) \
5578 _(ipsec_spd_add_del_entry_reply) \
5579 _(ipsec_sad_add_del_entry_reply) \
5580 _(ipsec_sa_set_key_reply) \
5581 _(ipsec_tunnel_if_add_del_reply) \
5582 _(ipsec_tunnel_if_set_key_reply) \
5583 _(ipsec_tunnel_if_set_sa_reply) \
5584 _(ikev2_profile_add_del_reply) \
5585 _(ikev2_profile_set_auth_reply) \
5586 _(ikev2_profile_set_id_reply) \
5587 _(ikev2_profile_set_ts_reply) \
5588 _(ikev2_set_local_key_reply) \
5589 _(ikev2_set_responder_reply) \
5590 _(ikev2_set_ike_transforms_reply) \
5591 _(ikev2_set_esp_transforms_reply) \
5592 _(ikev2_set_sa_lifetime_reply) \
5593 _(ikev2_initiate_sa_init_reply) \
5594 _(ikev2_initiate_del_ike_sa_reply) \
5595 _(ikev2_initiate_del_child_sa_reply) \
5596 _(ikev2_initiate_rekey_child_sa_reply) \
5597 _(delete_loopback_reply) \
5598 _(bd_ip_mac_add_del_reply) \
5599 _(map_del_domain_reply) \
5600 _(map_add_del_rule_reply) \
5601 _(want_interface_events_reply) \
5602 _(want_stats_reply) \
5603 _(cop_interface_enable_disable_reply) \
5604 _(cop_whitelist_enable_disable_reply) \
5605 _(sw_interface_clear_stats_reply) \
5606 _(ioam_enable_reply) \
5607 _(ioam_disable_reply) \
5608 _(one_add_del_locator_reply) \
5609 _(one_add_del_local_eid_reply) \
5610 _(one_add_del_remote_mapping_reply) \
5611 _(one_add_del_adjacency_reply) \
5612 _(one_add_del_map_resolver_reply) \
5613 _(one_add_del_map_server_reply) \
5614 _(one_enable_disable_reply) \
5615 _(one_rloc_probe_enable_disable_reply) \
5616 _(one_map_register_enable_disable_reply) \
5617 _(one_map_register_set_ttl_reply) \
5618 _(one_set_transport_protocol_reply) \
5619 _(one_map_register_fallback_threshold_reply) \
5620 _(one_pitr_set_locator_set_reply) \
5621 _(one_map_request_mode_reply) \
5622 _(one_add_del_map_request_itr_rlocs_reply) \
5623 _(one_eid_table_add_del_map_reply) \
5624 _(one_use_petr_reply) \
5625 _(one_stats_enable_disable_reply) \
5626 _(one_add_del_l2_arp_entry_reply) \
5627 _(one_add_del_ndp_entry_reply) \
5628 _(one_stats_flush_reply) \
5629 _(one_enable_disable_xtr_mode_reply) \
5630 _(one_enable_disable_pitr_mode_reply) \
5631 _(one_enable_disable_petr_mode_reply) \
5632 _(gpe_enable_disable_reply) \
5633 _(gpe_set_encap_mode_reply) \
5634 _(gpe_add_del_iface_reply) \
5635 _(gpe_add_del_native_fwd_rpath_reply) \
5636 _(af_packet_delete_reply) \
5637 _(policer_classify_set_interface_reply) \
5638 _(netmap_create_reply) \
5639 _(netmap_delete_reply) \
5640 _(set_ipfix_exporter_reply) \
5641 _(set_ipfix_classify_stream_reply) \
5642 _(ipfix_classify_table_add_del_reply) \
5643 _(flow_classify_set_interface_reply) \
5644 _(sw_interface_span_enable_disable_reply) \
5645 _(pg_capture_reply) \
5646 _(pg_enable_disable_reply) \
5647 _(ip_source_and_port_range_check_add_del_reply) \
5648 _(ip_source_and_port_range_check_interface_add_del_reply)\
5649 _(delete_subif_reply) \
5650 _(l2_interface_pbb_tag_rewrite_reply) \
5652 _(feature_enable_disable_reply) \
5653 _(sw_interface_tag_add_del_reply) \
5654 _(sw_interface_set_mtu_reply) \
5655 _(p2p_ethernet_add_reply) \
5656 _(p2p_ethernet_del_reply) \
5657 _(lldp_config_reply) \
5658 _(sw_interface_set_lldp_reply) \
5659 _(tcp_configure_src_addresses_reply) \
5660 _(dns_enable_disable_reply) \
5661 _(dns_name_server_add_del_reply) \
5662 _(session_rule_add_del_reply) \
5663 _(ip_container_proxy_add_del_reply) \
5664 _(output_acl_set_interface_reply)
5667 static void vl_api_##n##_t_handler \
5668 (vl_api_##n##_t * mp) \
5670 vat_main_t * vam = &vat_main; \
5671 i32 retval = ntohl(mp->retval); \
5672 if (vam->async_mode) { \
5673 vam->async_errors += (retval < 0); \
5675 vam->retval = retval; \
5676 vam->result_ready = 1; \
5679 foreach_standard_reply_retval_handler;
5683 static void vl_api_##n##_t_handler_json \
5684 (vl_api_##n##_t * mp) \
5686 vat_main_t * vam = &vat_main; \
5687 vat_json_node_t node; \
5688 vat_json_init_object(&node); \
5689 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5690 vat_json_print(vam->ofp, &node); \
5691 vam->retval = ntohl(mp->retval); \
5692 vam->result_ready = 1; \
5694 foreach_standard_reply_retval_handler;
5698 * Table of message reply handlers, must include boilerplate handlers
5702 #define foreach_vpe_api_reply_msg \
5703 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5704 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5705 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5706 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5707 _(CONTROL_PING_REPLY, control_ping_reply) \
5708 _(CLI_REPLY, cli_reply) \
5709 _(CLI_INBAND_REPLY, cli_inband_reply) \
5710 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5711 sw_interface_add_del_address_reply) \
5712 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5713 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5714 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5715 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5716 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5717 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5718 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5719 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5720 sw_interface_set_l2_xconnect_reply) \
5721 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5722 sw_interface_set_l2_bridge_reply) \
5723 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5724 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5725 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5726 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5727 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5728 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5729 _(L2_FLAGS_REPLY, l2_flags_reply) \
5730 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5731 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5732 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5733 _(TAP_DELETE_REPLY, tap_delete_reply) \
5734 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5735 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5736 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5737 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5738 _(BOND_CREATE_REPLY, bond_create_reply) \
5739 _(BOND_DELETE_REPLY, bond_delete_reply) \
5740 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5741 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5742 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5743 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5744 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5745 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5746 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5747 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5748 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5749 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5750 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5751 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5752 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5753 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5754 proxy_arp_intfc_enable_disable_reply) \
5755 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5756 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5757 sw_interface_set_unnumbered_reply) \
5758 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5759 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5760 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5761 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5762 _(RESET_FIB_REPLY, reset_fib_reply) \
5763 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5764 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5765 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5766 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5767 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5768 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5769 sw_interface_ip6_enable_disable_reply) \
5770 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5771 sw_interface_ip6_set_link_local_address_reply) \
5772 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5773 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5774 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5775 sw_interface_ip6nd_ra_prefix_reply) \
5776 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5777 sw_interface_ip6nd_ra_config_reply) \
5778 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5779 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5780 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5781 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5782 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5783 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5784 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5785 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5786 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5787 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5788 classify_set_interface_ip_table_reply) \
5789 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5790 classify_set_interface_l2_tables_reply) \
5791 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5792 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5793 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5794 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5795 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5796 l2tpv3_interface_enable_disable_reply) \
5797 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5798 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5799 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5800 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5801 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5802 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5803 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5804 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5805 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5806 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5807 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5808 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5809 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5810 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5811 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5812 _(SHOW_VERSION_REPLY, show_version_reply) \
5813 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5814 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5815 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5816 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5817 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5818 _(IP4_ARP_EVENT, ip4_arp_event) \
5819 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5820 _(IP6_ND_EVENT, ip6_nd_event) \
5821 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5822 _(L2_MACS_EVENT, l2_macs_event) \
5823 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5824 _(IP_ADDRESS_DETAILS, ip_address_details) \
5825 _(IP_DETAILS, ip_details) \
5826 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5827 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5828 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5829 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5830 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5831 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5832 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5833 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5834 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5835 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5836 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5837 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5838 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5839 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5840 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5841 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5842 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5843 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5844 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5845 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5846 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5847 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5848 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5849 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5850 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5851 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5852 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5853 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5854 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5855 _(MAP_RULE_DETAILS, map_rule_details) \
5856 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5857 _(WANT_STATS_REPLY, want_stats_reply) \
5858 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5859 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5860 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5861 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5862 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5863 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5864 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5865 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5866 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5867 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5868 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5869 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5870 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5871 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5872 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5873 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5874 one_map_register_enable_disable_reply) \
5875 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5876 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5877 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5878 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5879 one_map_register_fallback_threshold_reply) \
5880 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5881 one_rloc_probe_enable_disable_reply) \
5882 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5883 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5884 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5885 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5886 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5887 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5888 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5889 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5890 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5891 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5892 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5893 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5894 _(ONE_STATS_DETAILS, one_stats_details) \
5895 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5896 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5897 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5898 show_one_stats_enable_disable_reply) \
5899 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5900 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5901 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5902 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5903 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5904 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5905 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5906 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5907 one_enable_disable_pitr_mode_reply) \
5908 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5909 one_enable_disable_petr_mode_reply) \
5910 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5911 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5912 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5913 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5914 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5915 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5916 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5917 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5918 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5919 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5920 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5921 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5922 gpe_add_del_native_fwd_rpath_reply) \
5923 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5924 gpe_fwd_entry_path_details) \
5925 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5926 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5927 one_add_del_map_request_itr_rlocs_reply) \
5928 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5929 one_get_map_request_itr_rlocs_reply) \
5930 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5931 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5932 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5933 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5934 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5935 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5936 show_one_map_register_state_reply) \
5937 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5938 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5939 show_one_map_register_fallback_threshold_reply) \
5940 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5941 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5942 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5943 _(POLICER_DETAILS, policer_details) \
5944 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5945 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5946 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5947 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5948 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5949 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5950 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5951 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5952 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5953 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5954 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5955 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5956 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5957 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5958 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5959 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5960 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5961 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5962 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5963 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5964 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5965 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5966 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5967 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5968 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5969 ip_source_and_port_range_check_add_del_reply) \
5970 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5971 ip_source_and_port_range_check_interface_add_del_reply) \
5972 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5973 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5974 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5975 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5976 _(PUNT_REPLY, punt_reply) \
5977 _(IP_FIB_DETAILS, ip_fib_details) \
5978 _(IP6_FIB_DETAILS, ip6_fib_details) \
5979 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5980 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5981 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5982 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5983 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5984 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5985 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5986 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5987 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5988 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5989 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5990 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5991 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5992 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5993 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5994 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5995 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5996 _(SESSION_RULES_DETAILS, session_rules_details) \
5997 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5998 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
6000 #define foreach_standalone_reply_msg \
6001 _(SW_INTERFACE_EVENT, sw_interface_event) \
6002 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
6003 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
6004 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
6005 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
6006 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
6007 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
6008 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
6017 #define STR_VTR_OP_CASE(op) \
6018 case L2_VTR_ ## op: \
6022 str_vtr_op (u32 vtr_op)
6026 STR_VTR_OP_CASE (DISABLED);
6027 STR_VTR_OP_CASE (PUSH_1);
6028 STR_VTR_OP_CASE (PUSH_2);
6029 STR_VTR_OP_CASE (POP_1);
6030 STR_VTR_OP_CASE (POP_2);
6031 STR_VTR_OP_CASE (TRANSLATE_1_1);
6032 STR_VTR_OP_CASE (TRANSLATE_1_2);
6033 STR_VTR_OP_CASE (TRANSLATE_2_1);
6034 STR_VTR_OP_CASE (TRANSLATE_2_2);
6041 dump_sub_interface_table (vat_main_t * vam)
6043 const sw_interface_subif_t *sub = NULL;
6045 if (vam->json_output)
6048 ("JSON output supported only for VPE API calls and dump_stats_table");
6053 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
6054 "Interface", "sw_if_index",
6055 "sub id", "dot1ad", "tags", "outer id",
6056 "inner id", "exact", "default", "outer any", "inner any");
6058 vec_foreach (sub, vam->sw_if_subif_table)
6061 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
6062 sub->interface_name,
6064 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
6065 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
6066 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
6067 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
6068 if (sub->vtr_op != L2_VTR_DISABLED)
6071 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
6072 "tag1: %d tag2: %d ]",
6073 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
6074 sub->vtr_tag1, sub->vtr_tag2);
6082 name_sort_cmp (void *a1, void *a2)
6084 name_sort_t *n1 = a1;
6085 name_sort_t *n2 = a2;
6087 return strcmp ((char *) n1->name, (char *) n2->name);
6091 dump_interface_table (vat_main_t * vam)
6094 name_sort_t *nses = 0, *ns;
6096 if (vam->json_output)
6099 ("JSON output supported only for VPE API calls and dump_stats_table");
6104 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6106 vec_add2 (nses, ns, 1);
6107 ns->name = (u8 *)(p->key);
6108 ns->value = (u32) p->value[0];
6112 vec_sort_with_function (nses, name_sort_cmp);
6114 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
6115 vec_foreach (ns, nses)
6117 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
6124 dump_ip_table (vat_main_t * vam, int is_ipv6)
6126 const ip_details_t *det = NULL;
6127 const ip_address_details_t *address = NULL;
6130 print (vam->ofp, "%-12s", "sw_if_index");
6132 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
6139 print (vam->ofp, "%-12d", i);
6140 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
6145 vec_foreach (address, det->addr)
6149 is_ipv6 ? format_ip6_address : format_ip4_address,
6150 address->ip, address->prefix_length);
6158 dump_ipv4_table (vat_main_t * vam)
6160 if (vam->json_output)
6163 ("JSON output supported only for VPE API calls and dump_stats_table");
6167 return dump_ip_table (vam, 0);
6171 dump_ipv6_table (vat_main_t * vam)
6173 if (vam->json_output)
6176 ("JSON output supported only for VPE API calls and dump_stats_table");
6180 return dump_ip_table (vam, 1);
6184 counter_type_to_str (u8 counter_type, u8 is_combined)
6188 switch (counter_type)
6190 case VNET_INTERFACE_COUNTER_DROP:
6192 case VNET_INTERFACE_COUNTER_PUNT:
6194 case VNET_INTERFACE_COUNTER_IP4:
6196 case VNET_INTERFACE_COUNTER_IP6:
6198 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
6200 case VNET_INTERFACE_COUNTER_RX_MISS:
6202 case VNET_INTERFACE_COUNTER_RX_ERROR:
6204 case VNET_INTERFACE_COUNTER_TX_ERROR:
6207 return "INVALID-COUNTER-TYPE";
6212 switch (counter_type)
6214 case VNET_INTERFACE_COUNTER_RX:
6216 case VNET_INTERFACE_COUNTER_TX:
6219 return "INVALID-COUNTER-TYPE";
6225 dump_stats_table (vat_main_t * vam)
6227 vat_json_node_t node;
6228 vat_json_node_t *msg_array;
6229 vat_json_node_t *msg;
6230 vat_json_node_t *counter_array;
6231 vat_json_node_t *counter;
6232 interface_counter_t c;
6234 ip4_fib_counter_t *c4;
6235 ip6_fib_counter_t *c6;
6236 ip4_nbr_counter_t *n4;
6237 ip6_nbr_counter_t *n6;
6240 if (!vam->json_output)
6242 clib_warning ("dump_stats_table supported only in JSON format");
6246 vat_json_init_object (&node);
6248 /* interface counters */
6249 msg_array = vat_json_object_add (&node, "interface_counters");
6250 vat_json_init_array (msg_array);
6251 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
6253 msg = vat_json_array_add (msg_array);
6254 vat_json_init_object (msg);
6255 vat_json_object_add_string_copy (msg, "vnet_counter_type",
6256 (u8 *) counter_type_to_str (i, 0));
6257 vat_json_object_add_int (msg, "is_combined", 0);
6258 counter_array = vat_json_object_add (msg, "data");
6259 vat_json_init_array (counter_array);
6260 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
6262 packets = vam->simple_interface_counters[i][j];
6263 vat_json_array_add_uint (counter_array, packets);
6266 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
6268 msg = vat_json_array_add (msg_array);
6269 vat_json_init_object (msg);
6270 vat_json_object_add_string_copy (msg, "vnet_counter_type",
6271 (u8 *) counter_type_to_str (i, 1));
6272 vat_json_object_add_int (msg, "is_combined", 1);
6273 counter_array = vat_json_object_add (msg, "data");
6274 vat_json_init_array (counter_array);
6275 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
6277 c = vam->combined_interface_counters[i][j];
6278 counter = vat_json_array_add (counter_array);
6279 vat_json_init_object (counter);
6280 vat_json_object_add_uint (counter, "packets", c.packets);
6281 vat_json_object_add_uint (counter, "bytes", c.bytes);
6285 /* ip4 fib counters */
6286 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
6287 vat_json_init_array (msg_array);
6288 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
6290 msg = vat_json_array_add (msg_array);
6291 vat_json_init_object (msg);
6292 vat_json_object_add_uint (msg, "vrf_id",
6293 vam->ip4_fib_counters_vrf_id_by_index[i]);
6294 counter_array = vat_json_object_add (msg, "c");
6295 vat_json_init_array (counter_array);
6296 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
6298 counter = vat_json_array_add (counter_array);
6299 vat_json_init_object (counter);
6300 c4 = &vam->ip4_fib_counters[i][j];
6301 vat_json_object_add_ip4 (counter, "address", c4->address);
6302 vat_json_object_add_uint (counter, "address_length",
6303 c4->address_length);
6304 vat_json_object_add_uint (counter, "packets", c4->packets);
6305 vat_json_object_add_uint (counter, "bytes", c4->bytes);
6309 /* ip6 fib counters */
6310 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
6311 vat_json_init_array (msg_array);
6312 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
6314 msg = vat_json_array_add (msg_array);
6315 vat_json_init_object (msg);
6316 vat_json_object_add_uint (msg, "vrf_id",
6317 vam->ip6_fib_counters_vrf_id_by_index[i]);
6318 counter_array = vat_json_object_add (msg, "c");
6319 vat_json_init_array (counter_array);
6320 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
6322 counter = vat_json_array_add (counter_array);
6323 vat_json_init_object (counter);
6324 c6 = &vam->ip6_fib_counters[i][j];
6325 vat_json_object_add_ip6 (counter, "address", c6->address);
6326 vat_json_object_add_uint (counter, "address_length",
6327 c6->address_length);
6328 vat_json_object_add_uint (counter, "packets", c6->packets);
6329 vat_json_object_add_uint (counter, "bytes", c6->bytes);
6333 /* ip4 nbr counters */
6334 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
6335 vat_json_init_array (msg_array);
6336 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
6338 msg = vat_json_array_add (msg_array);
6339 vat_json_init_object (msg);
6340 vat_json_object_add_uint (msg, "sw_if_index", i);
6341 counter_array = vat_json_object_add (msg, "c");
6342 vat_json_init_array (counter_array);
6343 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
6345 counter = vat_json_array_add (counter_array);
6346 vat_json_init_object (counter);
6347 n4 = &vam->ip4_nbr_counters[i][j];
6348 vat_json_object_add_ip4 (counter, "address", n4->address);
6349 vat_json_object_add_uint (counter, "link-type", n4->linkt);
6350 vat_json_object_add_uint (counter, "packets", n4->packets);
6351 vat_json_object_add_uint (counter, "bytes", n4->bytes);
6355 /* ip6 nbr counters */
6356 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
6357 vat_json_init_array (msg_array);
6358 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
6360 msg = vat_json_array_add (msg_array);
6361 vat_json_init_object (msg);
6362 vat_json_object_add_uint (msg, "sw_if_index", i);
6363 counter_array = vat_json_object_add (msg, "c");
6364 vat_json_init_array (counter_array);
6365 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
6367 counter = vat_json_array_add (counter_array);
6368 vat_json_init_object (counter);
6369 n6 = &vam->ip6_nbr_counters[i][j];
6370 vat_json_object_add_ip6 (counter, "address", n6->address);
6371 vat_json_object_add_uint (counter, "packets", n6->packets);
6372 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6376 vat_json_print (vam->ofp, &node);
6377 vat_json_free (&node);
6383 * Pass CLI buffers directly in the CLI_INBAND API message,
6384 * instead of an additional shared memory area.
6387 exec_inband (vat_main_t * vam)
6389 vl_api_cli_inband_t *mp;
6390 unformat_input_t *i = vam->input;
6393 if (vec_len (i->buffer) == 0)
6396 if (vam->exec_mode == 0 && unformat (i, "mode"))
6401 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6408 * In order for the CLI command to work, it
6409 * must be a vector ending in \n, not a C-string ending
6412 u32 len = vec_len (vam->input->buffer);
6413 M2 (CLI_INBAND, mp, len);
6414 clib_memcpy (mp->cmd, vam->input->buffer, len);
6415 mp->length = htonl (len);
6419 /* json responses may or may not include a useful reply... */
6420 if (vec_len (vam->cmd_reply))
6421 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6426 exec (vat_main_t * vam)
6428 return exec_inband (vam);
6432 api_create_loopback (vat_main_t * vam)
6434 unformat_input_t *i = vam->input;
6435 vl_api_create_loopback_t *mp;
6436 vl_api_create_loopback_instance_t *mp_lbi;
6439 u8 is_specified = 0;
6440 u32 user_instance = 0;
6443 memset (mac_address, 0, sizeof (mac_address));
6445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6447 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6449 if (unformat (i, "instance %d", &user_instance))
6457 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6458 mp_lbi->is_specified = is_specified;
6460 mp_lbi->user_instance = htonl (user_instance);
6462 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6467 /* Construct the API message */
6468 M (CREATE_LOOPBACK, mp);
6470 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6479 api_delete_loopback (vat_main_t * vam)
6481 unformat_input_t *i = vam->input;
6482 vl_api_delete_loopback_t *mp;
6483 u32 sw_if_index = ~0;
6486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6488 if (unformat (i, "sw_if_index %d", &sw_if_index))
6494 if (sw_if_index == ~0)
6496 errmsg ("missing sw_if_index");
6500 /* Construct the API message */
6501 M (DELETE_LOOPBACK, mp);
6502 mp->sw_if_index = ntohl (sw_if_index);
6510 api_want_stats (vat_main_t * vam)
6512 unformat_input_t *i = vam->input;
6513 vl_api_want_stats_t *mp;
6517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6519 if (unformat (i, "enable"))
6521 else if (unformat (i, "disable"))
6529 errmsg ("missing enable|disable");
6534 mp->enable_disable = enable;
6542 api_want_interface_events (vat_main_t * vam)
6544 unformat_input_t *i = vam->input;
6545 vl_api_want_interface_events_t *mp;
6549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6551 if (unformat (i, "enable"))
6553 else if (unformat (i, "disable"))
6561 errmsg ("missing enable|disable");
6565 M (WANT_INTERFACE_EVENTS, mp);
6566 mp->enable_disable = enable;
6568 vam->interface_event_display = enable;
6576 /* Note: non-static, called once to set up the initial intfc table */
6578 api_sw_interface_dump (vat_main_t * vam)
6580 vl_api_sw_interface_dump_t *mp;
6581 vl_api_control_ping_t *mp_ping;
6583 name_sort_t *nses = 0, *ns;
6584 sw_interface_subif_t *sub = NULL;
6587 /* Toss the old name table */
6589 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6591 vec_add2 (nses, ns, 1);
6592 ns->name = (u8 *)(p->key);
6593 ns->value = (u32) p->value[0];
6597 hash_free (vam->sw_if_index_by_interface_name);
6599 vec_foreach (ns, nses) vec_free (ns->name);
6603 vec_foreach (sub, vam->sw_if_subif_table)
6605 vec_free (sub->interface_name);
6607 vec_free (vam->sw_if_subif_table);
6609 /* recreate the interface name hash table */
6610 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6613 * Ask for all interface names. Otherwise, the epic catalog of
6614 * name filters becomes ridiculously long, and vat ends up needing
6615 * to be taught about new interface types.
6617 M (SW_INTERFACE_DUMP, mp);
6620 /* Use a control ping for synchronization */
6621 MPING (CONTROL_PING, mp_ping);
6629 api_sw_interface_set_flags (vat_main_t * vam)
6631 unformat_input_t *i = vam->input;
6632 vl_api_sw_interface_set_flags_t *mp;
6634 u8 sw_if_index_set = 0;
6638 /* Parse args required to build the message */
6639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6641 if (unformat (i, "admin-up"))
6643 else if (unformat (i, "admin-down"))
6646 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6647 sw_if_index_set = 1;
6648 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6649 sw_if_index_set = 1;
6654 if (sw_if_index_set == 0)
6656 errmsg ("missing interface name or sw_if_index");
6660 /* Construct the API message */
6661 M (SW_INTERFACE_SET_FLAGS, mp);
6662 mp->sw_if_index = ntohl (sw_if_index);
6663 mp->admin_up_down = admin_up;
6668 /* Wait for a reply, return the good/bad news... */
6674 api_sw_interface_set_rx_mode (vat_main_t * vam)
6676 unformat_input_t *i = vam->input;
6677 vl_api_sw_interface_set_rx_mode_t *mp;
6679 u8 sw_if_index_set = 0;
6681 u8 queue_id_valid = 0;
6683 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6685 /* Parse args required to build the message */
6686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6688 if (unformat (i, "queue %d", &queue_id))
6690 else if (unformat (i, "polling"))
6691 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6692 else if (unformat (i, "interrupt"))
6693 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6694 else if (unformat (i, "adaptive"))
6695 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6697 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6698 sw_if_index_set = 1;
6699 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6700 sw_if_index_set = 1;
6705 if (sw_if_index_set == 0)
6707 errmsg ("missing interface name or sw_if_index");
6710 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6712 errmsg ("missing rx-mode");
6716 /* Construct the API message */
6717 M (SW_INTERFACE_SET_RX_MODE, mp);
6718 mp->sw_if_index = ntohl (sw_if_index);
6720 mp->queue_id_valid = queue_id_valid;
6721 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6726 /* Wait for a reply, return the good/bad news... */
6732 api_sw_interface_clear_stats (vat_main_t * vam)
6734 unformat_input_t *i = vam->input;
6735 vl_api_sw_interface_clear_stats_t *mp;
6737 u8 sw_if_index_set = 0;
6740 /* Parse args required to build the message */
6741 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6743 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6744 sw_if_index_set = 1;
6745 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6746 sw_if_index_set = 1;
6751 /* Construct the API message */
6752 M (SW_INTERFACE_CLEAR_STATS, mp);
6754 if (sw_if_index_set == 1)
6755 mp->sw_if_index = ntohl (sw_if_index);
6757 mp->sw_if_index = ~0;
6762 /* Wait for a reply, return the good/bad news... */
6768 api_sw_interface_add_del_address (vat_main_t * vam)
6770 unformat_input_t *i = vam->input;
6771 vl_api_sw_interface_add_del_address_t *mp;
6773 u8 sw_if_index_set = 0;
6774 u8 is_add = 1, del_all = 0;
6775 u32 address_length = 0;
6776 u8 v4_address_set = 0;
6777 u8 v6_address_set = 0;
6778 ip4_address_t v4address;
6779 ip6_address_t v6address;
6782 /* Parse args required to build the message */
6783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6785 if (unformat (i, "del-all"))
6787 else if (unformat (i, "del"))
6790 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6791 sw_if_index_set = 1;
6792 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6793 sw_if_index_set = 1;
6794 else if (unformat (i, "%U/%d",
6795 unformat_ip4_address, &v4address, &address_length))
6797 else if (unformat (i, "%U/%d",
6798 unformat_ip6_address, &v6address, &address_length))
6804 if (sw_if_index_set == 0)
6806 errmsg ("missing interface name or sw_if_index");
6809 if (v4_address_set && v6_address_set)
6811 errmsg ("both v4 and v6 addresses set");
6814 if (!v4_address_set && !v6_address_set && !del_all)
6816 errmsg ("no addresses set");
6820 /* Construct the API message */
6821 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6823 mp->sw_if_index = ntohl (sw_if_index);
6824 mp->is_add = is_add;
6825 mp->del_all = del_all;
6829 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6833 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6835 mp->address_length = address_length;
6840 /* Wait for a reply, return good/bad news */
6846 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6848 unformat_input_t *i = vam->input;
6849 vl_api_sw_interface_set_mpls_enable_t *mp;
6851 u8 sw_if_index_set = 0;
6855 /* Parse args required to build the message */
6856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6858 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6859 sw_if_index_set = 1;
6860 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6861 sw_if_index_set = 1;
6862 else if (unformat (i, "disable"))
6864 else if (unformat (i, "dis"))
6870 if (sw_if_index_set == 0)
6872 errmsg ("missing interface name or sw_if_index");
6876 /* Construct the API message */
6877 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6879 mp->sw_if_index = ntohl (sw_if_index);
6880 mp->enable = enable;
6885 /* Wait for a reply... */
6891 api_sw_interface_set_table (vat_main_t * vam)
6893 unformat_input_t *i = vam->input;
6894 vl_api_sw_interface_set_table_t *mp;
6895 u32 sw_if_index, vrf_id = 0;
6896 u8 sw_if_index_set = 0;
6900 /* Parse args required to build the message */
6901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6903 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6904 sw_if_index_set = 1;
6905 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6906 sw_if_index_set = 1;
6907 else if (unformat (i, "vrf %d", &vrf_id))
6909 else if (unformat (i, "ipv6"))
6915 if (sw_if_index_set == 0)
6917 errmsg ("missing interface name or sw_if_index");
6921 /* Construct the API message */
6922 M (SW_INTERFACE_SET_TABLE, mp);
6924 mp->sw_if_index = ntohl (sw_if_index);
6925 mp->is_ipv6 = is_ipv6;
6926 mp->vrf_id = ntohl (vrf_id);
6931 /* Wait for a reply... */
6936 static void vl_api_sw_interface_get_table_reply_t_handler
6937 (vl_api_sw_interface_get_table_reply_t * mp)
6939 vat_main_t *vam = &vat_main;
6941 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6943 vam->retval = ntohl (mp->retval);
6944 vam->result_ready = 1;
6948 static void vl_api_sw_interface_get_table_reply_t_handler_json
6949 (vl_api_sw_interface_get_table_reply_t * mp)
6951 vat_main_t *vam = &vat_main;
6952 vat_json_node_t node;
6954 vat_json_init_object (&node);
6955 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6956 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6958 vat_json_print (vam->ofp, &node);
6959 vat_json_free (&node);
6961 vam->retval = ntohl (mp->retval);
6962 vam->result_ready = 1;
6966 api_sw_interface_get_table (vat_main_t * vam)
6968 unformat_input_t *i = vam->input;
6969 vl_api_sw_interface_get_table_t *mp;
6971 u8 sw_if_index_set = 0;
6975 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6977 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6978 sw_if_index_set = 1;
6979 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6980 sw_if_index_set = 1;
6981 else if (unformat (i, "ipv6"))
6987 if (sw_if_index_set == 0)
6989 errmsg ("missing interface name or sw_if_index");
6993 M (SW_INTERFACE_GET_TABLE, mp);
6994 mp->sw_if_index = htonl (sw_if_index);
6995 mp->is_ipv6 = is_ipv6;
7003 api_sw_interface_set_vpath (vat_main_t * vam)
7005 unformat_input_t *i = vam->input;
7006 vl_api_sw_interface_set_vpath_t *mp;
7007 u32 sw_if_index = 0;
7008 u8 sw_if_index_set = 0;
7012 /* Parse args required to build the message */
7013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7015 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7016 sw_if_index_set = 1;
7017 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7018 sw_if_index_set = 1;
7019 else if (unformat (i, "enable"))
7021 else if (unformat (i, "disable"))
7027 if (sw_if_index_set == 0)
7029 errmsg ("missing interface name or sw_if_index");
7033 /* Construct the API message */
7034 M (SW_INTERFACE_SET_VPATH, mp);
7036 mp->sw_if_index = ntohl (sw_if_index);
7037 mp->enable = is_enable;
7042 /* Wait for a reply... */
7048 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
7050 unformat_input_t *i = vam->input;
7051 vl_api_sw_interface_set_vxlan_bypass_t *mp;
7052 u32 sw_if_index = 0;
7053 u8 sw_if_index_set = 0;
7058 /* Parse args required to build the message */
7059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7061 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7062 sw_if_index_set = 1;
7063 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7064 sw_if_index_set = 1;
7065 else if (unformat (i, "enable"))
7067 else if (unformat (i, "disable"))
7069 else if (unformat (i, "ip4"))
7071 else if (unformat (i, "ip6"))
7077 if (sw_if_index_set == 0)
7079 errmsg ("missing interface name or sw_if_index");
7083 /* Construct the API message */
7084 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
7086 mp->sw_if_index = ntohl (sw_if_index);
7087 mp->enable = is_enable;
7088 mp->is_ipv6 = is_ipv6;
7093 /* Wait for a reply... */
7099 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
7101 unformat_input_t *i = vam->input;
7102 vl_api_sw_interface_set_geneve_bypass_t *mp;
7103 u32 sw_if_index = 0;
7104 u8 sw_if_index_set = 0;
7109 /* Parse args required to build the message */
7110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7112 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7113 sw_if_index_set = 1;
7114 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7115 sw_if_index_set = 1;
7116 else if (unformat (i, "enable"))
7118 else if (unformat (i, "disable"))
7120 else if (unformat (i, "ip4"))
7122 else if (unformat (i, "ip6"))
7128 if (sw_if_index_set == 0)
7130 errmsg ("missing interface name or sw_if_index");
7134 /* Construct the API message */
7135 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
7137 mp->sw_if_index = ntohl (sw_if_index);
7138 mp->enable = is_enable;
7139 mp->is_ipv6 = is_ipv6;
7144 /* Wait for a reply... */
7150 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
7152 unformat_input_t *i = vam->input;
7153 vl_api_sw_interface_set_l2_xconnect_t *mp;
7155 u8 rx_sw_if_index_set = 0;
7157 u8 tx_sw_if_index_set = 0;
7161 /* Parse args required to build the message */
7162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7164 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7165 rx_sw_if_index_set = 1;
7166 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7167 tx_sw_if_index_set = 1;
7168 else if (unformat (i, "rx"))
7170 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7174 rx_sw_if_index_set = 1;
7179 else if (unformat (i, "tx"))
7181 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7183 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7185 tx_sw_if_index_set = 1;
7190 else if (unformat (i, "enable"))
7192 else if (unformat (i, "disable"))
7198 if (rx_sw_if_index_set == 0)
7200 errmsg ("missing rx interface name or rx_sw_if_index");
7204 if (enable && (tx_sw_if_index_set == 0))
7206 errmsg ("missing tx interface name or tx_sw_if_index");
7210 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
7212 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7213 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7214 mp->enable = enable;
7222 api_sw_interface_set_l2_bridge (vat_main_t * vam)
7224 unformat_input_t *i = vam->input;
7225 vl_api_sw_interface_set_l2_bridge_t *mp;
7227 u8 rx_sw_if_index_set = 0;
7235 /* Parse args required to build the message */
7236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7238 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
7239 rx_sw_if_index_set = 1;
7240 else if (unformat (i, "bd_id %d", &bd_id))
7244 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
7245 rx_sw_if_index_set = 1;
7246 else if (unformat (i, "shg %d", &shg))
7248 else if (unformat (i, "bvi"))
7250 else if (unformat (i, "enable"))
7252 else if (unformat (i, "disable"))
7258 if (rx_sw_if_index_set == 0)
7260 errmsg ("missing rx interface name or sw_if_index");
7264 if (enable && (bd_id_set == 0))
7266 errmsg ("missing bridge domain");
7270 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
7272 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7273 mp->bd_id = ntohl (bd_id);
7276 mp->enable = enable;
7284 api_bridge_domain_dump (vat_main_t * vam)
7286 unformat_input_t *i = vam->input;
7287 vl_api_bridge_domain_dump_t *mp;
7288 vl_api_control_ping_t *mp_ping;
7292 /* Parse args required to build the message */
7293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7295 if (unformat (i, "bd_id %d", &bd_id))
7301 M (BRIDGE_DOMAIN_DUMP, mp);
7302 mp->bd_id = ntohl (bd_id);
7305 /* Use a control ping for synchronization */
7306 MPING (CONTROL_PING, mp_ping);
7314 api_bridge_domain_add_del (vat_main_t * vam)
7316 unformat_input_t *i = vam->input;
7317 vl_api_bridge_domain_add_del_t *mp;
7320 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7325 /* Parse args required to build the message */
7326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7328 if (unformat (i, "bd_id %d", &bd_id))
7330 else if (unformat (i, "flood %d", &flood))
7332 else if (unformat (i, "uu-flood %d", &uu_flood))
7334 else if (unformat (i, "forward %d", &forward))
7336 else if (unformat (i, "learn %d", &learn))
7338 else if (unformat (i, "arp-term %d", &arp_term))
7340 else if (unformat (i, "mac-age %d", &mac_age))
7342 else if (unformat (i, "bd-tag %s", &bd_tag))
7344 else if (unformat (i, "del"))
7347 flood = uu_flood = forward = learn = 0;
7355 errmsg ("missing bridge domain");
7362 errmsg ("mac age must be less than 256 ");
7367 if ((bd_tag) && (vec_len (bd_tag) > 63))
7369 errmsg ("bd-tag cannot be longer than 63");
7374 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7376 mp->bd_id = ntohl (bd_id);
7378 mp->uu_flood = uu_flood;
7379 mp->forward = forward;
7381 mp->arp_term = arp_term;
7382 mp->is_add = is_add;
7383 mp->mac_age = (u8) mac_age;
7386 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
7387 mp->bd_tag[vec_len (bd_tag)] = 0;
7398 api_l2fib_flush_bd (vat_main_t * vam)
7400 unformat_input_t *i = vam->input;
7401 vl_api_l2fib_flush_bd_t *mp;
7405 /* Parse args required to build the message */
7406 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7408 if (unformat (i, "bd_id %d", &bd_id));
7415 errmsg ("missing bridge domain");
7419 M (L2FIB_FLUSH_BD, mp);
7421 mp->bd_id = htonl (bd_id);
7429 api_l2fib_flush_int (vat_main_t * vam)
7431 unformat_input_t *i = vam->input;
7432 vl_api_l2fib_flush_int_t *mp;
7433 u32 sw_if_index = ~0;
7436 /* Parse args required to build the message */
7437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7439 if (unformat (i, "sw_if_index %d", &sw_if_index));
7441 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7446 if (sw_if_index == ~0)
7448 errmsg ("missing interface name or sw_if_index");
7452 M (L2FIB_FLUSH_INT, mp);
7454 mp->sw_if_index = ntohl (sw_if_index);
7462 api_l2fib_add_del (vat_main_t * vam)
7464 unformat_input_t *i = vam->input;
7465 vl_api_l2fib_add_del_t *mp;
7471 u32 sw_if_index = ~0;
7472 u8 sw_if_index_set = 0;
7481 /* Parse args required to build the message */
7482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7484 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7486 else if (unformat (i, "bd_id %d", &bd_id))
7488 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7489 sw_if_index_set = 1;
7490 else if (unformat (i, "sw_if"))
7492 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7495 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7496 sw_if_index_set = 1;
7501 else if (unformat (i, "static"))
7503 else if (unformat (i, "filter"))
7508 else if (unformat (i, "bvi"))
7513 else if (unformat (i, "del"))
7515 else if (unformat (i, "count %d", &count))
7523 errmsg ("missing mac address");
7529 errmsg ("missing bridge domain");
7533 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7535 errmsg ("missing interface name or sw_if_index");
7541 /* Turn on async mode */
7542 vam->async_mode = 1;
7543 vam->async_errors = 0;
7544 before = vat_time_now (vam);
7547 for (j = 0; j < count; j++)
7549 M (L2FIB_ADD_DEL, mp);
7551 clib_memcpy (mp->mac, mac, 6);
7552 mp->bd_id = ntohl (bd_id);
7553 mp->is_add = is_add;
7557 mp->sw_if_index = ntohl (sw_if_index);
7558 mp->static_mac = static_mac;
7559 mp->filter_mac = filter_mac;
7560 mp->bvi_mac = bvi_mac;
7562 increment_mac_address (mac);
7569 vl_api_control_ping_t *mp_ping;
7572 /* Shut off async mode */
7573 vam->async_mode = 0;
7575 MPING (CONTROL_PING, mp_ping);
7578 timeout = vat_time_now (vam) + 1.0;
7579 while (vat_time_now (vam) < timeout)
7580 if (vam->result_ready == 1)
7585 if (vam->retval == -99)
7588 if (vam->async_errors > 0)
7590 errmsg ("%d asynchronous errors", vam->async_errors);
7593 vam->async_errors = 0;
7594 after = vat_time_now (vam);
7596 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7597 count, after - before, count / (after - before));
7603 /* Wait for a reply... */
7607 /* Return the good/bad news */
7608 return (vam->retval);
7612 api_bridge_domain_set_mac_age (vat_main_t * vam)
7614 unformat_input_t *i = vam->input;
7615 vl_api_bridge_domain_set_mac_age_t *mp;
7620 /* Parse args required to build the message */
7621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7623 if (unformat (i, "bd_id %d", &bd_id));
7624 else if (unformat (i, "mac-age %d", &mac_age));
7631 errmsg ("missing bridge domain");
7637 errmsg ("mac age must be less than 256 ");
7641 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7643 mp->bd_id = htonl (bd_id);
7644 mp->mac_age = (u8) mac_age;
7652 api_l2_flags (vat_main_t * vam)
7654 unformat_input_t *i = vam->input;
7655 vl_api_l2_flags_t *mp;
7658 u8 sw_if_index_set = 0;
7662 /* Parse args required to build the message */
7663 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7665 if (unformat (i, "sw_if_index %d", &sw_if_index))
7666 sw_if_index_set = 1;
7667 else if (unformat (i, "sw_if"))
7669 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7672 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7673 sw_if_index_set = 1;
7678 else if (unformat (i, "learn"))
7680 else if (unformat (i, "forward"))
7682 else if (unformat (i, "flood"))
7684 else if (unformat (i, "uu-flood"))
7685 flags |= L2_UU_FLOOD;
7686 else if (unformat (i, "arp-term"))
7687 flags |= L2_ARP_TERM;
7688 else if (unformat (i, "off"))
7690 else if (unformat (i, "disable"))
7696 if (sw_if_index_set == 0)
7698 errmsg ("missing interface name or sw_if_index");
7704 mp->sw_if_index = ntohl (sw_if_index);
7705 mp->feature_bitmap = ntohl (flags);
7706 mp->is_set = is_set;
7714 api_bridge_flags (vat_main_t * vam)
7716 unformat_input_t *i = vam->input;
7717 vl_api_bridge_flags_t *mp;
7724 /* Parse args required to build the message */
7725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7727 if (unformat (i, "bd_id %d", &bd_id))
7729 else if (unformat (i, "learn"))
7731 else if (unformat (i, "forward"))
7733 else if (unformat (i, "flood"))
7735 else if (unformat (i, "uu-flood"))
7736 flags |= L2_UU_FLOOD;
7737 else if (unformat (i, "arp-term"))
7738 flags |= L2_ARP_TERM;
7739 else if (unformat (i, "off"))
7741 else if (unformat (i, "disable"))
7749 errmsg ("missing bridge domain");
7753 M (BRIDGE_FLAGS, mp);
7755 mp->bd_id = ntohl (bd_id);
7756 mp->feature_bitmap = ntohl (flags);
7757 mp->is_set = is_set;
7765 api_bd_ip_mac_add_del (vat_main_t * vam)
7767 unformat_input_t *i = vam->input;
7768 vl_api_bd_ip_mac_add_del_t *mp;
7775 ip4_address_t v4addr;
7776 ip6_address_t v6addr;
7781 /* Parse args required to build the message */
7782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7784 if (unformat (i, "bd_id %d", &bd_id))
7788 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7792 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7797 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7801 else if (unformat (i, "del"))
7809 errmsg ("missing bridge domain");
7812 else if (ip_set == 0)
7814 errmsg ("missing IP address");
7817 else if (mac_set == 0)
7819 errmsg ("missing MAC address");
7823 M (BD_IP_MAC_ADD_DEL, mp);
7825 mp->bd_id = ntohl (bd_id);
7826 mp->is_ipv6 = is_ipv6;
7827 mp->is_add = is_add;
7829 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7831 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7832 clib_memcpy (mp->mac_address, macaddr, 6);
7839 api_tap_connect (vat_main_t * vam)
7841 unformat_input_t *i = vam->input;
7842 vl_api_tap_connect_t *mp;
7848 ip4_address_t ip4_address;
7850 int ip4_address_set = 0;
7851 ip6_address_t ip6_address;
7853 int ip6_address_set = 0;
7856 memset (mac_address, 0, sizeof (mac_address));
7858 /* Parse args required to build the message */
7859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7861 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7865 else if (unformat (i, "random-mac"))
7867 else if (unformat (i, "tapname %s", &tap_name))
7869 else if (unformat (i, "tag %s", &tag))
7871 else if (unformat (i, "address %U/%d",
7872 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7873 ip4_address_set = 1;
7874 else if (unformat (i, "address %U/%d",
7875 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7876 ip6_address_set = 1;
7883 errmsg ("missing tap name");
7886 if (vec_len (tap_name) > 63)
7888 errmsg ("tap name too long");
7891 vec_add1 (tap_name, 0);
7893 if (vec_len (tag) > 63)
7895 errmsg ("tag too long");
7899 /* Construct the API message */
7900 M (TAP_CONNECT, mp);
7902 mp->use_random_mac = random_mac;
7903 clib_memcpy (mp->mac_address, mac_address, 6);
7904 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7906 clib_memcpy (mp->tag, tag, vec_len (tag));
7908 if (ip4_address_set)
7910 mp->ip4_address_set = 1;
7911 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7912 mp->ip4_mask_width = ip4_mask_width;
7914 if (ip6_address_set)
7916 mp->ip6_address_set = 1;
7917 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7918 mp->ip6_mask_width = ip6_mask_width;
7921 vec_free (tap_name);
7927 /* Wait for a reply... */
7933 api_tap_modify (vat_main_t * vam)
7935 unformat_input_t *i = vam->input;
7936 vl_api_tap_modify_t *mp;
7941 u32 sw_if_index = ~0;
7942 u8 sw_if_index_set = 0;
7945 memset (mac_address, 0, sizeof (mac_address));
7947 /* Parse args required to build the message */
7948 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7950 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7951 sw_if_index_set = 1;
7952 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7953 sw_if_index_set = 1;
7954 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7958 else if (unformat (i, "random-mac"))
7960 else if (unformat (i, "tapname %s", &tap_name))
7966 if (sw_if_index_set == 0)
7968 errmsg ("missing vpp interface name");
7973 errmsg ("missing tap name");
7976 if (vec_len (tap_name) > 63)
7978 errmsg ("tap name too long");
7980 vec_add1 (tap_name, 0);
7982 /* Construct the API message */
7985 mp->use_random_mac = random_mac;
7986 mp->sw_if_index = ntohl (sw_if_index);
7987 clib_memcpy (mp->mac_address, mac_address, 6);
7988 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7989 vec_free (tap_name);
7994 /* Wait for a reply... */
8000 api_tap_delete (vat_main_t * vam)
8002 unformat_input_t *i = vam->input;
8003 vl_api_tap_delete_t *mp;
8004 u32 sw_if_index = ~0;
8005 u8 sw_if_index_set = 0;
8008 /* Parse args required to build the message */
8009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8012 sw_if_index_set = 1;
8013 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8014 sw_if_index_set = 1;
8019 if (sw_if_index_set == 0)
8021 errmsg ("missing vpp interface name");
8025 /* Construct the API message */
8028 mp->sw_if_index = ntohl (sw_if_index);
8033 /* Wait for a reply... */
8039 api_tap_create_v2 (vat_main_t * vam)
8041 unformat_input_t *i = vam->input;
8042 vl_api_tap_create_v2_t *mp;
8046 u8 *host_if_name = 0;
8048 u8 host_mac_addr[6];
8049 u8 host_mac_addr_set = 0;
8050 u8 *host_bridge = 0;
8051 ip4_address_t host_ip4_addr;
8052 ip4_address_t host_ip4_gw;
8053 u8 host_ip4_gw_set = 0;
8054 u32 host_ip4_prefix_len = 0;
8055 ip6_address_t host_ip6_addr;
8056 ip6_address_t host_ip6_gw;
8057 u8 host_ip6_gw_set = 0;
8058 u32 host_ip6_prefix_len = 0;
8060 u32 rx_ring_sz = 0, tx_ring_sz = 0;
8062 memset (mac_address, 0, sizeof (mac_address));
8064 /* Parse args required to build the message */
8065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8067 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
8071 else if (unformat (i, "id %u", &id))
8073 else if (unformat (i, "host-if-name %s", &host_if_name))
8075 else if (unformat (i, "host-ns %s", &host_ns))
8077 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
8079 host_mac_addr_set = 1;
8080 else if (unformat (i, "host-bridge %s", &host_bridge))
8082 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
8083 &host_ip4_addr, &host_ip4_prefix_len))
8085 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
8086 &host_ip6_addr, &host_ip6_prefix_len))
8088 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
8090 host_ip4_gw_set = 1;
8091 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
8093 host_ip6_gw_set = 1;
8094 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
8096 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
8102 if (vec_len (host_if_name) > 63)
8104 errmsg ("tap name too long. ");
8107 if (vec_len (host_ns) > 63)
8109 errmsg ("host name space too long. ");
8112 if (vec_len (host_bridge) > 63)
8114 errmsg ("host bridge name too long. ");
8117 if (host_ip4_prefix_len > 32)
8119 errmsg ("host ip4 prefix length not valid. ");
8122 if (host_ip6_prefix_len > 128)
8124 errmsg ("host ip6 prefix length not valid. ");
8127 if (!is_pow2 (rx_ring_sz))
8129 errmsg ("rx ring size must be power of 2. ");
8132 if (rx_ring_sz > 32768)
8134 errmsg ("rx ring size must be 32768 or lower. ");
8137 if (!is_pow2 (tx_ring_sz))
8139 errmsg ("tx ring size must be power of 2. ");
8142 if (tx_ring_sz > 32768)
8144 errmsg ("tx ring size must be 32768 or lower. ");
8148 /* Construct the API message */
8149 M (TAP_CREATE_V2, mp);
8151 mp->use_random_mac = random_mac;
8153 mp->id = ntohl (id);
8154 mp->host_namespace_set = host_ns != 0;
8155 mp->host_bridge_set = host_bridge != 0;
8156 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
8157 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
8158 mp->rx_ring_sz = ntohs (rx_ring_sz);
8159 mp->tx_ring_sz = ntohs (tx_ring_sz);
8161 if (random_mac == 0)
8162 clib_memcpy (mp->mac_address, mac_address, 6);
8163 if (host_mac_addr_set)
8164 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
8166 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
8168 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
8170 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
8171 if (host_ip4_prefix_len)
8172 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
8173 if (host_ip4_prefix_len)
8174 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
8175 if (host_ip4_gw_set)
8176 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
8177 if (host_ip6_gw_set)
8178 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
8181 vec_free (host_if_name);
8182 vec_free (host_bridge);
8187 /* Wait for a reply... */
8193 api_tap_delete_v2 (vat_main_t * vam)
8195 unformat_input_t *i = vam->input;
8196 vl_api_tap_delete_v2_t *mp;
8197 u32 sw_if_index = ~0;
8198 u8 sw_if_index_set = 0;
8201 /* Parse args required to build the message */
8202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8205 sw_if_index_set = 1;
8206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8207 sw_if_index_set = 1;
8212 if (sw_if_index_set == 0)
8214 errmsg ("missing vpp interface name. ");
8218 /* Construct the API message */
8219 M (TAP_DELETE_V2, mp);
8221 mp->sw_if_index = ntohl (sw_if_index);
8226 /* Wait for a reply... */
8232 api_bond_create (vat_main_t * vam)
8234 unformat_input_t *i = vam->input;
8235 vl_api_bond_create_t *mp;
8243 memset (mac_address, 0, sizeof (mac_address));
8246 /* Parse args required to build the message */
8247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8249 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
8251 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
8252 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
8254 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
8261 if (mode_is_set == 0)
8263 errmsg ("Missing bond mode. ");
8267 /* Construct the API message */
8268 M (BOND_CREATE, mp);
8270 mp->use_custom_mac = custom_mac;
8276 clib_memcpy (mp->mac_address, mac_address, 6);
8281 /* Wait for a reply... */
8287 api_bond_delete (vat_main_t * vam)
8289 unformat_input_t *i = vam->input;
8290 vl_api_bond_delete_t *mp;
8291 u32 sw_if_index = ~0;
8292 u8 sw_if_index_set = 0;
8295 /* Parse args required to build the message */
8296 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8298 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8299 sw_if_index_set = 1;
8300 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8301 sw_if_index_set = 1;
8306 if (sw_if_index_set == 0)
8308 errmsg ("missing vpp interface name. ");
8312 /* Construct the API message */
8313 M (BOND_DELETE, mp);
8315 mp->sw_if_index = ntohl (sw_if_index);
8320 /* Wait for a reply... */
8326 api_bond_enslave (vat_main_t * vam)
8328 unformat_input_t *i = vam->input;
8329 vl_api_bond_enslave_t *mp;
8330 u32 bond_sw_if_index;
8334 u32 bond_sw_if_index_is_set = 0;
8336 u8 sw_if_index_is_set = 0;
8338 /* Parse args required to build the message */
8339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8341 if (unformat (i, "sw_if_index %d", &sw_if_index))
8342 sw_if_index_is_set = 1;
8343 else if (unformat (i, "bond %u", &bond_sw_if_index))
8344 bond_sw_if_index_is_set = 1;
8345 else if (unformat (i, "passive %d", &is_passive))
8347 else if (unformat (i, "long-timeout %d", &is_long_timeout))
8353 if (bond_sw_if_index_is_set == 0)
8355 errmsg ("Missing bond sw_if_index. ");
8358 if (sw_if_index_is_set == 0)
8360 errmsg ("Missing slave sw_if_index. ");
8364 /* Construct the API message */
8365 M (BOND_ENSLAVE, mp);
8367 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
8368 mp->sw_if_index = ntohl (sw_if_index);
8369 mp->is_long_timeout = is_long_timeout;
8370 mp->is_passive = is_passive;
8375 /* Wait for a reply... */
8381 api_bond_detach_slave (vat_main_t * vam)
8383 unformat_input_t *i = vam->input;
8384 vl_api_bond_detach_slave_t *mp;
8385 u32 sw_if_index = ~0;
8386 u8 sw_if_index_set = 0;
8389 /* Parse args required to build the message */
8390 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8392 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8393 sw_if_index_set = 1;
8394 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8395 sw_if_index_set = 1;
8400 if (sw_if_index_set == 0)
8402 errmsg ("missing vpp interface name. ");
8406 /* Construct the API message */
8407 M (BOND_DETACH_SLAVE, mp);
8409 mp->sw_if_index = ntohl (sw_if_index);
8414 /* Wait for a reply... */
8420 api_ip_table_add_del (vat_main_t * vam)
8422 unformat_input_t *i = vam->input;
8423 vl_api_ip_table_add_del_t *mp;
8429 /* Parse args required to build the message */
8430 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8432 if (unformat (i, "ipv6"))
8434 else if (unformat (i, "del"))
8436 else if (unformat (i, "add"))
8438 else if (unformat (i, "table %d", &table_id))
8442 clib_warning ("parse error '%U'", format_unformat_error, i);
8449 errmsg ("missing table-ID");
8453 /* Construct the API message */
8454 M (IP_TABLE_ADD_DEL, mp);
8456 mp->table_id = ntohl (table_id);
8457 mp->is_ipv6 = is_ipv6;
8458 mp->is_add = is_add;
8463 /* Wait for a reply... */
8470 api_ip_add_del_route (vat_main_t * vam)
8472 unformat_input_t *i = vam->input;
8473 vl_api_ip_add_del_route_t *mp;
8474 u32 sw_if_index = ~0, vrf_id = 0;
8476 u8 is_local = 0, is_drop = 0;
8477 u8 is_unreach = 0, is_prohibit = 0;
8479 u32 next_hop_weight = 1;
8480 u8 is_multipath = 0;
8482 u8 address_length_set = 0;
8483 u32 next_hop_table_id = 0;
8484 u32 resolve_attempts = 0;
8485 u32 dst_address_length = 0;
8486 u8 next_hop_set = 0;
8487 ip4_address_t v4_dst_address, v4_next_hop_address;
8488 ip6_address_t v6_dst_address, v6_next_hop_address;
8492 u32 random_add_del = 0;
8493 u32 *random_vector = 0;
8495 u32 random_seed = 0xdeaddabe;
8496 u32 classify_table_index = ~0;
8498 u8 resolve_host = 0, resolve_attached = 0;
8499 mpls_label_t *next_hop_out_label_stack = NULL;
8500 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8501 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8503 /* Parse args required to build the message */
8504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8506 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8508 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8510 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8515 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8520 else if (unformat (i, "/%d", &dst_address_length))
8522 address_length_set = 1;
8525 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8526 &v4_next_hop_address))
8530 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8531 &v6_next_hop_address))
8535 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8537 else if (unformat (i, "weight %d", &next_hop_weight))
8539 else if (unformat (i, "drop"))
8543 else if (unformat (i, "null-send-unreach"))
8547 else if (unformat (i, "null-send-prohibit"))
8551 else if (unformat (i, "local"))
8555 else if (unformat (i, "classify %d", &classify_table_index))
8559 else if (unformat (i, "del"))
8561 else if (unformat (i, "add"))
8563 else if (unformat (i, "resolve-via-host"))
8565 else if (unformat (i, "resolve-via-attached"))
8566 resolve_attached = 1;
8567 else if (unformat (i, "multipath"))
8569 else if (unformat (i, "vrf %d", &vrf_id))
8571 else if (unformat (i, "count %d", &count))
8573 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8575 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8577 else if (unformat (i, "out-label %d", &next_hop_out_label))
8578 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8579 else if (unformat (i, "via-label %d", &next_hop_via_label))
8581 else if (unformat (i, "random"))
8583 else if (unformat (i, "seed %d", &random_seed))
8587 clib_warning ("parse error '%U'", format_unformat_error, i);
8592 if (!next_hop_set && !is_drop && !is_local &&
8593 !is_classify && !is_unreach && !is_prohibit &&
8594 MPLS_LABEL_INVALID == next_hop_via_label)
8597 ("next hop / local / drop / unreach / prohibit / classify not set");
8601 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8603 errmsg ("next hop and next-hop via label set");
8606 if (address_set == 0)
8608 errmsg ("missing addresses");
8612 if (address_length_set == 0)
8614 errmsg ("missing address length");
8618 /* Generate a pile of unique, random routes */
8621 u32 this_random_address;
8622 random_hash = hash_create (count, sizeof (uword));
8624 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8625 for (j = 0; j <= count; j++)
8629 this_random_address = random_u32 (&random_seed);
8630 this_random_address =
8631 clib_host_to_net_u32 (this_random_address);
8633 while (hash_get (random_hash, this_random_address));
8634 vec_add1 (random_vector, this_random_address);
8635 hash_set (random_hash, this_random_address, 1);
8637 hash_free (random_hash);
8638 v4_dst_address.as_u32 = random_vector[0];
8643 /* Turn on async mode */
8644 vam->async_mode = 1;
8645 vam->async_errors = 0;
8646 before = vat_time_now (vam);
8649 for (j = 0; j < count; j++)
8651 /* Construct the API message */
8652 M2 (IP_ADD_DEL_ROUTE, mp,
8653 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8655 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8656 mp->table_id = ntohl (vrf_id);
8658 mp->is_add = is_add;
8659 mp->is_drop = is_drop;
8660 mp->is_unreach = is_unreach;
8661 mp->is_prohibit = is_prohibit;
8662 mp->is_ipv6 = is_ipv6;
8663 mp->is_local = is_local;
8664 mp->is_classify = is_classify;
8665 mp->is_multipath = is_multipath;
8666 mp->is_resolve_host = resolve_host;
8667 mp->is_resolve_attached = resolve_attached;
8668 mp->next_hop_weight = next_hop_weight;
8669 mp->dst_address_length = dst_address_length;
8670 mp->next_hop_table_id = ntohl (next_hop_table_id);
8671 mp->classify_table_index = ntohl (classify_table_index);
8672 mp->next_hop_via_label = ntohl (next_hop_via_label);
8673 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8674 if (0 != mp->next_hop_n_out_labels)
8676 memcpy (mp->next_hop_out_label_stack,
8677 next_hop_out_label_stack,
8678 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8679 vec_free (next_hop_out_label_stack);
8684 clib_memcpy (mp->dst_address, &v6_dst_address,
8685 sizeof (v6_dst_address));
8687 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8688 sizeof (v6_next_hop_address));
8689 increment_v6_address (&v6_dst_address);
8693 clib_memcpy (mp->dst_address, &v4_dst_address,
8694 sizeof (v4_dst_address));
8696 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8697 sizeof (v4_next_hop_address));
8699 v4_dst_address.as_u32 = random_vector[j + 1];
8701 increment_v4_address (&v4_dst_address);
8705 /* If we receive SIGTERM, stop now... */
8710 /* When testing multiple add/del ops, use a control-ping to sync */
8713 vl_api_control_ping_t *mp_ping;
8717 /* Shut off async mode */
8718 vam->async_mode = 0;
8720 MPING (CONTROL_PING, mp_ping);
8723 timeout = vat_time_now (vam) + 1.0;
8724 while (vat_time_now (vam) < timeout)
8725 if (vam->result_ready == 1)
8730 if (vam->retval == -99)
8733 if (vam->async_errors > 0)
8735 errmsg ("%d asynchronous errors", vam->async_errors);
8738 vam->async_errors = 0;
8739 after = vat_time_now (vam);
8741 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8745 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8746 count, after - before, count / (after - before));
8752 /* Wait for a reply... */
8757 /* Return the good/bad news */
8758 return (vam->retval);
8762 api_ip_mroute_add_del (vat_main_t * vam)
8764 unformat_input_t *i = vam->input;
8765 vl_api_ip_mroute_add_del_t *mp;
8766 u32 sw_if_index = ~0, vrf_id = 0;
8771 u32 grp_address_length = 0;
8772 ip4_address_t v4_grp_address, v4_src_address;
8773 ip6_address_t v6_grp_address, v6_src_address;
8774 mfib_itf_flags_t iflags = 0;
8775 mfib_entry_flags_t eflags = 0;
8778 /* Parse args required to build the message */
8779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8781 if (unformat (i, "sw_if_index %d", &sw_if_index))
8783 else if (unformat (i, "%U %U",
8784 unformat_ip4_address, &v4_src_address,
8785 unformat_ip4_address, &v4_grp_address))
8787 grp_address_length = 64;
8791 else if (unformat (i, "%U %U",
8792 unformat_ip6_address, &v6_src_address,
8793 unformat_ip6_address, &v6_grp_address))
8795 grp_address_length = 256;
8799 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8801 memset (&v4_src_address, 0, sizeof (v4_src_address));
8802 grp_address_length = 32;
8806 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8808 memset (&v6_src_address, 0, sizeof (v6_src_address));
8809 grp_address_length = 128;
8813 else if (unformat (i, "/%d", &grp_address_length))
8815 else if (unformat (i, "local"))
8819 else if (unformat (i, "del"))
8821 else if (unformat (i, "add"))
8823 else if (unformat (i, "vrf %d", &vrf_id))
8825 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8827 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8831 clib_warning ("parse error '%U'", format_unformat_error, i);
8836 if (address_set == 0)
8838 errmsg ("missing addresses\n");
8842 /* Construct the API message */
8843 M (IP_MROUTE_ADD_DEL, mp);
8845 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8846 mp->table_id = ntohl (vrf_id);
8848 mp->is_add = is_add;
8849 mp->is_ipv6 = is_ipv6;
8850 mp->is_local = is_local;
8851 mp->itf_flags = ntohl (iflags);
8852 mp->entry_flags = ntohl (eflags);
8853 mp->grp_address_length = grp_address_length;
8854 mp->grp_address_length = ntohs (mp->grp_address_length);
8858 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8859 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8863 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8864 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8870 /* Wait for a reply... */
8876 api_mpls_table_add_del (vat_main_t * vam)
8878 unformat_input_t *i = vam->input;
8879 vl_api_mpls_table_add_del_t *mp;
8884 /* Parse args required to build the message */
8885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8887 if (unformat (i, "table %d", &table_id))
8889 else if (unformat (i, "del"))
8891 else if (unformat (i, "add"))
8895 clib_warning ("parse error '%U'", format_unformat_error, i);
8902 errmsg ("missing table-ID");
8906 /* Construct the API message */
8907 M (MPLS_TABLE_ADD_DEL, mp);
8909 mp->mt_table_id = ntohl (table_id);
8910 mp->mt_is_add = is_add;
8915 /* Wait for a reply... */
8922 api_mpls_route_add_del (vat_main_t * vam)
8924 unformat_input_t *i = vam->input;
8925 vl_api_mpls_route_add_del_t *mp;
8926 u32 sw_if_index = ~0, table_id = 0;
8928 u32 next_hop_weight = 1;
8929 u8 is_multipath = 0;
8930 u32 next_hop_table_id = 0;
8931 u8 next_hop_set = 0;
8932 ip4_address_t v4_next_hop_address = {
8935 ip6_address_t v6_next_hop_address = { {0} };
8939 u32 classify_table_index = ~0;
8941 u8 resolve_host = 0, resolve_attached = 0;
8942 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8943 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8944 mpls_label_t *next_hop_out_label_stack = NULL;
8945 mpls_label_t local_label = MPLS_LABEL_INVALID;
8947 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8949 /* Parse args required to build the message */
8950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8952 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8954 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8956 else if (unformat (i, "%d", &local_label))
8958 else if (unformat (i, "eos"))
8960 else if (unformat (i, "non-eos"))
8962 else if (unformat (i, "via %U", unformat_ip4_address,
8963 &v4_next_hop_address))
8966 next_hop_proto = DPO_PROTO_IP4;
8968 else if (unformat (i, "via %U", unformat_ip6_address,
8969 &v6_next_hop_address))
8972 next_hop_proto = DPO_PROTO_IP6;
8974 else if (unformat (i, "weight %d", &next_hop_weight))
8976 else if (unformat (i, "classify %d", &classify_table_index))
8980 else if (unformat (i, "del"))
8982 else if (unformat (i, "add"))
8984 else if (unformat (i, "resolve-via-host"))
8986 else if (unformat (i, "resolve-via-attached"))
8987 resolve_attached = 1;
8988 else if (unformat (i, "multipath"))
8990 else if (unformat (i, "count %d", &count))
8992 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8995 next_hop_proto = DPO_PROTO_IP4;
8997 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
9000 next_hop_proto = DPO_PROTO_IP6;
9002 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9004 else if (unformat (i, "via-label %d", &next_hop_via_label))
9006 else if (unformat (i, "out-label %d", &next_hop_out_label))
9007 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
9010 clib_warning ("parse error '%U'", format_unformat_error, i);
9015 if (!next_hop_set && !is_classify)
9017 errmsg ("next hop / classify not set");
9021 if (MPLS_LABEL_INVALID == local_label)
9023 errmsg ("missing label");
9029 /* Turn on async mode */
9030 vam->async_mode = 1;
9031 vam->async_errors = 0;
9032 before = vat_time_now (vam);
9035 for (j = 0; j < count; j++)
9037 /* Construct the API message */
9038 M2 (MPLS_ROUTE_ADD_DEL, mp,
9039 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
9041 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
9042 mp->mr_table_id = ntohl (table_id);
9044 mp->mr_is_add = is_add;
9045 mp->mr_next_hop_proto = next_hop_proto;
9046 mp->mr_is_classify = is_classify;
9047 mp->mr_is_multipath = is_multipath;
9048 mp->mr_is_resolve_host = resolve_host;
9049 mp->mr_is_resolve_attached = resolve_attached;
9050 mp->mr_next_hop_weight = next_hop_weight;
9051 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
9052 mp->mr_classify_table_index = ntohl (classify_table_index);
9053 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
9054 mp->mr_label = ntohl (local_label);
9055 mp->mr_eos = is_eos;
9057 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9058 if (0 != mp->mr_next_hop_n_out_labels)
9060 memcpy (mp->mr_next_hop_out_label_stack,
9061 next_hop_out_label_stack,
9062 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
9063 vec_free (next_hop_out_label_stack);
9068 if (DPO_PROTO_IP4 == next_hop_proto)
9070 clib_memcpy (mp->mr_next_hop,
9071 &v4_next_hop_address,
9072 sizeof (v4_next_hop_address));
9074 else if (DPO_PROTO_IP6 == next_hop_proto)
9077 clib_memcpy (mp->mr_next_hop,
9078 &v6_next_hop_address,
9079 sizeof (v6_next_hop_address));
9086 /* If we receive SIGTERM, stop now... */
9091 /* When testing multiple add/del ops, use a control-ping to sync */
9094 vl_api_control_ping_t *mp_ping;
9098 /* Shut off async mode */
9099 vam->async_mode = 0;
9101 MPING (CONTROL_PING, mp_ping);
9104 timeout = vat_time_now (vam) + 1.0;
9105 while (vat_time_now (vam) < timeout)
9106 if (vam->result_ready == 1)
9111 if (vam->retval == -99)
9114 if (vam->async_errors > 0)
9116 errmsg ("%d asynchronous errors", vam->async_errors);
9119 vam->async_errors = 0;
9120 after = vat_time_now (vam);
9122 /* slim chance, but we might have eaten SIGTERM on the first iteration */
9126 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
9127 count, after - before, count / (after - before));
9133 /* Wait for a reply... */
9138 /* Return the good/bad news */
9139 return (vam->retval);
9143 api_mpls_ip_bind_unbind (vat_main_t * vam)
9145 unformat_input_t *i = vam->input;
9146 vl_api_mpls_ip_bind_unbind_t *mp;
9147 u32 ip_table_id = 0;
9150 ip4_address_t v4_address;
9151 ip6_address_t v6_address;
9154 mpls_label_t local_label = MPLS_LABEL_INVALID;
9157 /* Parse args required to build the message */
9158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9160 if (unformat (i, "%U/%d", unformat_ip4_address,
9161 &v4_address, &address_length))
9166 else if (unformat (i, "%U/%d", unformat_ip6_address,
9167 &v6_address, &address_length))
9172 else if (unformat (i, "%d", &local_label))
9174 else if (unformat (i, "table-id %d", &ip_table_id))
9176 else if (unformat (i, "unbind"))
9178 else if (unformat (i, "bind"))
9182 clib_warning ("parse error '%U'", format_unformat_error, i);
9189 errmsg ("IP addres not set");
9193 if (MPLS_LABEL_INVALID == local_label)
9195 errmsg ("missing label");
9199 /* Construct the API message */
9200 M (MPLS_IP_BIND_UNBIND, mp);
9202 mp->mb_is_bind = is_bind;
9203 mp->mb_is_ip4 = is_ip4;
9204 mp->mb_ip_table_id = ntohl (ip_table_id);
9205 mp->mb_mpls_table_id = 0;
9206 mp->mb_label = ntohl (local_label);
9207 mp->mb_address_length = address_length;
9210 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
9212 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
9217 /* Wait for a reply... */
9223 api_bier_table_add_del (vat_main_t * vam)
9225 unformat_input_t *i = vam->input;
9226 vl_api_bier_table_add_del_t *mp;
9228 u32 set = 0, sub_domain = 0, hdr_len = 3;
9229 mpls_label_t local_label = MPLS_LABEL_INVALID;
9232 /* Parse args required to build the message */
9233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9235 if (unformat (i, "sub-domain %d", &sub_domain))
9237 else if (unformat (i, "set %d", &set))
9239 else if (unformat (i, "label %d", &local_label))
9241 else if (unformat (i, "hdr-len %d", &hdr_len))
9243 else if (unformat (i, "add"))
9245 else if (unformat (i, "del"))
9249 clib_warning ("parse error '%U'", format_unformat_error, i);
9254 if (MPLS_LABEL_INVALID == local_label)
9256 errmsg ("missing label\n");
9260 /* Construct the API message */
9261 M (BIER_TABLE_ADD_DEL, mp);
9263 mp->bt_is_add = is_add;
9264 mp->bt_label = ntohl (local_label);
9265 mp->bt_tbl_id.bt_set = set;
9266 mp->bt_tbl_id.bt_sub_domain = sub_domain;
9267 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
9272 /* Wait for a reply... */
9279 api_bier_route_add_del (vat_main_t * vam)
9281 unformat_input_t *i = vam->input;
9282 vl_api_bier_route_add_del_t *mp;
9284 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
9285 ip4_address_t v4_next_hop_address;
9286 ip6_address_t v6_next_hop_address;
9287 u8 next_hop_set = 0;
9288 u8 next_hop_proto_is_ip4 = 1;
9289 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9292 /* Parse args required to build the message */
9293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9295 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
9297 next_hop_proto_is_ip4 = 1;
9300 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
9302 next_hop_proto_is_ip4 = 0;
9305 if (unformat (i, "sub-domain %d", &sub_domain))
9307 else if (unformat (i, "set %d", &set))
9309 else if (unformat (i, "hdr-len %d", &hdr_len))
9311 else if (unformat (i, "bp %d", &bp))
9313 else if (unformat (i, "add"))
9315 else if (unformat (i, "del"))
9317 else if (unformat (i, "out-label %d", &next_hop_out_label))
9321 clib_warning ("parse error '%U'", format_unformat_error, i);
9326 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9328 errmsg ("next hop / label set\n");
9333 errmsg ("bit=position not set\n");
9337 /* Construct the API message */
9338 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9340 mp->br_is_add = is_add;
9341 mp->br_tbl_id.bt_set = set;
9342 mp->br_tbl_id.bt_sub_domain = sub_domain;
9343 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9344 mp->br_bp = ntohs (bp);
9346 mp->br_paths[0].n_labels = 1;
9347 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9348 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9350 if (next_hop_proto_is_ip4)
9352 clib_memcpy (mp->br_paths[0].next_hop,
9353 &v4_next_hop_address, sizeof (v4_next_hop_address));
9357 clib_memcpy (mp->br_paths[0].next_hop,
9358 &v6_next_hop_address, sizeof (v6_next_hop_address));
9364 /* Wait for a reply... */
9371 api_proxy_arp_add_del (vat_main_t * vam)
9373 unformat_input_t *i = vam->input;
9374 vl_api_proxy_arp_add_del_t *mp;
9377 ip4_address_t lo, hi;
9381 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9383 if (unformat (i, "vrf %d", &vrf_id))
9385 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
9386 unformat_ip4_address, &hi))
9388 else if (unformat (i, "del"))
9392 clib_warning ("parse error '%U'", format_unformat_error, i);
9399 errmsg ("address range not set");
9403 M (PROXY_ARP_ADD_DEL, mp);
9405 mp->vrf_id = ntohl (vrf_id);
9406 mp->is_add = is_add;
9407 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
9408 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
9416 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9418 unformat_input_t *i = vam->input;
9419 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9422 u8 sw_if_index_set = 0;
9425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9427 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9428 sw_if_index_set = 1;
9429 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9430 sw_if_index_set = 1;
9431 else if (unformat (i, "enable"))
9433 else if (unformat (i, "disable"))
9437 clib_warning ("parse error '%U'", format_unformat_error, i);
9442 if (sw_if_index_set == 0)
9444 errmsg ("missing interface name or sw_if_index");
9448 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9450 mp->sw_if_index = ntohl (sw_if_index);
9451 mp->enable_disable = enable;
9459 api_mpls_tunnel_add_del (vat_main_t * vam)
9461 unformat_input_t *i = vam->input;
9462 vl_api_mpls_tunnel_add_del_t *mp;
9466 u32 sw_if_index = ~0;
9467 u32 next_hop_sw_if_index = ~0;
9468 u32 next_hop_proto_is_ip4 = 1;
9470 u32 next_hop_table_id = 0;
9471 ip4_address_t v4_next_hop_address = {
9474 ip6_address_t v6_next_hop_address = { {0} };
9475 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9480 if (unformat (i, "add"))
9482 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9484 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9486 else if (unformat (i, "via %U",
9487 unformat_ip4_address, &v4_next_hop_address))
9489 next_hop_proto_is_ip4 = 1;
9491 else if (unformat (i, "via %U",
9492 unformat_ip6_address, &v6_next_hop_address))
9494 next_hop_proto_is_ip4 = 0;
9496 else if (unformat (i, "l2-only"))
9498 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9500 else if (unformat (i, "out-label %d", &next_hop_out_label))
9501 vec_add1 (labels, ntohl (next_hop_out_label));
9504 clib_warning ("parse error '%U'", format_unformat_error, i);
9509 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9511 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9512 mp->mt_sw_if_index = ntohl (sw_if_index);
9513 mp->mt_is_add = is_add;
9514 mp->mt_l2_only = l2_only;
9515 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9516 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9518 mp->mt_next_hop_n_out_labels = vec_len (labels);
9520 if (0 != mp->mt_next_hop_n_out_labels)
9522 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9523 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9527 if (next_hop_proto_is_ip4)
9529 clib_memcpy (mp->mt_next_hop,
9530 &v4_next_hop_address, sizeof (v4_next_hop_address));
9534 clib_memcpy (mp->mt_next_hop,
9535 &v6_next_hop_address, sizeof (v6_next_hop_address));
9544 api_sw_interface_set_unnumbered (vat_main_t * vam)
9546 unformat_input_t *i = vam->input;
9547 vl_api_sw_interface_set_unnumbered_t *mp;
9549 u32 unnum_sw_index = ~0;
9551 u8 sw_if_index_set = 0;
9554 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9556 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9557 sw_if_index_set = 1;
9558 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9559 sw_if_index_set = 1;
9560 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9562 else if (unformat (i, "del"))
9566 clib_warning ("parse error '%U'", format_unformat_error, i);
9571 if (sw_if_index_set == 0)
9573 errmsg ("missing interface name or sw_if_index");
9577 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9579 mp->sw_if_index = ntohl (sw_if_index);
9580 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9581 mp->is_add = is_add;
9589 api_ip_neighbor_add_del (vat_main_t * vam)
9591 unformat_input_t *i = vam->input;
9592 vl_api_ip_neighbor_add_del_t *mp;
9594 u8 sw_if_index_set = 0;
9597 u8 is_no_fib_entry = 0;
9600 u8 v4_address_set = 0;
9601 u8 v6_address_set = 0;
9602 ip4_address_t v4address;
9603 ip6_address_t v6address;
9606 memset (mac_address, 0, sizeof (mac_address));
9608 /* Parse args required to build the message */
9609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9611 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9615 else if (unformat (i, "del"))
9618 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9619 sw_if_index_set = 1;
9620 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9621 sw_if_index_set = 1;
9622 else if (unformat (i, "is_static"))
9624 else if (unformat (i, "no-fib-entry"))
9625 is_no_fib_entry = 1;
9626 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9628 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9632 clib_warning ("parse error '%U'", format_unformat_error, i);
9637 if (sw_if_index_set == 0)
9639 errmsg ("missing interface name or sw_if_index");
9642 if (v4_address_set && v6_address_set)
9644 errmsg ("both v4 and v6 addresses set");
9647 if (!v4_address_set && !v6_address_set)
9649 errmsg ("no address set");
9653 /* Construct the API message */
9654 M (IP_NEIGHBOR_ADD_DEL, mp);
9656 mp->sw_if_index = ntohl (sw_if_index);
9657 mp->is_add = is_add;
9658 mp->is_static = is_static;
9659 mp->is_no_adj_fib = is_no_fib_entry;
9661 clib_memcpy (mp->mac_address, mac_address, 6);
9665 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9669 /* mp->is_ipv6 = 0; via memset in M macro above */
9670 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9676 /* Wait for a reply, return good/bad news */
9682 api_create_vlan_subif (vat_main_t * vam)
9684 unformat_input_t *i = vam->input;
9685 vl_api_create_vlan_subif_t *mp;
9687 u8 sw_if_index_set = 0;
9692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9694 if (unformat (i, "sw_if_index %d", &sw_if_index))
9695 sw_if_index_set = 1;
9697 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9698 sw_if_index_set = 1;
9699 else if (unformat (i, "vlan %d", &vlan_id))
9703 clib_warning ("parse error '%U'", format_unformat_error, i);
9708 if (sw_if_index_set == 0)
9710 errmsg ("missing interface name or sw_if_index");
9714 if (vlan_id_set == 0)
9716 errmsg ("missing vlan_id");
9719 M (CREATE_VLAN_SUBIF, mp);
9721 mp->sw_if_index = ntohl (sw_if_index);
9722 mp->vlan_id = ntohl (vlan_id);
9729 #define foreach_create_subif_bit \
9736 _(outer_vlan_id_any) \
9737 _(inner_vlan_id_any)
9740 api_create_subif (vat_main_t * vam)
9742 unformat_input_t *i = vam->input;
9743 vl_api_create_subif_t *mp;
9745 u8 sw_if_index_set = 0;
9752 u32 exact_match = 0;
9753 u32 default_sub = 0;
9754 u32 outer_vlan_id_any = 0;
9755 u32 inner_vlan_id_any = 0;
9757 u16 outer_vlan_id = 0;
9758 u16 inner_vlan_id = 0;
9761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9763 if (unformat (i, "sw_if_index %d", &sw_if_index))
9764 sw_if_index_set = 1;
9766 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9767 sw_if_index_set = 1;
9768 else if (unformat (i, "sub_id %d", &sub_id))
9770 else if (unformat (i, "outer_vlan_id %d", &tmp))
9771 outer_vlan_id = tmp;
9772 else if (unformat (i, "inner_vlan_id %d", &tmp))
9773 inner_vlan_id = tmp;
9775 #define _(a) else if (unformat (i, #a)) a = 1 ;
9776 foreach_create_subif_bit
9780 clib_warning ("parse error '%U'", format_unformat_error, i);
9785 if (sw_if_index_set == 0)
9787 errmsg ("missing interface name or sw_if_index");
9791 if (sub_id_set == 0)
9793 errmsg ("missing sub_id");
9796 M (CREATE_SUBIF, mp);
9798 mp->sw_if_index = ntohl (sw_if_index);
9799 mp->sub_id = ntohl (sub_id);
9801 #define _(a) mp->a = a;
9802 foreach_create_subif_bit;
9805 mp->outer_vlan_id = ntohs (outer_vlan_id);
9806 mp->inner_vlan_id = ntohs (inner_vlan_id);
9814 api_oam_add_del (vat_main_t * vam)
9816 unformat_input_t *i = vam->input;
9817 vl_api_oam_add_del_t *mp;
9820 ip4_address_t src, dst;
9825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9827 if (unformat (i, "vrf %d", &vrf_id))
9829 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9831 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9833 else if (unformat (i, "del"))
9837 clib_warning ("parse error '%U'", format_unformat_error, i);
9844 errmsg ("missing src addr");
9850 errmsg ("missing dst addr");
9854 M (OAM_ADD_DEL, mp);
9856 mp->vrf_id = ntohl (vrf_id);
9857 mp->is_add = is_add;
9858 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9859 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9867 api_reset_fib (vat_main_t * vam)
9869 unformat_input_t *i = vam->input;
9870 vl_api_reset_fib_t *mp;
9876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9878 if (unformat (i, "vrf %d", &vrf_id))
9880 else if (unformat (i, "ipv6"))
9884 clib_warning ("parse error '%U'", format_unformat_error, i);
9889 if (vrf_id_set == 0)
9891 errmsg ("missing vrf id");
9897 mp->vrf_id = ntohl (vrf_id);
9898 mp->is_ipv6 = is_ipv6;
9906 api_dhcp_proxy_config (vat_main_t * vam)
9908 unformat_input_t *i = vam->input;
9909 vl_api_dhcp_proxy_config_t *mp;
9911 u32 server_vrf_id = 0;
9913 u8 v4_address_set = 0;
9914 u8 v6_address_set = 0;
9915 ip4_address_t v4address;
9916 ip6_address_t v6address;
9917 u8 v4_src_address_set = 0;
9918 u8 v6_src_address_set = 0;
9919 ip4_address_t v4srcaddress;
9920 ip6_address_t v6srcaddress;
9923 /* Parse args required to build the message */
9924 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9926 if (unformat (i, "del"))
9928 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9930 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9932 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9934 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9936 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9937 v4_src_address_set = 1;
9938 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9939 v6_src_address_set = 1;
9944 if (v4_address_set && v6_address_set)
9946 errmsg ("both v4 and v6 server addresses set");
9949 if (!v4_address_set && !v6_address_set)
9951 errmsg ("no server addresses set");
9955 if (v4_src_address_set && v6_src_address_set)
9957 errmsg ("both v4 and v6 src addresses set");
9960 if (!v4_src_address_set && !v6_src_address_set)
9962 errmsg ("no src addresses set");
9966 if (!(v4_src_address_set && v4_address_set) &&
9967 !(v6_src_address_set && v6_address_set))
9969 errmsg ("no matching server and src addresses set");
9973 /* Construct the API message */
9974 M (DHCP_PROXY_CONFIG, mp);
9976 mp->is_add = is_add;
9977 mp->rx_vrf_id = ntohl (rx_vrf_id);
9978 mp->server_vrf_id = ntohl (server_vrf_id);
9982 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9983 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9987 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9988 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9994 /* Wait for a reply, return good/bad news */
9999 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
10000 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
10003 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
10005 vat_main_t *vam = &vat_main;
10006 u32 i, count = mp->count;
10007 vl_api_dhcp_server_t *s;
10011 "RX Table-ID %d, Source Address %U, VSS Type %d, "
10012 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
10013 ntohl (mp->rx_vrf_id),
10014 format_ip6_address, mp->dhcp_src_address,
10015 mp->vss_type, mp->vss_vpn_ascii_id,
10016 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
10019 "RX Table-ID %d, Source Address %U, VSS Type %d, "
10020 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
10021 ntohl (mp->rx_vrf_id),
10022 format_ip4_address, mp->dhcp_src_address,
10023 mp->vss_type, mp->vss_vpn_ascii_id,
10024 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
10026 for (i = 0; i < count; i++)
10028 s = &mp->servers[i];
10032 " Server Table-ID %d, Server Address %U",
10033 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
10036 " Server Table-ID %d, Server Address %U",
10037 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
10041 static void vl_api_dhcp_proxy_details_t_handler_json
10042 (vl_api_dhcp_proxy_details_t * mp)
10044 vat_main_t *vam = &vat_main;
10045 vat_json_node_t *node = NULL;
10046 u32 i, count = mp->count;
10047 struct in_addr ip4;
10048 struct in6_addr ip6;
10049 vl_api_dhcp_server_t *s;
10051 if (VAT_JSON_ARRAY != vam->json_tree.type)
10053 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10054 vat_json_init_array (&vam->json_tree);
10056 node = vat_json_array_add (&vam->json_tree);
10058 vat_json_init_object (node);
10059 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
10060 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
10061 sizeof (mp->vss_type));
10062 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
10063 mp->vss_vpn_ascii_id);
10064 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
10065 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
10069 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
10070 vat_json_object_add_ip6 (node, "src_address", ip6);
10074 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
10075 vat_json_object_add_ip4 (node, "src_address", ip4);
10078 for (i = 0; i < count; i++)
10080 s = &mp->servers[i];
10082 vat_json_object_add_uint (node, "server-table-id",
10083 ntohl (s->server_vrf_id));
10087 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
10088 vat_json_object_add_ip4 (node, "src_address", ip4);
10092 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
10093 vat_json_object_add_ip6 (node, "server_address", ip6);
10099 api_dhcp_proxy_dump (vat_main_t * vam)
10101 unformat_input_t *i = vam->input;
10102 vl_api_control_ping_t *mp_ping;
10103 vl_api_dhcp_proxy_dump_t *mp;
10107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10109 if (unformat (i, "ipv6"))
10113 clib_warning ("parse error '%U'", format_unformat_error, i);
10118 M (DHCP_PROXY_DUMP, mp);
10120 mp->is_ip6 = is_ipv6;
10123 /* Use a control ping for synchronization */
10124 MPING (CONTROL_PING, mp_ping);
10132 api_dhcp_proxy_set_vss (vat_main_t * vam)
10134 unformat_input_t *i = vam->input;
10135 vl_api_dhcp_proxy_set_vss_t *mp;
10139 u8 vss_type = VSS_TYPE_DEFAULT;
10140 u8 *vpn_ascii_id = 0;
10145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10147 if (unformat (i, "tbl_id %d", &tbl_id))
10149 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
10150 vss_type = VSS_TYPE_ASCII;
10151 else if (unformat (i, "fib_id %d", &fib_id))
10152 vss_type = VSS_TYPE_VPN_ID;
10153 else if (unformat (i, "oui %d", &oui))
10154 vss_type = VSS_TYPE_VPN_ID;
10155 else if (unformat (i, "ipv6"))
10157 else if (unformat (i, "del"))
10165 errmsg ("missing tbl_id ");
10166 vec_free (vpn_ascii_id);
10170 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
10172 errmsg ("vpn_ascii_id cannot be longer than 128 ");
10173 vec_free (vpn_ascii_id);
10177 M (DHCP_PROXY_SET_VSS, mp);
10178 mp->tbl_id = ntohl (tbl_id);
10179 mp->vss_type = vss_type;
10182 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
10183 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
10185 mp->vpn_index = ntohl (fib_id);
10186 mp->oui = ntohl (oui);
10187 mp->is_ipv6 = is_ipv6;
10188 mp->is_add = is_add;
10193 vec_free (vpn_ascii_id);
10198 api_dhcp_client_config (vat_main_t * vam)
10200 unformat_input_t *i = vam->input;
10201 vl_api_dhcp_client_config_t *mp;
10203 u8 sw_if_index_set = 0;
10206 u8 disable_event = 0;
10209 /* Parse args required to build the message */
10210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10212 if (unformat (i, "del"))
10215 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10216 sw_if_index_set = 1;
10217 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10218 sw_if_index_set = 1;
10219 else if (unformat (i, "hostname %s", &hostname))
10221 else if (unformat (i, "disable_event"))
10227 if (sw_if_index_set == 0)
10229 errmsg ("missing interface name or sw_if_index");
10233 if (vec_len (hostname) > 63)
10235 errmsg ("hostname too long");
10237 vec_add1 (hostname, 0);
10239 /* Construct the API message */
10240 M (DHCP_CLIENT_CONFIG, mp);
10242 mp->sw_if_index = htonl (sw_if_index);
10243 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
10244 vec_free (hostname);
10245 mp->is_add = is_add;
10246 mp->want_dhcp_event = disable_event ? 0 : 1;
10247 mp->pid = htonl (getpid ());
10252 /* Wait for a reply, return good/bad news */
10258 api_set_ip_flow_hash (vat_main_t * vam)
10260 unformat_input_t *i = vam->input;
10261 vl_api_set_ip_flow_hash_t *mp;
10273 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10275 if (unformat (i, "vrf %d", &vrf_id))
10277 else if (unformat (i, "ipv6"))
10279 else if (unformat (i, "src"))
10281 else if (unformat (i, "dst"))
10283 else if (unformat (i, "sport"))
10285 else if (unformat (i, "dport"))
10287 else if (unformat (i, "proto"))
10289 else if (unformat (i, "reverse"))
10294 clib_warning ("parse error '%U'", format_unformat_error, i);
10299 if (vrf_id_set == 0)
10301 errmsg ("missing vrf id");
10305 M (SET_IP_FLOW_HASH, mp);
10311 mp->reverse = reverse;
10312 mp->vrf_id = ntohl (vrf_id);
10313 mp->is_ipv6 = is_ipv6;
10321 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
10323 unformat_input_t *i = vam->input;
10324 vl_api_sw_interface_ip6_enable_disable_t *mp;
10326 u8 sw_if_index_set = 0;
10330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10332 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10333 sw_if_index_set = 1;
10334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10335 sw_if_index_set = 1;
10336 else if (unformat (i, "enable"))
10338 else if (unformat (i, "disable"))
10342 clib_warning ("parse error '%U'", format_unformat_error, i);
10347 if (sw_if_index_set == 0)
10349 errmsg ("missing interface name or sw_if_index");
10353 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10355 mp->sw_if_index = ntohl (sw_if_index);
10356 mp->enable = enable;
10364 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
10366 unformat_input_t *i = vam->input;
10367 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
10369 u8 sw_if_index_set = 0;
10370 u8 v6_address_set = 0;
10371 ip6_address_t v6address;
10374 /* Parse args required to build the message */
10375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10377 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10378 sw_if_index_set = 1;
10379 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10380 sw_if_index_set = 1;
10381 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
10382 v6_address_set = 1;
10387 if (sw_if_index_set == 0)
10389 errmsg ("missing interface name or sw_if_index");
10392 if (!v6_address_set)
10394 errmsg ("no address set");
10398 /* Construct the API message */
10399 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
10401 mp->sw_if_index = ntohl (sw_if_index);
10402 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10407 /* Wait for a reply, return good/bad news */
10413 api_ip6nd_proxy_add_del (vat_main_t * vam)
10415 unformat_input_t *i = vam->input;
10416 vl_api_ip6nd_proxy_add_del_t *mp;
10417 u32 sw_if_index = ~0;
10418 u8 v6_address_set = 0;
10419 ip6_address_t v6address;
10423 /* Parse args required to build the message */
10424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10426 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10428 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10430 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
10431 v6_address_set = 1;
10432 if (unformat (i, "del"))
10436 clib_warning ("parse error '%U'", format_unformat_error, i);
10441 if (sw_if_index == ~0)
10443 errmsg ("missing interface name or sw_if_index");
10446 if (!v6_address_set)
10448 errmsg ("no address set");
10452 /* Construct the API message */
10453 M (IP6ND_PROXY_ADD_DEL, mp);
10455 mp->is_del = is_del;
10456 mp->sw_if_index = ntohl (sw_if_index);
10457 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10462 /* Wait for a reply, return good/bad news */
10468 api_ip6nd_proxy_dump (vat_main_t * vam)
10470 vl_api_ip6nd_proxy_dump_t *mp;
10471 vl_api_control_ping_t *mp_ping;
10474 M (IP6ND_PROXY_DUMP, mp);
10478 /* Use a control ping for synchronization */
10479 MPING (CONTROL_PING, mp_ping);
10486 static void vl_api_ip6nd_proxy_details_t_handler
10487 (vl_api_ip6nd_proxy_details_t * mp)
10489 vat_main_t *vam = &vat_main;
10491 print (vam->ofp, "host %U sw_if_index %d",
10492 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10495 static void vl_api_ip6nd_proxy_details_t_handler_json
10496 (vl_api_ip6nd_proxy_details_t * mp)
10498 vat_main_t *vam = &vat_main;
10499 struct in6_addr ip6;
10500 vat_json_node_t *node = NULL;
10502 if (VAT_JSON_ARRAY != vam->json_tree.type)
10504 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10505 vat_json_init_array (&vam->json_tree);
10507 node = vat_json_array_add (&vam->json_tree);
10509 vat_json_init_object (node);
10510 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10512 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10513 vat_json_object_add_ip6 (node, "host", ip6);
10517 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10519 unformat_input_t *i = vam->input;
10520 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10522 u8 sw_if_index_set = 0;
10523 u32 address_length = 0;
10524 u8 v6_address_set = 0;
10525 ip6_address_t v6address;
10526 u8 use_default = 0;
10527 u8 no_advertise = 0;
10529 u8 no_autoconfig = 0;
10532 u32 val_lifetime = 0;
10533 u32 pref_lifetime = 0;
10536 /* Parse args required to build the message */
10537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10539 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10540 sw_if_index_set = 1;
10541 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10542 sw_if_index_set = 1;
10543 else if (unformat (i, "%U/%d",
10544 unformat_ip6_address, &v6address, &address_length))
10545 v6_address_set = 1;
10546 else if (unformat (i, "val_life %d", &val_lifetime))
10548 else if (unformat (i, "pref_life %d", &pref_lifetime))
10550 else if (unformat (i, "def"))
10552 else if (unformat (i, "noadv"))
10554 else if (unformat (i, "offl"))
10556 else if (unformat (i, "noauto"))
10558 else if (unformat (i, "nolink"))
10560 else if (unformat (i, "isno"))
10564 clib_warning ("parse error '%U'", format_unformat_error, i);
10569 if (sw_if_index_set == 0)
10571 errmsg ("missing interface name or sw_if_index");
10574 if (!v6_address_set)
10576 errmsg ("no address set");
10580 /* Construct the API message */
10581 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10583 mp->sw_if_index = ntohl (sw_if_index);
10584 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10585 mp->address_length = address_length;
10586 mp->use_default = use_default;
10587 mp->no_advertise = no_advertise;
10588 mp->off_link = off_link;
10589 mp->no_autoconfig = no_autoconfig;
10590 mp->no_onlink = no_onlink;
10592 mp->val_lifetime = ntohl (val_lifetime);
10593 mp->pref_lifetime = ntohl (pref_lifetime);
10598 /* Wait for a reply, return good/bad news */
10604 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10606 unformat_input_t *i = vam->input;
10607 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10609 u8 sw_if_index_set = 0;
10614 u8 send_unicast = 0;
10617 u8 default_router = 0;
10618 u32 max_interval = 0;
10619 u32 min_interval = 0;
10621 u32 initial_count = 0;
10622 u32 initial_interval = 0;
10626 /* Parse args required to build the message */
10627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10629 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10630 sw_if_index_set = 1;
10631 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10632 sw_if_index_set = 1;
10633 else if (unformat (i, "maxint %d", &max_interval))
10635 else if (unformat (i, "minint %d", &min_interval))
10637 else if (unformat (i, "life %d", &lifetime))
10639 else if (unformat (i, "count %d", &initial_count))
10641 else if (unformat (i, "interval %d", &initial_interval))
10643 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10645 else if (unformat (i, "managed"))
10647 else if (unformat (i, "other"))
10649 else if (unformat (i, "ll"))
10651 else if (unformat (i, "send"))
10653 else if (unformat (i, "cease"))
10655 else if (unformat (i, "isno"))
10657 else if (unformat (i, "def"))
10658 default_router = 1;
10661 clib_warning ("parse error '%U'", format_unformat_error, i);
10666 if (sw_if_index_set == 0)
10668 errmsg ("missing interface name or sw_if_index");
10672 /* Construct the API message */
10673 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10675 mp->sw_if_index = ntohl (sw_if_index);
10676 mp->max_interval = ntohl (max_interval);
10677 mp->min_interval = ntohl (min_interval);
10678 mp->lifetime = ntohl (lifetime);
10679 mp->initial_count = ntohl (initial_count);
10680 mp->initial_interval = ntohl (initial_interval);
10681 mp->suppress = suppress;
10682 mp->managed = managed;
10684 mp->ll_option = ll_option;
10685 mp->send_unicast = send_unicast;
10688 mp->default_router = default_router;
10693 /* Wait for a reply, return good/bad news */
10699 api_set_arp_neighbor_limit (vat_main_t * vam)
10701 unformat_input_t *i = vam->input;
10702 vl_api_set_arp_neighbor_limit_t *mp;
10708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10710 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10712 else if (unformat (i, "ipv6"))
10716 clib_warning ("parse error '%U'", format_unformat_error, i);
10721 if (limit_set == 0)
10723 errmsg ("missing limit value");
10727 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10729 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10730 mp->is_ipv6 = is_ipv6;
10738 api_l2_patch_add_del (vat_main_t * vam)
10740 unformat_input_t *i = vam->input;
10741 vl_api_l2_patch_add_del_t *mp;
10742 u32 rx_sw_if_index;
10743 u8 rx_sw_if_index_set = 0;
10744 u32 tx_sw_if_index;
10745 u8 tx_sw_if_index_set = 0;
10749 /* Parse args required to build the message */
10750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10752 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10753 rx_sw_if_index_set = 1;
10754 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10755 tx_sw_if_index_set = 1;
10756 else if (unformat (i, "rx"))
10758 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10760 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10762 rx_sw_if_index_set = 1;
10767 else if (unformat (i, "tx"))
10769 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10771 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10773 tx_sw_if_index_set = 1;
10778 else if (unformat (i, "del"))
10784 if (rx_sw_if_index_set == 0)
10786 errmsg ("missing rx interface name or rx_sw_if_index");
10790 if (tx_sw_if_index_set == 0)
10792 errmsg ("missing tx interface name or tx_sw_if_index");
10796 M (L2_PATCH_ADD_DEL, mp);
10798 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10799 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10800 mp->is_add = is_add;
10808 u8 localsid_addr[16];
10817 api_sr_localsid_add_del (vat_main_t * vam)
10819 unformat_input_t *i = vam->input;
10820 vl_api_sr_localsid_add_del_t *mp;
10823 ip6_address_t localsid;
10827 u32 fib_table = ~(u32) 0;
10828 ip6_address_t next_hop;
10830 bool nexthop_set = 0;
10834 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10836 if (unformat (i, "del"))
10838 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10839 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10841 else if (unformat (i, "behavior %u", &behavior));
10842 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10843 else if (unformat (i, "fib-table %u", &fib_table));
10844 else if (unformat (i, "end.psp %u", &behavior));
10849 M (SR_LOCALSID_ADD_DEL, mp);
10851 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10853 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10854 mp->behavior = behavior;
10855 mp->sw_if_index = ntohl (sw_if_index);
10856 mp->fib_table = ntohl (fib_table);
10857 mp->end_psp = end_psp;
10858 mp->is_del = is_del;
10866 api_ioam_enable (vat_main_t * vam)
10868 unformat_input_t *input = vam->input;
10869 vl_api_ioam_enable_t *mp;
10871 int has_trace_option = 0;
10872 int has_pot_option = 0;
10873 int has_seqno_option = 0;
10874 int has_analyse_option = 0;
10877 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10879 if (unformat (input, "trace"))
10880 has_trace_option = 1;
10881 else if (unformat (input, "pot"))
10882 has_pot_option = 1;
10883 else if (unformat (input, "seqno"))
10884 has_seqno_option = 1;
10885 else if (unformat (input, "analyse"))
10886 has_analyse_option = 1;
10890 M (IOAM_ENABLE, mp);
10891 mp->id = htons (id);
10892 mp->seqno = has_seqno_option;
10893 mp->analyse = has_analyse_option;
10894 mp->pot_enable = has_pot_option;
10895 mp->trace_enable = has_trace_option;
10904 api_ioam_disable (vat_main_t * vam)
10906 vl_api_ioam_disable_t *mp;
10909 M (IOAM_DISABLE, mp);
10915 #define foreach_tcp_proto_field \
10919 #define foreach_udp_proto_field \
10923 #define foreach_ip4_proto_field \
10935 u16 src_port, dst_port;
10938 #if VPP_API_TEST_BUILTIN == 0
10940 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10942 u8 **maskp = va_arg (*args, u8 **);
10944 u8 found_something = 0;
10947 #define _(a) u8 a=0;
10948 foreach_tcp_proto_field;
10951 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10954 #define _(a) else if (unformat (input, #a)) a=1;
10955 foreach_tcp_proto_field
10961 #define _(a) found_something += a;
10962 foreach_tcp_proto_field;
10965 if (found_something == 0)
10968 vec_validate (mask, sizeof (*tcp) - 1);
10970 tcp = (tcp_header_t *) mask;
10972 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10973 foreach_tcp_proto_field;
10981 unformat_udp_mask (unformat_input_t * input, va_list * args)
10983 u8 **maskp = va_arg (*args, u8 **);
10985 u8 found_something = 0;
10988 #define _(a) u8 a=0;
10989 foreach_udp_proto_field;
10992 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10995 #define _(a) else if (unformat (input, #a)) a=1;
10996 foreach_udp_proto_field
11002 #define _(a) found_something += a;
11003 foreach_udp_proto_field;
11006 if (found_something == 0)
11009 vec_validate (mask, sizeof (*udp) - 1);
11011 udp = (udp_header_t *) mask;
11013 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
11014 foreach_udp_proto_field;
11022 unformat_l4_mask (unformat_input_t * input, va_list * args)
11024 u8 **maskp = va_arg (*args, u8 **);
11025 u16 src_port = 0, dst_port = 0;
11026 tcpudp_header_t *tcpudp;
11028 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11030 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
11032 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
11034 else if (unformat (input, "src_port"))
11036 else if (unformat (input, "dst_port"))
11042 if (!src_port && !dst_port)
11046 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
11048 tcpudp = (tcpudp_header_t *) mask;
11049 tcpudp->src_port = src_port;
11050 tcpudp->dst_port = dst_port;
11058 unformat_ip4_mask (unformat_input_t * input, va_list * args)
11060 u8 **maskp = va_arg (*args, u8 **);
11062 u8 found_something = 0;
11065 #define _(a) u8 a=0;
11066 foreach_ip4_proto_field;
11072 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11074 if (unformat (input, "version"))
11076 else if (unformat (input, "hdr_length"))
11078 else if (unformat (input, "src"))
11080 else if (unformat (input, "dst"))
11082 else if (unformat (input, "proto"))
11085 #define _(a) else if (unformat (input, #a)) a=1;
11086 foreach_ip4_proto_field
11092 #define _(a) found_something += a;
11093 foreach_ip4_proto_field;
11096 if (found_something == 0)
11099 vec_validate (mask, sizeof (*ip) - 1);
11101 ip = (ip4_header_t *) mask;
11103 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
11104 foreach_ip4_proto_field;
11107 ip->ip_version_and_header_length = 0;
11110 ip->ip_version_and_header_length |= 0xF0;
11113 ip->ip_version_and_header_length |= 0x0F;
11119 #define foreach_ip6_proto_field \
11122 _(payload_length) \
11127 unformat_ip6_mask (unformat_input_t * input, va_list * args)
11129 u8 **maskp = va_arg (*args, u8 **);
11131 u8 found_something = 0;
11133 u32 ip_version_traffic_class_and_flow_label;
11135 #define _(a) u8 a=0;
11136 foreach_ip6_proto_field;
11139 u8 traffic_class = 0;
11142 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11144 if (unformat (input, "version"))
11146 else if (unformat (input, "traffic-class"))
11148 else if (unformat (input, "flow-label"))
11150 else if (unformat (input, "src"))
11152 else if (unformat (input, "dst"))
11154 else if (unformat (input, "proto"))
11157 #define _(a) else if (unformat (input, #a)) a=1;
11158 foreach_ip6_proto_field
11164 #define _(a) found_something += a;
11165 foreach_ip6_proto_field;
11168 if (found_something == 0)
11171 vec_validate (mask, sizeof (*ip) - 1);
11173 ip = (ip6_header_t *) mask;
11175 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
11176 foreach_ip6_proto_field;
11179 ip_version_traffic_class_and_flow_label = 0;
11182 ip_version_traffic_class_and_flow_label |= 0xF0000000;
11185 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
11188 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
11190 ip->ip_version_traffic_class_and_flow_label =
11191 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11198 unformat_l3_mask (unformat_input_t * input, va_list * args)
11200 u8 **maskp = va_arg (*args, u8 **);
11202 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11204 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
11206 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
11215 unformat_l2_mask (unformat_input_t * input, va_list * args)
11217 u8 **maskp = va_arg (*args, u8 **);
11224 u8 ignore_tag1 = 0;
11225 u8 ignore_tag2 = 0;
11232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11234 if (unformat (input, "src"))
11236 else if (unformat (input, "dst"))
11238 else if (unformat (input, "proto"))
11240 else if (unformat (input, "tag1"))
11242 else if (unformat (input, "tag2"))
11244 else if (unformat (input, "ignore-tag1"))
11246 else if (unformat (input, "ignore-tag2"))
11248 else if (unformat (input, "cos1"))
11250 else if (unformat (input, "cos2"))
11252 else if (unformat (input, "dot1q"))
11254 else if (unformat (input, "dot1ad"))
11259 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
11260 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11263 if (tag1 || ignore_tag1 || cos1 || dot1q)
11265 if (tag2 || ignore_tag2 || cos2 || dot1ad)
11268 vec_validate (mask, len - 1);
11271 memset (mask, 0xff, 6);
11274 memset (mask + 6, 0xff, 6);
11276 if (tag2 || dot1ad)
11278 /* inner vlan tag */
11287 mask[21] = mask[20] = 0xff;
11308 mask[16] = mask[17] = 0xff;
11318 mask[12] = mask[13] = 0xff;
11325 unformat_classify_mask (unformat_input_t * input, va_list * args)
11327 u8 **maskp = va_arg (*args, u8 **);
11328 u32 *skipp = va_arg (*args, u32 *);
11329 u32 *matchp = va_arg (*args, u32 *);
11337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11339 if (unformat (input, "hex %U", unformat_hex_string, &mask))
11341 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
11343 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
11345 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
11359 if (mask || l2 || l3 || l4)
11361 if (l2 || l3 || l4)
11363 /* "With a free Ethernet header in every package" */
11365 vec_validate (l2, 13);
11369 vec_append (mask, l3);
11374 vec_append (mask, l4);
11379 /* Scan forward looking for the first significant mask octet */
11380 for (i = 0; i < vec_len (mask); i++)
11384 /* compute (skip, match) params */
11385 *skipp = i / sizeof (u32x4);
11386 vec_delete (mask, *skipp * sizeof (u32x4), 0);
11388 /* Pad mask to an even multiple of the vector size */
11389 while (vec_len (mask) % sizeof (u32x4))
11390 vec_add1 (mask, 0);
11392 match = vec_len (mask) / sizeof (u32x4);
11394 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11396 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11397 if (*tmp || *(tmp + 1))
11402 clib_warning ("BUG: match 0");
11404 _vec_len (mask) = match * sizeof (u32x4);
11414 #endif /* VPP_API_TEST_BUILTIN */
11416 #define foreach_l2_next \
11418 _(ethernet, ETHERNET_INPUT) \
11419 _(ip4, IP4_INPUT) \
11423 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11425 u32 *miss_next_indexp = va_arg (*args, u32 *);
11426 u32 next_index = 0;
11430 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11434 if (unformat (input, "%d", &tmp))
11443 *miss_next_indexp = next_index;
11447 #define foreach_ip_next \
11450 _(rewrite, REWRITE)
11453 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11455 u32 *miss_next_indexp = va_arg (*args, u32 *);
11456 u32 next_index = 0;
11460 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11464 if (unformat (input, "%d", &tmp))
11473 *miss_next_indexp = next_index;
11477 #define foreach_acl_next \
11481 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11483 u32 *miss_next_indexp = va_arg (*args, u32 *);
11484 u32 next_index = 0;
11488 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11492 if (unformat (input, "permit"))
11497 else if (unformat (input, "%d", &tmp))
11506 *miss_next_indexp = next_index;
11511 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11513 u32 *r = va_arg (*args, u32 *);
11515 if (unformat (input, "conform-color"))
11516 *r = POLICE_CONFORM;
11517 else if (unformat (input, "exceed-color"))
11518 *r = POLICE_EXCEED;
11526 api_classify_add_del_table (vat_main_t * vam)
11528 unformat_input_t *i = vam->input;
11529 vl_api_classify_add_del_table_t *mp;
11536 u32 table_index = ~0;
11537 u32 next_table_index = ~0;
11538 u32 miss_next_index = ~0;
11539 u32 memory_size = 32 << 20;
11541 u32 current_data_flag = 0;
11542 int current_data_offset = 0;
11545 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11547 if (unformat (i, "del"))
11549 else if (unformat (i, "del-chain"))
11554 else if (unformat (i, "buckets %d", &nbuckets))
11556 else if (unformat (i, "memory_size %d", &memory_size))
11558 else if (unformat (i, "skip %d", &skip))
11560 else if (unformat (i, "match %d", &match))
11562 else if (unformat (i, "table %d", &table_index))
11564 else if (unformat (i, "mask %U", unformat_classify_mask,
11565 &mask, &skip, &match))
11567 else if (unformat (i, "next-table %d", &next_table_index))
11569 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11572 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11575 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11578 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11580 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11586 if (is_add && mask == 0)
11588 errmsg ("Mask required");
11592 if (is_add && skip == ~0)
11594 errmsg ("skip count required");
11598 if (is_add && match == ~0)
11600 errmsg ("match count required");
11604 if (!is_add && table_index == ~0)
11606 errmsg ("table index required for delete");
11610 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11612 mp->is_add = is_add;
11613 mp->del_chain = del_chain;
11614 mp->table_index = ntohl (table_index);
11615 mp->nbuckets = ntohl (nbuckets);
11616 mp->memory_size = ntohl (memory_size);
11617 mp->skip_n_vectors = ntohl (skip);
11618 mp->match_n_vectors = ntohl (match);
11619 mp->next_table_index = ntohl (next_table_index);
11620 mp->miss_next_index = ntohl (miss_next_index);
11621 mp->current_data_flag = ntohl (current_data_flag);
11622 mp->current_data_offset = ntohl (current_data_offset);
11623 clib_memcpy (mp->mask, mask, vec_len (mask));
11632 #if VPP_API_TEST_BUILTIN == 0
11634 unformat_l4_match (unformat_input_t * input, va_list * args)
11636 u8 **matchp = va_arg (*args, u8 **);
11638 u8 *proto_header = 0;
11644 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11646 if (unformat (input, "src_port %d", &src_port))
11648 else if (unformat (input, "dst_port %d", &dst_port))
11654 h.src_port = clib_host_to_net_u16 (src_port);
11655 h.dst_port = clib_host_to_net_u16 (dst_port);
11656 vec_validate (proto_header, sizeof (h) - 1);
11657 memcpy (proto_header, &h, sizeof (h));
11659 *matchp = proto_header;
11665 unformat_ip4_match (unformat_input_t * input, va_list * args)
11667 u8 **matchp = va_arg (*args, u8 **);
11672 int hdr_length = 0;
11673 u32 hdr_length_val;
11674 int src = 0, dst = 0;
11675 ip4_address_t src_val, dst_val;
11682 int fragment_id = 0;
11683 u32 fragment_id_val;
11689 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11691 if (unformat (input, "version %d", &version_val))
11693 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11695 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11697 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11699 else if (unformat (input, "proto %d", &proto_val))
11701 else if (unformat (input, "tos %d", &tos_val))
11703 else if (unformat (input, "length %d", &length_val))
11705 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11707 else if (unformat (input, "ttl %d", &ttl_val))
11709 else if (unformat (input, "checksum %d", &checksum_val))
11715 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11716 + ttl + checksum == 0)
11720 * Aligned because we use the real comparison functions
11722 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11724 ip = (ip4_header_t *) match;
11726 /* These are realistically matched in practice */
11728 ip->src_address.as_u32 = src_val.as_u32;
11731 ip->dst_address.as_u32 = dst_val.as_u32;
11734 ip->protocol = proto_val;
11737 /* These are not, but they're included for completeness */
11739 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11742 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11748 ip->length = clib_host_to_net_u16 (length_val);
11754 ip->checksum = clib_host_to_net_u16 (checksum_val);
11761 unformat_ip6_match (unformat_input_t * input, va_list * args)
11763 u8 **matchp = va_arg (*args, u8 **);
11768 u8 traffic_class = 0;
11769 u32 traffic_class_val = 0;
11772 int src = 0, dst = 0;
11773 ip6_address_t src_val, dst_val;
11776 int payload_length = 0;
11777 u32 payload_length_val;
11780 u32 ip_version_traffic_class_and_flow_label;
11782 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11784 if (unformat (input, "version %d", &version_val))
11786 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11788 else if (unformat (input, "flow_label %d", &flow_label_val))
11790 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11792 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11794 else if (unformat (input, "proto %d", &proto_val))
11796 else if (unformat (input, "payload_length %d", &payload_length_val))
11797 payload_length = 1;
11798 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11804 if (version + traffic_class + flow_label + src + dst + proto +
11805 payload_length + hop_limit == 0)
11809 * Aligned because we use the real comparison functions
11811 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11813 ip = (ip6_header_t *) match;
11816 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11819 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11822 ip->protocol = proto_val;
11824 ip_version_traffic_class_and_flow_label = 0;
11827 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11830 ip_version_traffic_class_and_flow_label |=
11831 (traffic_class_val & 0xFF) << 20;
11834 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11836 ip->ip_version_traffic_class_and_flow_label =
11837 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11839 if (payload_length)
11840 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11843 ip->hop_limit = hop_limit_val;
11850 unformat_l3_match (unformat_input_t * input, va_list * args)
11852 u8 **matchp = va_arg (*args, u8 **);
11854 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11856 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11858 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11867 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11869 u8 *tagp = va_arg (*args, u8 *);
11872 if (unformat (input, "%d", &tag))
11874 tagp[0] = (tag >> 8) & 0x0F;
11875 tagp[1] = tag & 0xFF;
11883 unformat_l2_match (unformat_input_t * input, va_list * args)
11885 u8 **matchp = va_arg (*args, u8 **);
11898 u8 ignore_tag1 = 0;
11899 u8 ignore_tag2 = 0;
11905 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11907 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11910 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11912 else if (unformat (input, "proto %U",
11913 unformat_ethernet_type_host_byte_order, &proto_val))
11915 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11917 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11919 else if (unformat (input, "ignore-tag1"))
11921 else if (unformat (input, "ignore-tag2"))
11923 else if (unformat (input, "cos1 %d", &cos1_val))
11925 else if (unformat (input, "cos2 %d", &cos2_val))
11930 if ((src + dst + proto + tag1 + tag2 +
11931 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11934 if (tag1 || ignore_tag1 || cos1)
11936 if (tag2 || ignore_tag2 || cos2)
11939 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11942 clib_memcpy (match, dst_val, 6);
11945 clib_memcpy (match + 6, src_val, 6);
11949 /* inner vlan tag */
11950 match[19] = tag2_val[1];
11951 match[18] = tag2_val[0];
11953 match[18] |= (cos2_val & 0x7) << 5;
11956 match[21] = proto_val & 0xff;
11957 match[20] = proto_val >> 8;
11961 match[15] = tag1_val[1];
11962 match[14] = tag1_val[0];
11965 match[14] |= (cos1_val & 0x7) << 5;
11971 match[15] = tag1_val[1];
11972 match[14] = tag1_val[0];
11975 match[17] = proto_val & 0xff;
11976 match[16] = proto_val >> 8;
11979 match[14] |= (cos1_val & 0x7) << 5;
11985 match[18] |= (cos2_val & 0x7) << 5;
11987 match[14] |= (cos1_val & 0x7) << 5;
11990 match[13] = proto_val & 0xff;
11991 match[12] = proto_val >> 8;
12000 api_unformat_classify_match (unformat_input_t * input, va_list * args)
12002 u8 **matchp = va_arg (*args, u8 **);
12003 u32 skip_n_vectors = va_arg (*args, u32);
12004 u32 match_n_vectors = va_arg (*args, u32);
12011 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12013 if (unformat (input, "hex %U", unformat_hex_string, &match))
12015 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
12017 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
12019 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
12033 if (match || l2 || l3 || l4)
12035 if (l2 || l3 || l4)
12037 /* "Win a free Ethernet header in every packet" */
12039 vec_validate_aligned (l2, 13, sizeof (u32x4));
12043 vec_append_aligned (match, l3, sizeof (u32x4));
12048 vec_append_aligned (match, l4, sizeof (u32x4));
12053 /* Make sure the vector is big enough even if key is all 0's */
12054 vec_validate_aligned
12055 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
12058 /* Set size, include skipped vectors */
12059 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
12070 api_classify_add_del_session (vat_main_t * vam)
12072 unformat_input_t *i = vam->input;
12073 vl_api_classify_add_del_session_t *mp;
12075 u32 table_index = ~0;
12076 u32 hit_next_index = ~0;
12077 u32 opaque_index = ~0;
12080 u32 skip_n_vectors = 0;
12081 u32 match_n_vectors = 0;
12087 * Warning: you have to supply skip_n and match_n
12088 * because the API client cant simply look at the classify
12092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12094 if (unformat (i, "del"))
12096 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
12099 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
12102 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
12105 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
12107 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
12109 else if (unformat (i, "opaque-index %d", &opaque_index))
12111 else if (unformat (i, "skip_n %d", &skip_n_vectors))
12113 else if (unformat (i, "match_n %d", &match_n_vectors))
12115 else if (unformat (i, "match %U", api_unformat_classify_match,
12116 &match, skip_n_vectors, match_n_vectors))
12118 else if (unformat (i, "advance %d", &advance))
12120 else if (unformat (i, "table-index %d", &table_index))
12122 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
12124 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
12126 else if (unformat (i, "action %d", &action))
12128 else if (unformat (i, "metadata %d", &metadata))
12134 if (table_index == ~0)
12136 errmsg ("Table index required");
12140 if (is_add && match == 0)
12142 errmsg ("Match value required");
12146 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
12148 mp->is_add = is_add;
12149 mp->table_index = ntohl (table_index);
12150 mp->hit_next_index = ntohl (hit_next_index);
12151 mp->opaque_index = ntohl (opaque_index);
12152 mp->advance = ntohl (advance);
12153 mp->action = action;
12154 mp->metadata = ntohl (metadata);
12155 clib_memcpy (mp->match, match, vec_len (match));
12164 api_classify_set_interface_ip_table (vat_main_t * vam)
12166 unformat_input_t *i = vam->input;
12167 vl_api_classify_set_interface_ip_table_t *mp;
12169 int sw_if_index_set;
12170 u32 table_index = ~0;
12174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12176 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12177 sw_if_index_set = 1;
12178 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12179 sw_if_index_set = 1;
12180 else if (unformat (i, "table %d", &table_index))
12184 clib_warning ("parse error '%U'", format_unformat_error, i);
12189 if (sw_if_index_set == 0)
12191 errmsg ("missing interface name or sw_if_index");
12196 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
12198 mp->sw_if_index = ntohl (sw_if_index);
12199 mp->table_index = ntohl (table_index);
12200 mp->is_ipv6 = is_ipv6;
12208 api_classify_set_interface_l2_tables (vat_main_t * vam)
12210 unformat_input_t *i = vam->input;
12211 vl_api_classify_set_interface_l2_tables_t *mp;
12213 int sw_if_index_set;
12214 u32 ip4_table_index = ~0;
12215 u32 ip6_table_index = ~0;
12216 u32 other_table_index = ~0;
12220 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12222 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12223 sw_if_index_set = 1;
12224 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12225 sw_if_index_set = 1;
12226 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12228 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12230 else if (unformat (i, "other-table %d", &other_table_index))
12232 else if (unformat (i, "is-input %d", &is_input))
12236 clib_warning ("parse error '%U'", format_unformat_error, i);
12241 if (sw_if_index_set == 0)
12243 errmsg ("missing interface name or sw_if_index");
12248 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
12250 mp->sw_if_index = ntohl (sw_if_index);
12251 mp->ip4_table_index = ntohl (ip4_table_index);
12252 mp->ip6_table_index = ntohl (ip6_table_index);
12253 mp->other_table_index = ntohl (other_table_index);
12254 mp->is_input = (u8) is_input;
12262 api_set_ipfix_exporter (vat_main_t * vam)
12264 unformat_input_t *i = vam->input;
12265 vl_api_set_ipfix_exporter_t *mp;
12266 ip4_address_t collector_address;
12267 u8 collector_address_set = 0;
12268 u32 collector_port = ~0;
12269 ip4_address_t src_address;
12270 u8 src_address_set = 0;
12273 u32 template_interval = ~0;
12274 u8 udp_checksum = 0;
12277 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12279 if (unformat (i, "collector_address %U", unformat_ip4_address,
12280 &collector_address))
12281 collector_address_set = 1;
12282 else if (unformat (i, "collector_port %d", &collector_port))
12284 else if (unformat (i, "src_address %U", unformat_ip4_address,
12286 src_address_set = 1;
12287 else if (unformat (i, "vrf_id %d", &vrf_id))
12289 else if (unformat (i, "path_mtu %d", &path_mtu))
12291 else if (unformat (i, "template_interval %d", &template_interval))
12293 else if (unformat (i, "udp_checksum"))
12299 if (collector_address_set == 0)
12301 errmsg ("collector_address required");
12305 if (src_address_set == 0)
12307 errmsg ("src_address required");
12311 M (SET_IPFIX_EXPORTER, mp);
12313 memcpy (mp->collector_address, collector_address.data,
12314 sizeof (collector_address.data));
12315 mp->collector_port = htons ((u16) collector_port);
12316 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
12317 mp->vrf_id = htonl (vrf_id);
12318 mp->path_mtu = htonl (path_mtu);
12319 mp->template_interval = htonl (template_interval);
12320 mp->udp_checksum = udp_checksum;
12328 api_set_ipfix_classify_stream (vat_main_t * vam)
12330 unformat_input_t *i = vam->input;
12331 vl_api_set_ipfix_classify_stream_t *mp;
12333 u32 src_port = UDP_DST_PORT_ipfix;
12336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12338 if (unformat (i, "domain %d", &domain_id))
12340 else if (unformat (i, "src_port %d", &src_port))
12344 errmsg ("unknown input `%U'", format_unformat_error, i);
12349 M (SET_IPFIX_CLASSIFY_STREAM, mp);
12351 mp->domain_id = htonl (domain_id);
12352 mp->src_port = htons ((u16) src_port);
12360 api_ipfix_classify_table_add_del (vat_main_t * vam)
12362 unformat_input_t *i = vam->input;
12363 vl_api_ipfix_classify_table_add_del_t *mp;
12365 u32 classify_table_index = ~0;
12367 u8 transport_protocol = 255;
12370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12372 if (unformat (i, "add"))
12374 else if (unformat (i, "del"))
12376 else if (unformat (i, "table %d", &classify_table_index))
12378 else if (unformat (i, "ip4"))
12380 else if (unformat (i, "ip6"))
12382 else if (unformat (i, "tcp"))
12383 transport_protocol = 6;
12384 else if (unformat (i, "udp"))
12385 transport_protocol = 17;
12388 errmsg ("unknown input `%U'", format_unformat_error, i);
12395 errmsg ("expecting: add|del");
12398 if (classify_table_index == ~0)
12400 errmsg ("classifier table not specified");
12403 if (ip_version == 0)
12405 errmsg ("IP version not specified");
12409 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12411 mp->is_add = is_add;
12412 mp->table_id = htonl (classify_table_index);
12413 mp->ip_version = ip_version;
12414 mp->transport_protocol = transport_protocol;
12422 api_get_node_index (vat_main_t * vam)
12424 unformat_input_t *i = vam->input;
12425 vl_api_get_node_index_t *mp;
12429 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12431 if (unformat (i, "node %s", &name))
12438 errmsg ("node name required");
12441 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12443 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12447 M (GET_NODE_INDEX, mp);
12448 clib_memcpy (mp->node_name, name, vec_len (name));
12457 api_get_next_index (vat_main_t * vam)
12459 unformat_input_t *i = vam->input;
12460 vl_api_get_next_index_t *mp;
12461 u8 *node_name = 0, *next_node_name = 0;
12464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12466 if (unformat (i, "node-name %s", &node_name))
12468 else if (unformat (i, "next-node-name %s", &next_node_name))
12472 if (node_name == 0)
12474 errmsg ("node name required");
12477 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12479 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12483 if (next_node_name == 0)
12485 errmsg ("next node name required");
12488 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12490 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12494 M (GET_NEXT_INDEX, mp);
12495 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12496 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12497 vec_free (node_name);
12498 vec_free (next_node_name);
12506 api_add_node_next (vat_main_t * vam)
12508 unformat_input_t *i = vam->input;
12509 vl_api_add_node_next_t *mp;
12514 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12516 if (unformat (i, "node %s", &name))
12518 else if (unformat (i, "next %s", &next))
12525 errmsg ("node name required");
12528 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12530 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12535 errmsg ("next node required");
12538 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12540 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12544 M (ADD_NODE_NEXT, mp);
12545 clib_memcpy (mp->node_name, name, vec_len (name));
12546 clib_memcpy (mp->next_name, next, vec_len (next));
12556 api_l2tpv3_create_tunnel (vat_main_t * vam)
12558 unformat_input_t *i = vam->input;
12559 ip6_address_t client_address, our_address;
12560 int client_address_set = 0;
12561 int our_address_set = 0;
12562 u32 local_session_id = 0;
12563 u32 remote_session_id = 0;
12564 u64 local_cookie = 0;
12565 u64 remote_cookie = 0;
12566 u8 l2_sublayer_present = 0;
12567 vl_api_l2tpv3_create_tunnel_t *mp;
12570 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12572 if (unformat (i, "client_address %U", unformat_ip6_address,
12574 client_address_set = 1;
12575 else if (unformat (i, "our_address %U", unformat_ip6_address,
12577 our_address_set = 1;
12578 else if (unformat (i, "local_session_id %d", &local_session_id))
12580 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12582 else if (unformat (i, "local_cookie %lld", &local_cookie))
12584 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12586 else if (unformat (i, "l2-sublayer-present"))
12587 l2_sublayer_present = 1;
12592 if (client_address_set == 0)
12594 errmsg ("client_address required");
12598 if (our_address_set == 0)
12600 errmsg ("our_address required");
12604 M (L2TPV3_CREATE_TUNNEL, mp);
12606 clib_memcpy (mp->client_address, client_address.as_u8,
12607 sizeof (mp->client_address));
12609 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12611 mp->local_session_id = ntohl (local_session_id);
12612 mp->remote_session_id = ntohl (remote_session_id);
12613 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12614 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12615 mp->l2_sublayer_present = l2_sublayer_present;
12624 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12626 unformat_input_t *i = vam->input;
12628 u8 sw_if_index_set = 0;
12629 u64 new_local_cookie = 0;
12630 u64 new_remote_cookie = 0;
12631 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12636 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12637 sw_if_index_set = 1;
12638 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12639 sw_if_index_set = 1;
12640 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12642 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12648 if (sw_if_index_set == 0)
12650 errmsg ("missing interface name or sw_if_index");
12654 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12656 mp->sw_if_index = ntohl (sw_if_index);
12657 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12658 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12666 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12668 unformat_input_t *i = vam->input;
12669 vl_api_l2tpv3_interface_enable_disable_t *mp;
12671 u8 sw_if_index_set = 0;
12672 u8 enable_disable = 1;
12675 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12677 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12678 sw_if_index_set = 1;
12679 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12680 sw_if_index_set = 1;
12681 else if (unformat (i, "enable"))
12682 enable_disable = 1;
12683 else if (unformat (i, "disable"))
12684 enable_disable = 0;
12689 if (sw_if_index_set == 0)
12691 errmsg ("missing interface name or sw_if_index");
12695 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12697 mp->sw_if_index = ntohl (sw_if_index);
12698 mp->enable_disable = enable_disable;
12706 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12708 unformat_input_t *i = vam->input;
12709 vl_api_l2tpv3_set_lookup_key_t *mp;
12713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12715 if (unformat (i, "lookup_v6_src"))
12716 key = L2T_LOOKUP_SRC_ADDRESS;
12717 else if (unformat (i, "lookup_v6_dst"))
12718 key = L2T_LOOKUP_DST_ADDRESS;
12719 else if (unformat (i, "lookup_session_id"))
12720 key = L2T_LOOKUP_SESSION_ID;
12725 if (key == (u8) ~ 0)
12727 errmsg ("l2tp session lookup key unset");
12731 M (L2TPV3_SET_LOOKUP_KEY, mp);
12740 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12741 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12743 vat_main_t *vam = &vat_main;
12745 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12746 format_ip6_address, mp->our_address,
12747 format_ip6_address, mp->client_address,
12748 clib_net_to_host_u32 (mp->sw_if_index));
12751 " local cookies %016llx %016llx remote cookie %016llx",
12752 clib_net_to_host_u64 (mp->local_cookie[0]),
12753 clib_net_to_host_u64 (mp->local_cookie[1]),
12754 clib_net_to_host_u64 (mp->remote_cookie));
12756 print (vam->ofp, " local session-id %d remote session-id %d",
12757 clib_net_to_host_u32 (mp->local_session_id),
12758 clib_net_to_host_u32 (mp->remote_session_id));
12760 print (vam->ofp, " l2 specific sublayer %s\n",
12761 mp->l2_sublayer_present ? "preset" : "absent");
12765 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12766 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12768 vat_main_t *vam = &vat_main;
12769 vat_json_node_t *node = NULL;
12770 struct in6_addr addr;
12772 if (VAT_JSON_ARRAY != vam->json_tree.type)
12774 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12775 vat_json_init_array (&vam->json_tree);
12777 node = vat_json_array_add (&vam->json_tree);
12779 vat_json_init_object (node);
12781 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12782 vat_json_object_add_ip6 (node, "our_address", addr);
12783 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12784 vat_json_object_add_ip6 (node, "client_address", addr);
12786 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12787 vat_json_init_array (lc);
12788 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12789 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12790 vat_json_object_add_uint (node, "remote_cookie",
12791 clib_net_to_host_u64 (mp->remote_cookie));
12793 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12794 vat_json_object_add_uint (node, "local_session_id",
12795 clib_net_to_host_u32 (mp->local_session_id));
12796 vat_json_object_add_uint (node, "remote_session_id",
12797 clib_net_to_host_u32 (mp->remote_session_id));
12798 vat_json_object_add_string_copy (node, "l2_sublayer",
12799 mp->l2_sublayer_present ? (u8 *) "present"
12800 : (u8 *) "absent");
12804 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12806 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12807 vl_api_control_ping_t *mp_ping;
12810 /* Get list of l2tpv3-tunnel interfaces */
12811 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12814 /* Use a control ping for synchronization */
12815 MPING (CONTROL_PING, mp_ping);
12823 static void vl_api_sw_interface_tap_details_t_handler
12824 (vl_api_sw_interface_tap_details_t * mp)
12826 vat_main_t *vam = &vat_main;
12828 print (vam->ofp, "%-16s %d",
12829 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12832 static void vl_api_sw_interface_tap_details_t_handler_json
12833 (vl_api_sw_interface_tap_details_t * mp)
12835 vat_main_t *vam = &vat_main;
12836 vat_json_node_t *node = NULL;
12838 if (VAT_JSON_ARRAY != vam->json_tree.type)
12840 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12841 vat_json_init_array (&vam->json_tree);
12843 node = vat_json_array_add (&vam->json_tree);
12845 vat_json_init_object (node);
12846 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12847 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12851 api_sw_interface_tap_dump (vat_main_t * vam)
12853 vl_api_sw_interface_tap_dump_t *mp;
12854 vl_api_control_ping_t *mp_ping;
12857 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12858 /* Get list of tap interfaces */
12859 M (SW_INTERFACE_TAP_DUMP, mp);
12862 /* Use a control ping for synchronization */
12863 MPING (CONTROL_PING, mp_ping);
12870 static void vl_api_sw_interface_tap_v2_details_t_handler
12871 (vl_api_sw_interface_tap_v2_details_t * mp)
12873 vat_main_t *vam = &vat_main;
12875 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12876 mp->host_ip4_prefix_len);
12877 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12878 mp->host_ip6_prefix_len);
12881 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s",
12882 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12883 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12884 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12885 mp->host_bridge, ip4, ip6);
12891 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12892 (vl_api_sw_interface_tap_v2_details_t * mp)
12894 vat_main_t *vam = &vat_main;
12895 vat_json_node_t *node = NULL;
12897 if (VAT_JSON_ARRAY != vam->json_tree.type)
12899 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12900 vat_json_init_array (&vam->json_tree);
12902 node = vat_json_array_add (&vam->json_tree);
12904 vat_json_init_object (node);
12905 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12906 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12907 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12908 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12909 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12910 vat_json_object_add_string_copy (node, "host_mac_addr",
12911 format (0, "%U", format_ethernet_address,
12912 &mp->host_mac_addr));
12913 vat_json_object_add_string_copy (node, "host_namespace",
12914 mp->host_namespace);
12915 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12916 vat_json_object_add_string_copy (node, "host_ip4_addr",
12917 format (0, "%U/%d", format_ip4_address,
12919 mp->host_ip4_prefix_len));
12920 vat_json_object_add_string_copy (node, "host_ip6_addr",
12921 format (0, "%U/%d", format_ip6_address,
12923 mp->host_ip6_prefix_len));
12928 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12930 vl_api_sw_interface_tap_v2_dump_t *mp;
12931 vl_api_control_ping_t *mp_ping;
12935 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12936 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12937 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12940 /* Get list of tap interfaces */
12941 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12944 /* Use a control ping for synchronization */
12945 MPING (CONTROL_PING, mp_ping);
12952 static uword unformat_vxlan_decap_next
12953 (unformat_input_t * input, va_list * args)
12955 u32 *result = va_arg (*args, u32 *);
12958 if (unformat (input, "l2"))
12959 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12960 else if (unformat (input, "%d", &tmp))
12968 api_vxlan_add_del_tunnel (vat_main_t * vam)
12970 unformat_input_t *line_input = vam->input;
12971 vl_api_vxlan_add_del_tunnel_t *mp;
12972 ip46_address_t src, dst;
12974 u8 ipv4_set = 0, ipv6_set = 0;
12979 u32 mcast_sw_if_index = ~0;
12980 u32 encap_vrf_id = 0;
12981 u32 decap_next_index = ~0;
12985 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12986 memset (&src, 0, sizeof src);
12987 memset (&dst, 0, sizeof dst);
12989 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12991 if (unformat (line_input, "del"))
12993 else if (unformat (line_input, "instance %d", &instance))
12996 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13002 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13008 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13014 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13019 else if (unformat (line_input, "group %U %U",
13020 unformat_ip4_address, &dst.ip4,
13021 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13023 grp_set = dst_set = 1;
13026 else if (unformat (line_input, "group %U",
13027 unformat_ip4_address, &dst.ip4))
13029 grp_set = dst_set = 1;
13032 else if (unformat (line_input, "group %U %U",
13033 unformat_ip6_address, &dst.ip6,
13034 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13036 grp_set = dst_set = 1;
13039 else if (unformat (line_input, "group %U",
13040 unformat_ip6_address, &dst.ip6))
13042 grp_set = dst_set = 1;
13046 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13048 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13050 else if (unformat (line_input, "decap-next %U",
13051 unformat_vxlan_decap_next, &decap_next_index))
13053 else if (unformat (line_input, "vni %d", &vni))
13057 errmsg ("parse error '%U'", format_unformat_error, line_input);
13064 errmsg ("tunnel src address not specified");
13069 errmsg ("tunnel dst address not specified");
13073 if (grp_set && !ip46_address_is_multicast (&dst))
13075 errmsg ("tunnel group address not multicast");
13078 if (grp_set && mcast_sw_if_index == ~0)
13080 errmsg ("tunnel nonexistent multicast device");
13083 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13085 errmsg ("tunnel dst address must be unicast");
13090 if (ipv4_set && ipv6_set)
13092 errmsg ("both IPv4 and IPv6 addresses specified");
13096 if ((vni == 0) || (vni >> 24))
13098 errmsg ("vni not specified or out of range");
13102 M (VXLAN_ADD_DEL_TUNNEL, mp);
13106 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
13107 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
13111 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
13112 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
13115 mp->instance = htonl (instance);
13116 mp->encap_vrf_id = ntohl (encap_vrf_id);
13117 mp->decap_next_index = ntohl (decap_next_index);
13118 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13119 mp->vni = ntohl (vni);
13120 mp->is_add = is_add;
13121 mp->is_ipv6 = ipv6_set;
13128 static void vl_api_vxlan_tunnel_details_t_handler
13129 (vl_api_vxlan_tunnel_details_t * mp)
13131 vat_main_t *vam = &vat_main;
13132 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13133 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13135 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
13136 ntohl (mp->sw_if_index),
13137 ntohl (mp->instance),
13138 format_ip46_address, &src, IP46_TYPE_ANY,
13139 format_ip46_address, &dst, IP46_TYPE_ANY,
13140 ntohl (mp->encap_vrf_id),
13141 ntohl (mp->decap_next_index), ntohl (mp->vni),
13142 ntohl (mp->mcast_sw_if_index));
13145 static void vl_api_vxlan_tunnel_details_t_handler_json
13146 (vl_api_vxlan_tunnel_details_t * mp)
13148 vat_main_t *vam = &vat_main;
13149 vat_json_node_t *node = NULL;
13151 if (VAT_JSON_ARRAY != vam->json_tree.type)
13153 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13154 vat_json_init_array (&vam->json_tree);
13156 node = vat_json_array_add (&vam->json_tree);
13158 vat_json_init_object (node);
13159 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13161 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
13165 struct in6_addr ip6;
13167 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13168 vat_json_object_add_ip6 (node, "src_address", ip6);
13169 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13170 vat_json_object_add_ip6 (node, "dst_address", ip6);
13174 struct in_addr ip4;
13176 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13177 vat_json_object_add_ip4 (node, "src_address", ip4);
13178 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13179 vat_json_object_add_ip4 (node, "dst_address", ip4);
13181 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13182 vat_json_object_add_uint (node, "decap_next_index",
13183 ntohl (mp->decap_next_index));
13184 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13185 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13186 vat_json_object_add_uint (node, "mcast_sw_if_index",
13187 ntohl (mp->mcast_sw_if_index));
13191 api_vxlan_tunnel_dump (vat_main_t * vam)
13193 unformat_input_t *i = vam->input;
13194 vl_api_vxlan_tunnel_dump_t *mp;
13195 vl_api_control_ping_t *mp_ping;
13197 u8 sw_if_index_set = 0;
13200 /* Parse args required to build the message */
13201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13203 if (unformat (i, "sw_if_index %d", &sw_if_index))
13204 sw_if_index_set = 1;
13209 if (sw_if_index_set == 0)
13214 if (!vam->json_output)
13216 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
13217 "sw_if_index", "instance", "src_address", "dst_address",
13218 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13221 /* Get list of vxlan-tunnel interfaces */
13222 M (VXLAN_TUNNEL_DUMP, mp);
13224 mp->sw_if_index = htonl (sw_if_index);
13228 /* Use a control ping for synchronization */
13229 MPING (CONTROL_PING, mp_ping);
13236 static uword unformat_geneve_decap_next
13237 (unformat_input_t * input, va_list * args)
13239 u32 *result = va_arg (*args, u32 *);
13242 if (unformat (input, "l2"))
13243 *result = GENEVE_INPUT_NEXT_L2_INPUT;
13244 else if (unformat (input, "%d", &tmp))
13252 api_geneve_add_del_tunnel (vat_main_t * vam)
13254 unformat_input_t *line_input = vam->input;
13255 vl_api_geneve_add_del_tunnel_t *mp;
13256 ip46_address_t src, dst;
13258 u8 ipv4_set = 0, ipv6_set = 0;
13262 u32 mcast_sw_if_index = ~0;
13263 u32 encap_vrf_id = 0;
13264 u32 decap_next_index = ~0;
13268 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13269 memset (&src, 0, sizeof src);
13270 memset (&dst, 0, sizeof dst);
13272 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13274 if (unformat (line_input, "del"))
13277 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13283 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13289 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13295 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13300 else if (unformat (line_input, "group %U %U",
13301 unformat_ip4_address, &dst.ip4,
13302 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13304 grp_set = dst_set = 1;
13307 else if (unformat (line_input, "group %U",
13308 unformat_ip4_address, &dst.ip4))
13310 grp_set = dst_set = 1;
13313 else if (unformat (line_input, "group %U %U",
13314 unformat_ip6_address, &dst.ip6,
13315 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13317 grp_set = dst_set = 1;
13320 else if (unformat (line_input, "group %U",
13321 unformat_ip6_address, &dst.ip6))
13323 grp_set = dst_set = 1;
13327 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13329 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13331 else if (unformat (line_input, "decap-next %U",
13332 unformat_geneve_decap_next, &decap_next_index))
13334 else if (unformat (line_input, "vni %d", &vni))
13338 errmsg ("parse error '%U'", format_unformat_error, line_input);
13345 errmsg ("tunnel src address not specified");
13350 errmsg ("tunnel dst address not specified");
13354 if (grp_set && !ip46_address_is_multicast (&dst))
13356 errmsg ("tunnel group address not multicast");
13359 if (grp_set && mcast_sw_if_index == ~0)
13361 errmsg ("tunnel nonexistent multicast device");
13364 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13366 errmsg ("tunnel dst address must be unicast");
13371 if (ipv4_set && ipv6_set)
13373 errmsg ("both IPv4 and IPv6 addresses specified");
13377 if ((vni == 0) || (vni >> 24))
13379 errmsg ("vni not specified or out of range");
13383 M (GENEVE_ADD_DEL_TUNNEL, mp);
13387 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13388 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13392 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13393 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13395 mp->encap_vrf_id = ntohl (encap_vrf_id);
13396 mp->decap_next_index = ntohl (decap_next_index);
13397 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13398 mp->vni = ntohl (vni);
13399 mp->is_add = is_add;
13400 mp->is_ipv6 = ipv6_set;
13407 static void vl_api_geneve_tunnel_details_t_handler
13408 (vl_api_geneve_tunnel_details_t * mp)
13410 vat_main_t *vam = &vat_main;
13411 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13412 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13414 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13415 ntohl (mp->sw_if_index),
13416 format_ip46_address, &src, IP46_TYPE_ANY,
13417 format_ip46_address, &dst, IP46_TYPE_ANY,
13418 ntohl (mp->encap_vrf_id),
13419 ntohl (mp->decap_next_index), ntohl (mp->vni),
13420 ntohl (mp->mcast_sw_if_index));
13423 static void vl_api_geneve_tunnel_details_t_handler_json
13424 (vl_api_geneve_tunnel_details_t * mp)
13426 vat_main_t *vam = &vat_main;
13427 vat_json_node_t *node = NULL;
13429 if (VAT_JSON_ARRAY != vam->json_tree.type)
13431 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13432 vat_json_init_array (&vam->json_tree);
13434 node = vat_json_array_add (&vam->json_tree);
13436 vat_json_init_object (node);
13437 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13440 struct in6_addr ip6;
13442 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13443 vat_json_object_add_ip6 (node, "src_address", ip6);
13444 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13445 vat_json_object_add_ip6 (node, "dst_address", ip6);
13449 struct in_addr ip4;
13451 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13452 vat_json_object_add_ip4 (node, "src_address", ip4);
13453 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13454 vat_json_object_add_ip4 (node, "dst_address", ip4);
13456 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13457 vat_json_object_add_uint (node, "decap_next_index",
13458 ntohl (mp->decap_next_index));
13459 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13460 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13461 vat_json_object_add_uint (node, "mcast_sw_if_index",
13462 ntohl (mp->mcast_sw_if_index));
13466 api_geneve_tunnel_dump (vat_main_t * vam)
13468 unformat_input_t *i = vam->input;
13469 vl_api_geneve_tunnel_dump_t *mp;
13470 vl_api_control_ping_t *mp_ping;
13472 u8 sw_if_index_set = 0;
13475 /* Parse args required to build the message */
13476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13478 if (unformat (i, "sw_if_index %d", &sw_if_index))
13479 sw_if_index_set = 1;
13484 if (sw_if_index_set == 0)
13489 if (!vam->json_output)
13491 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13492 "sw_if_index", "local_address", "remote_address",
13493 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13496 /* Get list of geneve-tunnel interfaces */
13497 M (GENEVE_TUNNEL_DUMP, mp);
13499 mp->sw_if_index = htonl (sw_if_index);
13503 /* Use a control ping for synchronization */
13504 M (CONTROL_PING, mp_ping);
13512 api_gre_add_del_tunnel (vat_main_t * vam)
13514 unformat_input_t *line_input = vam->input;
13515 vl_api_gre_add_del_tunnel_t *mp;
13516 ip4_address_t src4, dst4;
13517 ip6_address_t src6, dst6;
13521 u8 t_type = GRE_TUNNEL_TYPE_L3;
13524 u32 outer_fib_id = 0;
13525 u32 session_id = 0;
13529 memset (&src4, 0, sizeof src4);
13530 memset (&dst4, 0, sizeof dst4);
13531 memset (&src6, 0, sizeof src6);
13532 memset (&dst6, 0, sizeof dst6);
13534 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13536 if (unformat (line_input, "del"))
13538 else if (unformat (line_input, "instance %d", &instance))
13540 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13545 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13550 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13555 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13560 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13562 else if (unformat (line_input, "teb"))
13563 t_type = GRE_TUNNEL_TYPE_TEB;
13564 else if (unformat (line_input, "erspan %d", &session_id))
13565 t_type = GRE_TUNNEL_TYPE_ERSPAN;
13568 errmsg ("parse error '%U'", format_unformat_error, line_input);
13575 errmsg ("tunnel src address not specified");
13580 errmsg ("tunnel dst address not specified");
13583 if (ipv4_set && ipv6_set)
13585 errmsg ("both IPv4 and IPv6 addresses specified");
13590 M (GRE_ADD_DEL_TUNNEL, mp);
13594 clib_memcpy (&mp->src_address, &src4, 4);
13595 clib_memcpy (&mp->dst_address, &dst4, 4);
13599 clib_memcpy (&mp->src_address, &src6, 16);
13600 clib_memcpy (&mp->dst_address, &dst6, 16);
13602 mp->instance = htonl (instance);
13603 mp->outer_fib_id = htonl (outer_fib_id);
13604 mp->is_add = is_add;
13605 mp->session_id = htons ((u16) session_id);
13606 mp->tunnel_type = t_type;
13607 mp->is_ipv6 = ipv6_set;
13614 static void vl_api_gre_tunnel_details_t_handler
13615 (vl_api_gre_tunnel_details_t * mp)
13617 vat_main_t *vam = &vat_main;
13618 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13619 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13621 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13622 ntohl (mp->sw_if_index),
13623 ntohl (mp->instance),
13624 format_ip46_address, &src, IP46_TYPE_ANY,
13625 format_ip46_address, &dst, IP46_TYPE_ANY,
13626 mp->tunnel_type, ntohl (mp->outer_fib_id), ntohl (mp->session_id));
13629 static void vl_api_gre_tunnel_details_t_handler_json
13630 (vl_api_gre_tunnel_details_t * mp)
13632 vat_main_t *vam = &vat_main;
13633 vat_json_node_t *node = NULL;
13634 struct in_addr ip4;
13635 struct in6_addr ip6;
13637 if (VAT_JSON_ARRAY != vam->json_tree.type)
13639 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13640 vat_json_init_array (&vam->json_tree);
13642 node = vat_json_array_add (&vam->json_tree);
13644 vat_json_init_object (node);
13645 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13646 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
13649 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13650 vat_json_object_add_ip4 (node, "src_address", ip4);
13651 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13652 vat_json_object_add_ip4 (node, "dst_address", ip4);
13656 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13657 vat_json_object_add_ip6 (node, "src_address", ip6);
13658 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13659 vat_json_object_add_ip6 (node, "dst_address", ip6);
13661 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel_type);
13662 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13663 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13664 vat_json_object_add_uint (node, "session_id", mp->session_id);
13668 api_gre_tunnel_dump (vat_main_t * vam)
13670 unformat_input_t *i = vam->input;
13671 vl_api_gre_tunnel_dump_t *mp;
13672 vl_api_control_ping_t *mp_ping;
13674 u8 sw_if_index_set = 0;
13677 /* Parse args required to build the message */
13678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13680 if (unformat (i, "sw_if_index %d", &sw_if_index))
13681 sw_if_index_set = 1;
13686 if (sw_if_index_set == 0)
13691 if (!vam->json_output)
13693 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13694 "sw_if_index", "instance", "src_address", "dst_address",
13695 "tunnel_type", "outer_fib_id", "session_id");
13698 /* Get list of gre-tunnel interfaces */
13699 M (GRE_TUNNEL_DUMP, mp);
13701 mp->sw_if_index = htonl (sw_if_index);
13705 /* Use a control ping for synchronization */
13706 MPING (CONTROL_PING, mp_ping);
13714 api_l2_fib_clear_table (vat_main_t * vam)
13716 // unformat_input_t * i = vam->input;
13717 vl_api_l2_fib_clear_table_t *mp;
13720 M (L2_FIB_CLEAR_TABLE, mp);
13728 api_l2_interface_efp_filter (vat_main_t * vam)
13730 unformat_input_t *i = vam->input;
13731 vl_api_l2_interface_efp_filter_t *mp;
13734 u8 sw_if_index_set = 0;
13737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13739 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13740 sw_if_index_set = 1;
13741 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13742 sw_if_index_set = 1;
13743 else if (unformat (i, "enable"))
13745 else if (unformat (i, "disable"))
13749 clib_warning ("parse error '%U'", format_unformat_error, i);
13754 if (sw_if_index_set == 0)
13756 errmsg ("missing sw_if_index");
13760 M (L2_INTERFACE_EFP_FILTER, mp);
13762 mp->sw_if_index = ntohl (sw_if_index);
13763 mp->enable_disable = enable;
13770 #define foreach_vtr_op \
13771 _("disable", L2_VTR_DISABLED) \
13772 _("push-1", L2_VTR_PUSH_1) \
13773 _("push-2", L2_VTR_PUSH_2) \
13774 _("pop-1", L2_VTR_POP_1) \
13775 _("pop-2", L2_VTR_POP_2) \
13776 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13777 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13778 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13779 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13782 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13784 unformat_input_t *i = vam->input;
13785 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13787 u8 sw_if_index_set = 0;
13790 u32 push_dot1q = 1;
13795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13797 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13798 sw_if_index_set = 1;
13799 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13800 sw_if_index_set = 1;
13801 else if (unformat (i, "vtr_op %d", &vtr_op))
13803 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13806 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13808 else if (unformat (i, "tag1 %d", &tag1))
13810 else if (unformat (i, "tag2 %d", &tag2))
13814 clib_warning ("parse error '%U'", format_unformat_error, i);
13819 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13821 errmsg ("missing vtr operation or sw_if_index");
13825 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13826 mp->sw_if_index = ntohl (sw_if_index);
13827 mp->vtr_op = ntohl (vtr_op);
13828 mp->push_dot1q = ntohl (push_dot1q);
13829 mp->tag1 = ntohl (tag1);
13830 mp->tag2 = ntohl (tag2);
13838 api_create_vhost_user_if (vat_main_t * vam)
13840 unformat_input_t *i = vam->input;
13841 vl_api_create_vhost_user_if_t *mp;
13844 u8 file_name_set = 0;
13845 u32 custom_dev_instance = ~0;
13847 u8 use_custom_mac = 0;
13851 /* Shut up coverity */
13852 memset (hwaddr, 0, sizeof (hwaddr));
13854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13856 if (unformat (i, "socket %s", &file_name))
13860 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13862 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13863 use_custom_mac = 1;
13864 else if (unformat (i, "server"))
13866 else if (unformat (i, "tag %s", &tag))
13872 if (file_name_set == 0)
13874 errmsg ("missing socket file name");
13878 if (vec_len (file_name) > 255)
13880 errmsg ("socket file name too long");
13883 vec_add1 (file_name, 0);
13885 M (CREATE_VHOST_USER_IF, mp);
13887 mp->is_server = is_server;
13888 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13889 vec_free (file_name);
13890 if (custom_dev_instance != ~0)
13893 mp->custom_dev_instance = ntohl (custom_dev_instance);
13895 mp->use_custom_mac = use_custom_mac;
13896 clib_memcpy (mp->mac_address, hwaddr, 6);
13898 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13907 api_modify_vhost_user_if (vat_main_t * vam)
13909 unformat_input_t *i = vam->input;
13910 vl_api_modify_vhost_user_if_t *mp;
13913 u8 file_name_set = 0;
13914 u32 custom_dev_instance = ~0;
13915 u8 sw_if_index_set = 0;
13916 u32 sw_if_index = (u32) ~ 0;
13919 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13921 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13922 sw_if_index_set = 1;
13923 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13924 sw_if_index_set = 1;
13925 else if (unformat (i, "socket %s", &file_name))
13929 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13931 else if (unformat (i, "server"))
13937 if (sw_if_index_set == 0)
13939 errmsg ("missing sw_if_index or interface name");
13943 if (file_name_set == 0)
13945 errmsg ("missing socket file name");
13949 if (vec_len (file_name) > 255)
13951 errmsg ("socket file name too long");
13954 vec_add1 (file_name, 0);
13956 M (MODIFY_VHOST_USER_IF, mp);
13958 mp->sw_if_index = ntohl (sw_if_index);
13959 mp->is_server = is_server;
13960 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13961 vec_free (file_name);
13962 if (custom_dev_instance != ~0)
13965 mp->custom_dev_instance = ntohl (custom_dev_instance);
13974 api_delete_vhost_user_if (vat_main_t * vam)
13976 unformat_input_t *i = vam->input;
13977 vl_api_delete_vhost_user_if_t *mp;
13978 u32 sw_if_index = ~0;
13979 u8 sw_if_index_set = 0;
13982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13984 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13985 sw_if_index_set = 1;
13986 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13987 sw_if_index_set = 1;
13992 if (sw_if_index_set == 0)
13994 errmsg ("missing sw_if_index or interface name");
13999 M (DELETE_VHOST_USER_IF, mp);
14001 mp->sw_if_index = ntohl (sw_if_index);
14008 static void vl_api_sw_interface_vhost_user_details_t_handler
14009 (vl_api_sw_interface_vhost_user_details_t * mp)
14011 vat_main_t *vam = &vat_main;
14013 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
14014 (char *) mp->interface_name,
14015 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
14016 clib_net_to_host_u64 (mp->features), mp->is_server,
14017 ntohl (mp->num_regions), (char *) mp->sock_filename);
14018 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
14021 static void vl_api_sw_interface_vhost_user_details_t_handler_json
14022 (vl_api_sw_interface_vhost_user_details_t * mp)
14024 vat_main_t *vam = &vat_main;
14025 vat_json_node_t *node = NULL;
14027 if (VAT_JSON_ARRAY != vam->json_tree.type)
14029 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14030 vat_json_init_array (&vam->json_tree);
14032 node = vat_json_array_add (&vam->json_tree);
14034 vat_json_init_object (node);
14035 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14036 vat_json_object_add_string_copy (node, "interface_name",
14037 mp->interface_name);
14038 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
14039 ntohl (mp->virtio_net_hdr_sz));
14040 vat_json_object_add_uint (node, "features",
14041 clib_net_to_host_u64 (mp->features));
14042 vat_json_object_add_uint (node, "is_server", mp->is_server);
14043 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
14044 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
14045 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
14049 api_sw_interface_vhost_user_dump (vat_main_t * vam)
14051 vl_api_sw_interface_vhost_user_dump_t *mp;
14052 vl_api_control_ping_t *mp_ping;
14055 "Interface name idx hdr_sz features server regions filename");
14057 /* Get list of vhost-user interfaces */
14058 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
14061 /* Use a control ping for synchronization */
14062 MPING (CONTROL_PING, mp_ping);
14070 api_show_version (vat_main_t * vam)
14072 vl_api_show_version_t *mp;
14075 M (SHOW_VERSION, mp);
14084 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
14086 unformat_input_t *line_input = vam->input;
14087 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
14088 ip4_address_t local4, remote4;
14089 ip6_address_t local6, remote6;
14091 u8 ipv4_set = 0, ipv6_set = 0;
14095 u32 mcast_sw_if_index = ~0;
14096 u32 encap_vrf_id = 0;
14097 u32 decap_vrf_id = 0;
14103 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
14104 memset (&local4, 0, sizeof local4);
14105 memset (&remote4, 0, sizeof remote4);
14106 memset (&local6, 0, sizeof local6);
14107 memset (&remote6, 0, sizeof remote6);
14109 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14111 if (unformat (line_input, "del"))
14113 else if (unformat (line_input, "local %U",
14114 unformat_ip4_address, &local4))
14119 else if (unformat (line_input, "remote %U",
14120 unformat_ip4_address, &remote4))
14125 else if (unformat (line_input, "local %U",
14126 unformat_ip6_address, &local6))
14131 else if (unformat (line_input, "remote %U",
14132 unformat_ip6_address, &remote6))
14137 else if (unformat (line_input, "group %U %U",
14138 unformat_ip4_address, &remote4,
14139 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
14141 grp_set = remote_set = 1;
14144 else if (unformat (line_input, "group %U",
14145 unformat_ip4_address, &remote4))
14147 grp_set = remote_set = 1;
14150 else if (unformat (line_input, "group %U %U",
14151 unformat_ip6_address, &remote6,
14152 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
14154 grp_set = remote_set = 1;
14157 else if (unformat (line_input, "group %U",
14158 unformat_ip6_address, &remote6))
14160 grp_set = remote_set = 1;
14164 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
14166 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
14168 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
14170 else if (unformat (line_input, "vni %d", &vni))
14172 else if (unformat (line_input, "next-ip4"))
14174 else if (unformat (line_input, "next-ip6"))
14176 else if (unformat (line_input, "next-ethernet"))
14178 else if (unformat (line_input, "next-nsh"))
14182 errmsg ("parse error '%U'", format_unformat_error, line_input);
14187 if (local_set == 0)
14189 errmsg ("tunnel local address not specified");
14192 if (remote_set == 0)
14194 errmsg ("tunnel remote address not specified");
14197 if (grp_set && mcast_sw_if_index == ~0)
14199 errmsg ("tunnel nonexistent multicast device");
14202 if (ipv4_set && ipv6_set)
14204 errmsg ("both IPv4 and IPv6 addresses specified");
14210 errmsg ("vni not specified");
14214 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
14219 clib_memcpy (&mp->local, &local6, sizeof (local6));
14220 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
14224 clib_memcpy (&mp->local, &local4, sizeof (local4));
14225 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
14228 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
14229 mp->encap_vrf_id = ntohl (encap_vrf_id);
14230 mp->decap_vrf_id = ntohl (decap_vrf_id);
14231 mp->protocol = protocol;
14232 mp->vni = ntohl (vni);
14233 mp->is_add = is_add;
14234 mp->is_ipv6 = ipv6_set;
14241 static void vl_api_vxlan_gpe_tunnel_details_t_handler
14242 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14244 vat_main_t *vam = &vat_main;
14245 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
14246 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
14248 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
14249 ntohl (mp->sw_if_index),
14250 format_ip46_address, &local, IP46_TYPE_ANY,
14251 format_ip46_address, &remote, IP46_TYPE_ANY,
14252 ntohl (mp->vni), mp->protocol,
14253 ntohl (mp->mcast_sw_if_index),
14254 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
14258 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
14259 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14261 vat_main_t *vam = &vat_main;
14262 vat_json_node_t *node = NULL;
14263 struct in_addr ip4;
14264 struct in6_addr ip6;
14266 if (VAT_JSON_ARRAY != vam->json_tree.type)
14268 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14269 vat_json_init_array (&vam->json_tree);
14271 node = vat_json_array_add (&vam->json_tree);
14273 vat_json_init_object (node);
14274 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14277 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
14278 vat_json_object_add_ip6 (node, "local", ip6);
14279 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
14280 vat_json_object_add_ip6 (node, "remote", ip6);
14284 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
14285 vat_json_object_add_ip4 (node, "local", ip4);
14286 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
14287 vat_json_object_add_ip4 (node, "remote", ip4);
14289 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
14290 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
14291 vat_json_object_add_uint (node, "mcast_sw_if_index",
14292 ntohl (mp->mcast_sw_if_index));
14293 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
14294 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
14295 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14299 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14301 unformat_input_t *i = vam->input;
14302 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14303 vl_api_control_ping_t *mp_ping;
14305 u8 sw_if_index_set = 0;
14308 /* Parse args required to build the message */
14309 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14311 if (unformat (i, "sw_if_index %d", &sw_if_index))
14312 sw_if_index_set = 1;
14317 if (sw_if_index_set == 0)
14322 if (!vam->json_output)
14324 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14325 "sw_if_index", "local", "remote", "vni",
14326 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14329 /* Get list of vxlan-tunnel interfaces */
14330 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14332 mp->sw_if_index = htonl (sw_if_index);
14336 /* Use a control ping for synchronization */
14337 MPING (CONTROL_PING, mp_ping);
14344 static void vl_api_l2_fib_table_details_t_handler
14345 (vl_api_l2_fib_table_details_t * mp)
14347 vat_main_t *vam = &vat_main;
14349 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14351 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14352 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14356 static void vl_api_l2_fib_table_details_t_handler_json
14357 (vl_api_l2_fib_table_details_t * mp)
14359 vat_main_t *vam = &vat_main;
14360 vat_json_node_t *node = NULL;
14362 if (VAT_JSON_ARRAY != vam->json_tree.type)
14364 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14365 vat_json_init_array (&vam->json_tree);
14367 node = vat_json_array_add (&vam->json_tree);
14369 vat_json_init_object (node);
14370 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14371 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14372 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14373 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14374 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14375 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14379 api_l2_fib_table_dump (vat_main_t * vam)
14381 unformat_input_t *i = vam->input;
14382 vl_api_l2_fib_table_dump_t *mp;
14383 vl_api_control_ping_t *mp_ping;
14388 /* Parse args required to build the message */
14389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14391 if (unformat (i, "bd_id %d", &bd_id))
14397 if (bd_id_set == 0)
14399 errmsg ("missing bridge domain");
14403 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14405 /* Get list of l2 fib entries */
14406 M (L2_FIB_TABLE_DUMP, mp);
14408 mp->bd_id = ntohl (bd_id);
14411 /* Use a control ping for synchronization */
14412 MPING (CONTROL_PING, mp_ping);
14421 api_interface_name_renumber (vat_main_t * vam)
14423 unformat_input_t *line_input = vam->input;
14424 vl_api_interface_name_renumber_t *mp;
14425 u32 sw_if_index = ~0;
14426 u32 new_show_dev_instance = ~0;
14429 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14431 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14434 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14436 else if (unformat (line_input, "new_show_dev_instance %d",
14437 &new_show_dev_instance))
14443 if (sw_if_index == ~0)
14445 errmsg ("missing interface name or sw_if_index");
14449 if (new_show_dev_instance == ~0)
14451 errmsg ("missing new_show_dev_instance");
14455 M (INTERFACE_NAME_RENUMBER, mp);
14457 mp->sw_if_index = ntohl (sw_if_index);
14458 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14466 api_want_ip4_arp_events (vat_main_t * vam)
14468 unformat_input_t *line_input = vam->input;
14469 vl_api_want_ip4_arp_events_t *mp;
14470 ip4_address_t address;
14471 int address_set = 0;
14472 u32 enable_disable = 1;
14475 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14477 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14479 else if (unformat (line_input, "del"))
14480 enable_disable = 0;
14485 if (address_set == 0)
14487 errmsg ("missing addresses");
14491 M (WANT_IP4_ARP_EVENTS, mp);
14492 mp->enable_disable = enable_disable;
14493 mp->pid = htonl (getpid ());
14494 mp->address = address.as_u32;
14502 api_want_ip6_nd_events (vat_main_t * vam)
14504 unformat_input_t *line_input = vam->input;
14505 vl_api_want_ip6_nd_events_t *mp;
14506 ip6_address_t address;
14507 int address_set = 0;
14508 u32 enable_disable = 1;
14511 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14513 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
14515 else if (unformat (line_input, "del"))
14516 enable_disable = 0;
14521 if (address_set == 0)
14523 errmsg ("missing addresses");
14527 M (WANT_IP6_ND_EVENTS, mp);
14528 mp->enable_disable = enable_disable;
14529 mp->pid = htonl (getpid ());
14530 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14538 api_want_l2_macs_events (vat_main_t * vam)
14540 unformat_input_t *line_input = vam->input;
14541 vl_api_want_l2_macs_events_t *mp;
14542 u8 enable_disable = 1;
14543 u32 scan_delay = 0;
14544 u32 max_macs_in_event = 0;
14545 u32 learn_limit = 0;
14548 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14550 if (unformat (line_input, "learn-limit %d", &learn_limit))
14552 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14554 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14556 else if (unformat (line_input, "disable"))
14557 enable_disable = 0;
14562 M (WANT_L2_MACS_EVENTS, mp);
14563 mp->enable_disable = enable_disable;
14564 mp->pid = htonl (getpid ());
14565 mp->learn_limit = htonl (learn_limit);
14566 mp->scan_delay = (u8) scan_delay;
14567 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14574 api_input_acl_set_interface (vat_main_t * vam)
14576 unformat_input_t *i = vam->input;
14577 vl_api_input_acl_set_interface_t *mp;
14579 int sw_if_index_set;
14580 u32 ip4_table_index = ~0;
14581 u32 ip6_table_index = ~0;
14582 u32 l2_table_index = ~0;
14586 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14588 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14589 sw_if_index_set = 1;
14590 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14591 sw_if_index_set = 1;
14592 else if (unformat (i, "del"))
14594 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14596 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14598 else if (unformat (i, "l2-table %d", &l2_table_index))
14602 clib_warning ("parse error '%U'", format_unformat_error, i);
14607 if (sw_if_index_set == 0)
14609 errmsg ("missing interface name or sw_if_index");
14613 M (INPUT_ACL_SET_INTERFACE, mp);
14615 mp->sw_if_index = ntohl (sw_if_index);
14616 mp->ip4_table_index = ntohl (ip4_table_index);
14617 mp->ip6_table_index = ntohl (ip6_table_index);
14618 mp->l2_table_index = ntohl (l2_table_index);
14619 mp->is_add = is_add;
14627 api_output_acl_set_interface (vat_main_t * vam)
14629 unformat_input_t *i = vam->input;
14630 vl_api_output_acl_set_interface_t *mp;
14632 int sw_if_index_set;
14633 u32 ip4_table_index = ~0;
14634 u32 ip6_table_index = ~0;
14635 u32 l2_table_index = ~0;
14639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14641 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14642 sw_if_index_set = 1;
14643 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14644 sw_if_index_set = 1;
14645 else if (unformat (i, "del"))
14647 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14649 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14651 else if (unformat (i, "l2-table %d", &l2_table_index))
14655 clib_warning ("parse error '%U'", format_unformat_error, i);
14660 if (sw_if_index_set == 0)
14662 errmsg ("missing interface name or sw_if_index");
14666 M (OUTPUT_ACL_SET_INTERFACE, mp);
14668 mp->sw_if_index = ntohl (sw_if_index);
14669 mp->ip4_table_index = ntohl (ip4_table_index);
14670 mp->ip6_table_index = ntohl (ip6_table_index);
14671 mp->l2_table_index = ntohl (l2_table_index);
14672 mp->is_add = is_add;
14680 api_ip_address_dump (vat_main_t * vam)
14682 unformat_input_t *i = vam->input;
14683 vl_api_ip_address_dump_t *mp;
14684 vl_api_control_ping_t *mp_ping;
14685 u32 sw_if_index = ~0;
14686 u8 sw_if_index_set = 0;
14691 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14693 if (unformat (i, "sw_if_index %d", &sw_if_index))
14694 sw_if_index_set = 1;
14696 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14697 sw_if_index_set = 1;
14698 else if (unformat (i, "ipv4"))
14700 else if (unformat (i, "ipv6"))
14706 if (ipv4_set && ipv6_set)
14708 errmsg ("ipv4 and ipv6 flags cannot be both set");
14712 if ((!ipv4_set) && (!ipv6_set))
14714 errmsg ("no ipv4 nor ipv6 flag set");
14718 if (sw_if_index_set == 0)
14720 errmsg ("missing interface name or sw_if_index");
14724 vam->current_sw_if_index = sw_if_index;
14725 vam->is_ipv6 = ipv6_set;
14727 M (IP_ADDRESS_DUMP, mp);
14728 mp->sw_if_index = ntohl (sw_if_index);
14729 mp->is_ipv6 = ipv6_set;
14732 /* Use a control ping for synchronization */
14733 MPING (CONTROL_PING, mp_ping);
14741 api_ip_dump (vat_main_t * vam)
14743 vl_api_ip_dump_t *mp;
14744 vl_api_control_ping_t *mp_ping;
14745 unformat_input_t *in = vam->input;
14752 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14754 if (unformat (in, "ipv4"))
14756 else if (unformat (in, "ipv6"))
14762 if (ipv4_set && ipv6_set)
14764 errmsg ("ipv4 and ipv6 flags cannot be both set");
14768 if ((!ipv4_set) && (!ipv6_set))
14770 errmsg ("no ipv4 nor ipv6 flag set");
14774 is_ipv6 = ipv6_set;
14775 vam->is_ipv6 = is_ipv6;
14777 /* free old data */
14778 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14780 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14782 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14785 mp->is_ipv6 = ipv6_set;
14788 /* Use a control ping for synchronization */
14789 MPING (CONTROL_PING, mp_ping);
14797 api_ipsec_spd_add_del (vat_main_t * vam)
14799 unformat_input_t *i = vam->input;
14800 vl_api_ipsec_spd_add_del_t *mp;
14805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14807 if (unformat (i, "spd_id %d", &spd_id))
14809 else if (unformat (i, "del"))
14813 clib_warning ("parse error '%U'", format_unformat_error, i);
14819 errmsg ("spd_id must be set");
14823 M (IPSEC_SPD_ADD_DEL, mp);
14825 mp->spd_id = ntohl (spd_id);
14826 mp->is_add = is_add;
14834 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14836 unformat_input_t *i = vam->input;
14837 vl_api_ipsec_interface_add_del_spd_t *mp;
14839 u8 sw_if_index_set = 0;
14840 u32 spd_id = (u32) ~ 0;
14844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14846 if (unformat (i, "del"))
14848 else if (unformat (i, "spd_id %d", &spd_id))
14851 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14852 sw_if_index_set = 1;
14853 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14854 sw_if_index_set = 1;
14857 clib_warning ("parse error '%U'", format_unformat_error, i);
14863 if (spd_id == (u32) ~ 0)
14865 errmsg ("spd_id must be set");
14869 if (sw_if_index_set == 0)
14871 errmsg ("missing interface name or sw_if_index");
14875 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14877 mp->spd_id = ntohl (spd_id);
14878 mp->sw_if_index = ntohl (sw_if_index);
14879 mp->is_add = is_add;
14887 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14889 unformat_input_t *i = vam->input;
14890 vl_api_ipsec_spd_add_del_entry_t *mp;
14891 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14892 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14894 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14895 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14896 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14897 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14900 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14901 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14902 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14903 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14904 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14905 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14909 if (unformat (i, "del"))
14911 if (unformat (i, "outbound"))
14913 if (unformat (i, "inbound"))
14915 else if (unformat (i, "spd_id %d", &spd_id))
14917 else if (unformat (i, "sa_id %d", &sa_id))
14919 else if (unformat (i, "priority %d", &priority))
14921 else if (unformat (i, "protocol %d", &protocol))
14923 else if (unformat (i, "lport_start %d", &lport_start))
14925 else if (unformat (i, "lport_stop %d", &lport_stop))
14927 else if (unformat (i, "rport_start %d", &rport_start))
14929 else if (unformat (i, "rport_stop %d", &rport_stop))
14933 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14939 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14946 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14952 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14959 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14965 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14972 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14978 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14984 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14986 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14988 clib_warning ("unsupported action: 'resolve'");
14994 clib_warning ("parse error '%U'", format_unformat_error, i);
15000 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
15002 mp->spd_id = ntohl (spd_id);
15003 mp->priority = ntohl (priority);
15004 mp->is_outbound = is_outbound;
15006 mp->is_ipv6 = is_ipv6;
15007 if (is_ipv6 || is_ip_any)
15009 clib_memcpy (mp->remote_address_start, &raddr6_start,
15010 sizeof (ip6_address_t));
15011 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
15012 sizeof (ip6_address_t));
15013 clib_memcpy (mp->local_address_start, &laddr6_start,
15014 sizeof (ip6_address_t));
15015 clib_memcpy (mp->local_address_stop, &laddr6_stop,
15016 sizeof (ip6_address_t));
15020 clib_memcpy (mp->remote_address_start, &raddr4_start,
15021 sizeof (ip4_address_t));
15022 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
15023 sizeof (ip4_address_t));
15024 clib_memcpy (mp->local_address_start, &laddr4_start,
15025 sizeof (ip4_address_t));
15026 clib_memcpy (mp->local_address_stop, &laddr4_stop,
15027 sizeof (ip4_address_t));
15029 mp->protocol = (u8) protocol;
15030 mp->local_port_start = ntohs ((u16) lport_start);
15031 mp->local_port_stop = ntohs ((u16) lport_stop);
15032 mp->remote_port_start = ntohs ((u16) rport_start);
15033 mp->remote_port_stop = ntohs ((u16) rport_stop);
15034 mp->policy = (u8) policy;
15035 mp->sa_id = ntohl (sa_id);
15036 mp->is_add = is_add;
15037 mp->is_ip_any = is_ip_any;
15044 api_ipsec_sad_add_del_entry (vat_main_t * vam)
15046 unformat_input_t *i = vam->input;
15047 vl_api_ipsec_sad_add_del_entry_t *mp;
15048 u32 sad_id = 0, spi = 0;
15049 u8 *ck = 0, *ik = 0;
15052 u8 protocol = IPSEC_PROTOCOL_AH;
15053 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
15054 u32 crypto_alg = 0, integ_alg = 0;
15055 ip4_address_t tun_src4;
15056 ip4_address_t tun_dst4;
15057 ip6_address_t tun_src6;
15058 ip6_address_t tun_dst6;
15061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15063 if (unformat (i, "del"))
15065 else if (unformat (i, "sad_id %d", &sad_id))
15067 else if (unformat (i, "spi %d", &spi))
15069 else if (unformat (i, "esp"))
15070 protocol = IPSEC_PROTOCOL_ESP;
15071 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
15074 is_tunnel_ipv6 = 0;
15076 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
15079 is_tunnel_ipv6 = 0;
15081 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
15084 is_tunnel_ipv6 = 1;
15086 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
15089 is_tunnel_ipv6 = 1;
15093 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15095 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
15096 crypto_alg >= IPSEC_CRYPTO_N_ALG)
15098 clib_warning ("unsupported crypto-alg: '%U'",
15099 format_ipsec_crypto_alg, crypto_alg);
15103 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15107 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15109 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
15110 integ_alg >= IPSEC_INTEG_N_ALG)
15112 clib_warning ("unsupported integ-alg: '%U'",
15113 format_ipsec_integ_alg, integ_alg);
15117 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15121 clib_warning ("parse error '%U'", format_unformat_error, i);
15127 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
15129 mp->sad_id = ntohl (sad_id);
15130 mp->is_add = is_add;
15131 mp->protocol = protocol;
15132 mp->spi = ntohl (spi);
15133 mp->is_tunnel = is_tunnel;
15134 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
15135 mp->crypto_algorithm = crypto_alg;
15136 mp->integrity_algorithm = integ_alg;
15137 mp->crypto_key_length = vec_len (ck);
15138 mp->integrity_key_length = vec_len (ik);
15140 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15141 mp->crypto_key_length = sizeof (mp->crypto_key);
15143 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15144 mp->integrity_key_length = sizeof (mp->integrity_key);
15147 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15149 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15153 if (is_tunnel_ipv6)
15155 clib_memcpy (mp->tunnel_src_address, &tun_src6,
15156 sizeof (ip6_address_t));
15157 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
15158 sizeof (ip6_address_t));
15162 clib_memcpy (mp->tunnel_src_address, &tun_src4,
15163 sizeof (ip4_address_t));
15164 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
15165 sizeof (ip4_address_t));
15175 api_ipsec_sa_set_key (vat_main_t * vam)
15177 unformat_input_t *i = vam->input;
15178 vl_api_ipsec_sa_set_key_t *mp;
15180 u8 *ck = 0, *ik = 0;
15183 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15185 if (unformat (i, "sa_id %d", &sa_id))
15187 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15189 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15193 clib_warning ("parse error '%U'", format_unformat_error, i);
15198 M (IPSEC_SA_SET_KEY, mp);
15200 mp->sa_id = ntohl (sa_id);
15201 mp->crypto_key_length = vec_len (ck);
15202 mp->integrity_key_length = vec_len (ik);
15204 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15205 mp->crypto_key_length = sizeof (mp->crypto_key);
15207 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15208 mp->integrity_key_length = sizeof (mp->integrity_key);
15211 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15213 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15221 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
15223 unformat_input_t *i = vam->input;
15224 vl_api_ipsec_tunnel_if_add_del_t *mp;
15225 u32 local_spi = 0, remote_spi = 0;
15226 u32 crypto_alg = 0, integ_alg = 0;
15227 u8 *lck = NULL, *rck = NULL;
15228 u8 *lik = NULL, *rik = NULL;
15229 ip4_address_t local_ip = { {0} };
15230 ip4_address_t remote_ip = { {0} };
15233 u8 anti_replay = 0;
15236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15238 if (unformat (i, "del"))
15240 else if (unformat (i, "esn"))
15242 else if (unformat (i, "anti_replay"))
15244 else if (unformat (i, "local_spi %d", &local_spi))
15246 else if (unformat (i, "remote_spi %d", &remote_spi))
15248 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
15250 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
15252 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
15255 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
15257 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15259 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15263 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15265 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
15266 crypto_alg >= IPSEC_CRYPTO_N_ALG)
15268 errmsg ("unsupported crypto-alg: '%U'\n",
15269 format_ipsec_crypto_alg, crypto_alg);
15275 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15277 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
15278 integ_alg >= IPSEC_INTEG_N_ALG)
15280 errmsg ("unsupported integ-alg: '%U'\n",
15281 format_ipsec_integ_alg, integ_alg);
15287 errmsg ("parse error '%U'\n", format_unformat_error, i);
15292 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15294 mp->is_add = is_add;
15296 mp->anti_replay = anti_replay;
15298 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
15299 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
15301 mp->local_spi = htonl (local_spi);
15302 mp->remote_spi = htonl (remote_spi);
15303 mp->crypto_alg = (u8) crypto_alg;
15305 mp->local_crypto_key_len = 0;
15308 mp->local_crypto_key_len = vec_len (lck);
15309 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15310 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15311 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15314 mp->remote_crypto_key_len = 0;
15317 mp->remote_crypto_key_len = vec_len (rck);
15318 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15319 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15320 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15323 mp->integ_alg = (u8) integ_alg;
15325 mp->local_integ_key_len = 0;
15328 mp->local_integ_key_len = vec_len (lik);
15329 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15330 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15331 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15334 mp->remote_integ_key_len = 0;
15337 mp->remote_integ_key_len = vec_len (rik);
15338 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15339 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15340 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15349 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15351 vat_main_t *vam = &vat_main;
15353 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15354 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
15355 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
15356 "tunnel_src_addr %U tunnel_dst_addr %U "
15357 "salt %u seq_outbound %lu last_seq_inbound %lu "
15358 "replay_window %lu total_data_size %lu\n",
15359 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
15361 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
15362 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
15363 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
15364 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15365 mp->tunnel_src_addr,
15366 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15367 mp->tunnel_dst_addr,
15369 clib_net_to_host_u64 (mp->seq_outbound),
15370 clib_net_to_host_u64 (mp->last_seq_inbound),
15371 clib_net_to_host_u64 (mp->replay_window),
15372 clib_net_to_host_u64 (mp->total_data_size));
15375 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15376 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15378 static void vl_api_ipsec_sa_details_t_handler_json
15379 (vl_api_ipsec_sa_details_t * mp)
15381 vat_main_t *vam = &vat_main;
15382 vat_json_node_t *node = NULL;
15383 struct in_addr src_ip4, dst_ip4;
15384 struct in6_addr src_ip6, dst_ip6;
15386 if (VAT_JSON_ARRAY != vam->json_tree.type)
15388 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15389 vat_json_init_array (&vam->json_tree);
15391 node = vat_json_array_add (&vam->json_tree);
15393 vat_json_init_object (node);
15394 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
15395 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15396 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
15397 vat_json_object_add_uint (node, "proto", mp->protocol);
15398 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
15399 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
15400 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
15401 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
15402 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
15403 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
15404 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
15405 mp->crypto_key_len);
15406 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
15407 mp->integ_key_len);
15408 if (mp->is_tunnel_ip6)
15410 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
15411 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
15412 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
15413 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
15417 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
15418 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
15419 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
15420 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
15422 vat_json_object_add_uint (node, "replay_window",
15423 clib_net_to_host_u64 (mp->replay_window));
15424 vat_json_object_add_uint (node, "total_data_size",
15425 clib_net_to_host_u64 (mp->total_data_size));
15430 api_ipsec_sa_dump (vat_main_t * vam)
15432 unformat_input_t *i = vam->input;
15433 vl_api_ipsec_sa_dump_t *mp;
15434 vl_api_control_ping_t *mp_ping;
15438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15440 if (unformat (i, "sa_id %d", &sa_id))
15444 clib_warning ("parse error '%U'", format_unformat_error, i);
15449 M (IPSEC_SA_DUMP, mp);
15451 mp->sa_id = ntohl (sa_id);
15455 /* Use a control ping for synchronization */
15456 M (CONTROL_PING, mp_ping);
15464 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15466 unformat_input_t *i = vam->input;
15467 vl_api_ipsec_tunnel_if_set_key_t *mp;
15468 u32 sw_if_index = ~0;
15469 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15474 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15476 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15479 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
15480 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15482 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
15483 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15484 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
15485 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15487 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
15488 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15489 else if (unformat (i, "%U", unformat_hex_string, &key))
15493 clib_warning ("parse error '%U'", format_unformat_error, i);
15498 if (sw_if_index == ~0)
15500 errmsg ("interface must be specified");
15504 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15506 errmsg ("key type must be specified");
15512 errmsg ("algorithm must be specified");
15516 if (vec_len (key) == 0)
15518 errmsg ("key must be specified");
15522 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15524 mp->sw_if_index = htonl (sw_if_index);
15526 mp->key_type = key_type;
15527 mp->key_len = vec_len (key);
15528 clib_memcpy (mp->key, key, vec_len (key));
15537 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15539 unformat_input_t *i = vam->input;
15540 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15541 u32 sw_if_index = ~0;
15543 u8 is_outbound = (u8) ~ 0;
15546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15548 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15550 else if (unformat (i, "sa_id %d", &sa_id))
15552 else if (unformat (i, "outbound"))
15554 else if (unformat (i, "inbound"))
15558 clib_warning ("parse error '%U'", format_unformat_error, i);
15563 if (sw_if_index == ~0)
15565 errmsg ("interface must be specified");
15571 errmsg ("SA ID must be specified");
15575 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15577 mp->sw_if_index = htonl (sw_if_index);
15578 mp->sa_id = htonl (sa_id);
15579 mp->is_outbound = is_outbound;
15588 api_ikev2_profile_add_del (vat_main_t * vam)
15590 unformat_input_t *i = vam->input;
15591 vl_api_ikev2_profile_add_del_t *mp;
15596 const char *valid_chars = "a-zA-Z0-9_";
15598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15600 if (unformat (i, "del"))
15602 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15603 vec_add1 (name, 0);
15606 errmsg ("parse error '%U'", format_unformat_error, i);
15611 if (!vec_len (name))
15613 errmsg ("profile name must be specified");
15617 if (vec_len (name) > 64)
15619 errmsg ("profile name too long");
15623 M (IKEV2_PROFILE_ADD_DEL, mp);
15625 clib_memcpy (mp->name, name, vec_len (name));
15626 mp->is_add = is_add;
15635 api_ikev2_profile_set_auth (vat_main_t * vam)
15637 unformat_input_t *i = vam->input;
15638 vl_api_ikev2_profile_set_auth_t *mp;
15641 u32 auth_method = 0;
15645 const char *valid_chars = "a-zA-Z0-9_";
15647 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15649 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15650 vec_add1 (name, 0);
15651 else if (unformat (i, "auth_method %U",
15652 unformat_ikev2_auth_method, &auth_method))
15654 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15656 else if (unformat (i, "auth_data %v", &data))
15660 errmsg ("parse error '%U'", format_unformat_error, i);
15665 if (!vec_len (name))
15667 errmsg ("profile name must be specified");
15671 if (vec_len (name) > 64)
15673 errmsg ("profile name too long");
15677 if (!vec_len (data))
15679 errmsg ("auth_data must be specified");
15685 errmsg ("auth_method must be specified");
15689 M (IKEV2_PROFILE_SET_AUTH, mp);
15691 mp->is_hex = is_hex;
15692 mp->auth_method = (u8) auth_method;
15693 mp->data_len = vec_len (data);
15694 clib_memcpy (mp->name, name, vec_len (name));
15695 clib_memcpy (mp->data, data, vec_len (data));
15705 api_ikev2_profile_set_id (vat_main_t * vam)
15707 unformat_input_t *i = vam->input;
15708 vl_api_ikev2_profile_set_id_t *mp;
15716 const char *valid_chars = "a-zA-Z0-9_";
15718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15720 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15721 vec_add1 (name, 0);
15722 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15724 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15726 data = vec_new (u8, 4);
15727 clib_memcpy (data, ip4.as_u8, 4);
15729 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15731 else if (unformat (i, "id_data %v", &data))
15733 else if (unformat (i, "local"))
15735 else if (unformat (i, "remote"))
15739 errmsg ("parse error '%U'", format_unformat_error, i);
15744 if (!vec_len (name))
15746 errmsg ("profile name must be specified");
15750 if (vec_len (name) > 64)
15752 errmsg ("profile name too long");
15756 if (!vec_len (data))
15758 errmsg ("id_data must be specified");
15764 errmsg ("id_type must be specified");
15768 M (IKEV2_PROFILE_SET_ID, mp);
15770 mp->is_local = is_local;
15771 mp->id_type = (u8) id_type;
15772 mp->data_len = vec_len (data);
15773 clib_memcpy (mp->name, name, vec_len (name));
15774 clib_memcpy (mp->data, data, vec_len (data));
15784 api_ikev2_profile_set_ts (vat_main_t * vam)
15786 unformat_input_t *i = vam->input;
15787 vl_api_ikev2_profile_set_ts_t *mp;
15790 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15791 ip4_address_t start_addr, end_addr;
15793 const char *valid_chars = "a-zA-Z0-9_";
15796 start_addr.as_u32 = 0;
15797 end_addr.as_u32 = (u32) ~ 0;
15799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15801 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15802 vec_add1 (name, 0);
15803 else if (unformat (i, "protocol %d", &proto))
15805 else if (unformat (i, "start_port %d", &start_port))
15807 else if (unformat (i, "end_port %d", &end_port))
15810 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15812 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15814 else if (unformat (i, "local"))
15816 else if (unformat (i, "remote"))
15820 errmsg ("parse error '%U'", format_unformat_error, i);
15825 if (!vec_len (name))
15827 errmsg ("profile name must be specified");
15831 if (vec_len (name) > 64)
15833 errmsg ("profile name too long");
15837 M (IKEV2_PROFILE_SET_TS, mp);
15839 mp->is_local = is_local;
15840 mp->proto = (u8) proto;
15841 mp->start_port = (u16) start_port;
15842 mp->end_port = (u16) end_port;
15843 mp->start_addr = start_addr.as_u32;
15844 mp->end_addr = end_addr.as_u32;
15845 clib_memcpy (mp->name, name, vec_len (name));
15854 api_ikev2_set_local_key (vat_main_t * vam)
15856 unformat_input_t *i = vam->input;
15857 vl_api_ikev2_set_local_key_t *mp;
15861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15863 if (unformat (i, "file %v", &file))
15864 vec_add1 (file, 0);
15867 errmsg ("parse error '%U'", format_unformat_error, i);
15872 if (!vec_len (file))
15874 errmsg ("RSA key file must be specified");
15878 if (vec_len (file) > 256)
15880 errmsg ("file name too long");
15884 M (IKEV2_SET_LOCAL_KEY, mp);
15886 clib_memcpy (mp->key_file, file, vec_len (file));
15895 api_ikev2_set_responder (vat_main_t * vam)
15897 unformat_input_t *i = vam->input;
15898 vl_api_ikev2_set_responder_t *mp;
15901 u32 sw_if_index = ~0;
15902 ip4_address_t address;
15904 const char *valid_chars = "a-zA-Z0-9_";
15906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15909 (i, "%U interface %d address %U", unformat_token, valid_chars,
15910 &name, &sw_if_index, unformat_ip4_address, &address))
15911 vec_add1 (name, 0);
15914 errmsg ("parse error '%U'", format_unformat_error, i);
15919 if (!vec_len (name))
15921 errmsg ("profile name must be specified");
15925 if (vec_len (name) > 64)
15927 errmsg ("profile name too long");
15931 M (IKEV2_SET_RESPONDER, mp);
15933 clib_memcpy (mp->name, name, vec_len (name));
15936 mp->sw_if_index = sw_if_index;
15937 clib_memcpy (mp->address, &address, sizeof (address));
15945 api_ikev2_set_ike_transforms (vat_main_t * vam)
15947 unformat_input_t *i = vam->input;
15948 vl_api_ikev2_set_ike_transforms_t *mp;
15951 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15953 const char *valid_chars = "a-zA-Z0-9_";
15955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15957 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15958 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15959 vec_add1 (name, 0);
15962 errmsg ("parse error '%U'", format_unformat_error, i);
15967 if (!vec_len (name))
15969 errmsg ("profile name must be specified");
15973 if (vec_len (name) > 64)
15975 errmsg ("profile name too long");
15979 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15981 clib_memcpy (mp->name, name, vec_len (name));
15983 mp->crypto_alg = crypto_alg;
15984 mp->crypto_key_size = crypto_key_size;
15985 mp->integ_alg = integ_alg;
15986 mp->dh_group = dh_group;
15995 api_ikev2_set_esp_transforms (vat_main_t * vam)
15997 unformat_input_t *i = vam->input;
15998 vl_api_ikev2_set_esp_transforms_t *mp;
16001 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
16003 const char *valid_chars = "a-zA-Z0-9_";
16005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16007 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
16008 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
16009 vec_add1 (name, 0);
16012 errmsg ("parse error '%U'", format_unformat_error, i);
16017 if (!vec_len (name))
16019 errmsg ("profile name must be specified");
16023 if (vec_len (name) > 64)
16025 errmsg ("profile name too long");
16029 M (IKEV2_SET_ESP_TRANSFORMS, mp);
16031 clib_memcpy (mp->name, name, vec_len (name));
16033 mp->crypto_alg = crypto_alg;
16034 mp->crypto_key_size = crypto_key_size;
16035 mp->integ_alg = integ_alg;
16036 mp->dh_group = dh_group;
16044 api_ikev2_set_sa_lifetime (vat_main_t * vam)
16046 unformat_input_t *i = vam->input;
16047 vl_api_ikev2_set_sa_lifetime_t *mp;
16050 u64 lifetime, lifetime_maxdata;
16051 u32 lifetime_jitter, handover;
16053 const char *valid_chars = "a-zA-Z0-9_";
16055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16057 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
16058 &lifetime, &lifetime_jitter, &handover,
16059 &lifetime_maxdata))
16060 vec_add1 (name, 0);
16063 errmsg ("parse error '%U'", format_unformat_error, i);
16068 if (!vec_len (name))
16070 errmsg ("profile name must be specified");
16074 if (vec_len (name) > 64)
16076 errmsg ("profile name too long");
16080 M (IKEV2_SET_SA_LIFETIME, mp);
16082 clib_memcpy (mp->name, name, vec_len (name));
16084 mp->lifetime = lifetime;
16085 mp->lifetime_jitter = lifetime_jitter;
16086 mp->handover = handover;
16087 mp->lifetime_maxdata = lifetime_maxdata;
16095 api_ikev2_initiate_sa_init (vat_main_t * vam)
16097 unformat_input_t *i = vam->input;
16098 vl_api_ikev2_initiate_sa_init_t *mp;
16102 const char *valid_chars = "a-zA-Z0-9_";
16104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16106 if (unformat (i, "%U", unformat_token, valid_chars, &name))
16107 vec_add1 (name, 0);
16110 errmsg ("parse error '%U'", format_unformat_error, i);
16115 if (!vec_len (name))
16117 errmsg ("profile name must be specified");
16121 if (vec_len (name) > 64)
16123 errmsg ("profile name too long");
16127 M (IKEV2_INITIATE_SA_INIT, mp);
16129 clib_memcpy (mp->name, name, vec_len (name));
16138 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
16140 unformat_input_t *i = vam->input;
16141 vl_api_ikev2_initiate_del_ike_sa_t *mp;
16146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16148 if (unformat (i, "%lx", &ispi))
16152 errmsg ("parse error '%U'", format_unformat_error, i);
16157 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
16167 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
16169 unformat_input_t *i = vam->input;
16170 vl_api_ikev2_initiate_del_child_sa_t *mp;
16175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16177 if (unformat (i, "%x", &ispi))
16181 errmsg ("parse error '%U'", format_unformat_error, i);
16186 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
16196 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
16198 unformat_input_t *i = vam->input;
16199 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
16204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16206 if (unformat (i, "%x", &ispi))
16210 errmsg ("parse error '%U'", format_unformat_error, i);
16215 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
16228 api_map_add_domain (vat_main_t * vam)
16230 unformat_input_t *i = vam->input;
16231 vl_api_map_add_domain_t *mp;
16233 ip4_address_t ip4_prefix;
16234 ip6_address_t ip6_prefix;
16235 ip6_address_t ip6_src;
16236 u32 num_m_args = 0;
16237 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
16238 0, psid_length = 0;
16239 u8 is_translation = 0;
16241 u32 ip6_src_len = 128;
16244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16246 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
16247 &ip4_prefix, &ip4_prefix_len))
16249 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
16250 &ip6_prefix, &ip6_prefix_len))
16254 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
16257 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
16259 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
16261 else if (unformat (i, "psid-offset %d", &psid_offset))
16263 else if (unformat (i, "psid-len %d", &psid_length))
16265 else if (unformat (i, "mtu %d", &mtu))
16267 else if (unformat (i, "map-t"))
16268 is_translation = 1;
16271 clib_warning ("parse error '%U'", format_unformat_error, i);
16276 if (num_m_args < 3)
16278 errmsg ("mandatory argument(s) missing");
16282 /* Construct the API message */
16283 M (MAP_ADD_DOMAIN, mp);
16285 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
16286 mp->ip4_prefix_len = ip4_prefix_len;
16288 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
16289 mp->ip6_prefix_len = ip6_prefix_len;
16291 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
16292 mp->ip6_src_prefix_len = ip6_src_len;
16294 mp->ea_bits_len = ea_bits_len;
16295 mp->psid_offset = psid_offset;
16296 mp->psid_length = psid_length;
16297 mp->is_translation = is_translation;
16298 mp->mtu = htons (mtu);
16303 /* Wait for a reply, return good/bad news */
16309 api_map_del_domain (vat_main_t * vam)
16311 unformat_input_t *i = vam->input;
16312 vl_api_map_del_domain_t *mp;
16314 u32 num_m_args = 0;
16318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16320 if (unformat (i, "index %d", &index))
16324 clib_warning ("parse error '%U'", format_unformat_error, i);
16329 if (num_m_args != 1)
16331 errmsg ("mandatory argument(s) missing");
16335 /* Construct the API message */
16336 M (MAP_DEL_DOMAIN, mp);
16338 mp->index = ntohl (index);
16343 /* Wait for a reply, return good/bad news */
16349 api_map_add_del_rule (vat_main_t * vam)
16351 unformat_input_t *i = vam->input;
16352 vl_api_map_add_del_rule_t *mp;
16354 ip6_address_t ip6_dst;
16355 u32 num_m_args = 0, index, psid = 0;
16358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16360 if (unformat (i, "index %d", &index))
16362 else if (unformat (i, "psid %d", &psid))
16364 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
16366 else if (unformat (i, "del"))
16372 clib_warning ("parse error '%U'", format_unformat_error, i);
16377 /* Construct the API message */
16378 M (MAP_ADD_DEL_RULE, mp);
16380 mp->index = ntohl (index);
16381 mp->is_add = is_add;
16382 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
16383 mp->psid = ntohs (psid);
16388 /* Wait for a reply, return good/bad news */
16394 api_map_domain_dump (vat_main_t * vam)
16396 vl_api_map_domain_dump_t *mp;
16397 vl_api_control_ping_t *mp_ping;
16400 /* Construct the API message */
16401 M (MAP_DOMAIN_DUMP, mp);
16406 /* Use a control ping for synchronization */
16407 MPING (CONTROL_PING, mp_ping);
16415 api_map_rule_dump (vat_main_t * vam)
16417 unformat_input_t *i = vam->input;
16418 vl_api_map_rule_dump_t *mp;
16419 vl_api_control_ping_t *mp_ping;
16420 u32 domain_index = ~0;
16423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16425 if (unformat (i, "index %u", &domain_index))
16431 if (domain_index == ~0)
16433 clib_warning ("parse error: domain index expected");
16437 /* Construct the API message */
16438 M (MAP_RULE_DUMP, mp);
16440 mp->domain_index = htonl (domain_index);
16445 /* Use a control ping for synchronization */
16446 MPING (CONTROL_PING, mp_ping);
16453 static void vl_api_map_add_domain_reply_t_handler
16454 (vl_api_map_add_domain_reply_t * mp)
16456 vat_main_t *vam = &vat_main;
16457 i32 retval = ntohl (mp->retval);
16459 if (vam->async_mode)
16461 vam->async_errors += (retval < 0);
16465 vam->retval = retval;
16466 vam->result_ready = 1;
16470 static void vl_api_map_add_domain_reply_t_handler_json
16471 (vl_api_map_add_domain_reply_t * mp)
16473 vat_main_t *vam = &vat_main;
16474 vat_json_node_t node;
16476 vat_json_init_object (&node);
16477 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
16478 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
16480 vat_json_print (vam->ofp, &node);
16481 vat_json_free (&node);
16483 vam->retval = ntohl (mp->retval);
16484 vam->result_ready = 1;
16488 api_get_first_msg_id (vat_main_t * vam)
16490 vl_api_get_first_msg_id_t *mp;
16491 unformat_input_t *i = vam->input;
16496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16498 if (unformat (i, "client %s", &name))
16506 errmsg ("missing client name");
16509 vec_add1 (name, 0);
16511 if (vec_len (name) > 63)
16513 errmsg ("client name too long");
16517 M (GET_FIRST_MSG_ID, mp);
16518 clib_memcpy (mp->name, name, vec_len (name));
16525 api_cop_interface_enable_disable (vat_main_t * vam)
16527 unformat_input_t *line_input = vam->input;
16528 vl_api_cop_interface_enable_disable_t *mp;
16529 u32 sw_if_index = ~0;
16530 u8 enable_disable = 1;
16533 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16535 if (unformat (line_input, "disable"))
16536 enable_disable = 0;
16537 if (unformat (line_input, "enable"))
16538 enable_disable = 1;
16539 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16540 vam, &sw_if_index))
16542 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16548 if (sw_if_index == ~0)
16550 errmsg ("missing interface name or sw_if_index");
16554 /* Construct the API message */
16555 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16556 mp->sw_if_index = ntohl (sw_if_index);
16557 mp->enable_disable = enable_disable;
16561 /* Wait for the reply */
16567 api_cop_whitelist_enable_disable (vat_main_t * vam)
16569 unformat_input_t *line_input = vam->input;
16570 vl_api_cop_whitelist_enable_disable_t *mp;
16571 u32 sw_if_index = ~0;
16572 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16576 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16578 if (unformat (line_input, "ip4"))
16580 else if (unformat (line_input, "ip6"))
16582 else if (unformat (line_input, "default"))
16584 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16585 vam, &sw_if_index))
16587 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16589 else if (unformat (line_input, "fib-id %d", &fib_id))
16595 if (sw_if_index == ~0)
16597 errmsg ("missing interface name or sw_if_index");
16601 /* Construct the API message */
16602 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16603 mp->sw_if_index = ntohl (sw_if_index);
16604 mp->fib_id = ntohl (fib_id);
16607 mp->default_cop = default_cop;
16611 /* Wait for the reply */
16617 api_get_node_graph (vat_main_t * vam)
16619 vl_api_get_node_graph_t *mp;
16622 M (GET_NODE_GRAPH, mp);
16626 /* Wait for the reply */
16632 /** Used for parsing LISP eids */
16633 typedef CLIB_PACKED(struct{
16634 u8 addr[16]; /**< eid address */
16635 u32 len; /**< prefix length if IP */
16636 u8 type; /**< type of eid */
16641 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16643 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16645 memset (a, 0, sizeof (a[0]));
16647 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16649 a->type = 0; /* ipv4 type */
16651 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16653 a->type = 1; /* ipv6 type */
16655 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16657 a->type = 2; /* mac type */
16659 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16661 a->type = 3; /* NSH type */
16662 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16663 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16670 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16679 lisp_eid_size_vat (u8 type)
16696 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16698 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16702 api_one_add_del_locator_set (vat_main_t * vam)
16704 unformat_input_t *input = vam->input;
16705 vl_api_one_add_del_locator_set_t *mp;
16707 u8 *locator_set_name = NULL;
16708 u8 locator_set_name_set = 0;
16709 vl_api_local_locator_t locator, *locators = 0;
16710 u32 sw_if_index, priority, weight;
16714 /* Parse args required to build the message */
16715 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16717 if (unformat (input, "del"))
16721 else if (unformat (input, "locator-set %s", &locator_set_name))
16723 locator_set_name_set = 1;
16725 else if (unformat (input, "sw_if_index %u p %u w %u",
16726 &sw_if_index, &priority, &weight))
16728 locator.sw_if_index = htonl (sw_if_index);
16729 locator.priority = priority;
16730 locator.weight = weight;
16731 vec_add1 (locators, locator);
16735 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16736 &sw_if_index, &priority, &weight))
16738 locator.sw_if_index = htonl (sw_if_index);
16739 locator.priority = priority;
16740 locator.weight = weight;
16741 vec_add1 (locators, locator);
16747 if (locator_set_name_set == 0)
16749 errmsg ("missing locator-set name");
16750 vec_free (locators);
16754 if (vec_len (locator_set_name) > 64)
16756 errmsg ("locator-set name too long");
16757 vec_free (locator_set_name);
16758 vec_free (locators);
16761 vec_add1 (locator_set_name, 0);
16763 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16765 /* Construct the API message */
16766 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16768 mp->is_add = is_add;
16769 clib_memcpy (mp->locator_set_name, locator_set_name,
16770 vec_len (locator_set_name));
16771 vec_free (locator_set_name);
16773 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16775 clib_memcpy (mp->locators, locators, data_len);
16776 vec_free (locators);
16781 /* Wait for a reply... */
16786 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16789 api_one_add_del_locator (vat_main_t * vam)
16791 unformat_input_t *input = vam->input;
16792 vl_api_one_add_del_locator_t *mp;
16793 u32 tmp_if_index = ~0;
16794 u32 sw_if_index = ~0;
16795 u8 sw_if_index_set = 0;
16796 u8 sw_if_index_if_name_set = 0;
16798 u8 priority_set = 0;
16802 u8 *locator_set_name = NULL;
16803 u8 locator_set_name_set = 0;
16806 /* Parse args required to build the message */
16807 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16809 if (unformat (input, "del"))
16813 else if (unformat (input, "locator-set %s", &locator_set_name))
16815 locator_set_name_set = 1;
16817 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16820 sw_if_index_if_name_set = 1;
16821 sw_if_index = tmp_if_index;
16823 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16825 sw_if_index_set = 1;
16826 sw_if_index = tmp_if_index;
16828 else if (unformat (input, "p %d", &priority))
16832 else if (unformat (input, "w %d", &weight))
16840 if (locator_set_name_set == 0)
16842 errmsg ("missing locator-set name");
16846 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16848 errmsg ("missing sw_if_index");
16849 vec_free (locator_set_name);
16853 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16855 errmsg ("cannot use both params interface name and sw_if_index");
16856 vec_free (locator_set_name);
16860 if (priority_set == 0)
16862 errmsg ("missing locator-set priority");
16863 vec_free (locator_set_name);
16867 if (weight_set == 0)
16869 errmsg ("missing locator-set weight");
16870 vec_free (locator_set_name);
16874 if (vec_len (locator_set_name) > 64)
16876 errmsg ("locator-set name too long");
16877 vec_free (locator_set_name);
16880 vec_add1 (locator_set_name, 0);
16882 /* Construct the API message */
16883 M (ONE_ADD_DEL_LOCATOR, mp);
16885 mp->is_add = is_add;
16886 mp->sw_if_index = ntohl (sw_if_index);
16887 mp->priority = priority;
16888 mp->weight = weight;
16889 clib_memcpy (mp->locator_set_name, locator_set_name,
16890 vec_len (locator_set_name));
16891 vec_free (locator_set_name);
16896 /* Wait for a reply... */
16901 #define api_lisp_add_del_locator api_one_add_del_locator
16904 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16906 u32 *key_id = va_arg (*args, u32 *);
16909 if (unformat (input, "%s", &s))
16911 if (!strcmp ((char *) s, "sha1"))
16912 key_id[0] = HMAC_SHA_1_96;
16913 else if (!strcmp ((char *) s, "sha256"))
16914 key_id[0] = HMAC_SHA_256_128;
16917 clib_warning ("invalid key_id: '%s'", s);
16918 key_id[0] = HMAC_NO_KEY;
16929 api_one_add_del_local_eid (vat_main_t * vam)
16931 unformat_input_t *input = vam->input;
16932 vl_api_one_add_del_local_eid_t *mp;
16935 lisp_eid_vat_t _eid, *eid = &_eid;
16936 u8 *locator_set_name = 0;
16937 u8 locator_set_name_set = 0;
16943 /* Parse args required to build the message */
16944 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16946 if (unformat (input, "del"))
16950 else if (unformat (input, "vni %d", &vni))
16954 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16958 else if (unformat (input, "locator-set %s", &locator_set_name))
16960 locator_set_name_set = 1;
16962 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16964 else if (unformat (input, "secret-key %_%v%_", &key))
16970 if (locator_set_name_set == 0)
16972 errmsg ("missing locator-set name");
16978 errmsg ("EID address not set!");
16979 vec_free (locator_set_name);
16983 if (key && (0 == key_id))
16985 errmsg ("invalid key_id!");
16989 if (vec_len (key) > 64)
16991 errmsg ("key too long");
16996 if (vec_len (locator_set_name) > 64)
16998 errmsg ("locator-set name too long");
16999 vec_free (locator_set_name);
17002 vec_add1 (locator_set_name, 0);
17004 /* Construct the API message */
17005 M (ONE_ADD_DEL_LOCAL_EID, mp);
17007 mp->is_add = is_add;
17008 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17009 mp->eid_type = eid->type;
17010 mp->prefix_len = eid->len;
17011 mp->vni = clib_host_to_net_u32 (vni);
17012 mp->key_id = clib_host_to_net_u16 (key_id);
17013 clib_memcpy (mp->locator_set_name, locator_set_name,
17014 vec_len (locator_set_name));
17015 clib_memcpy (mp->key, key, vec_len (key));
17017 vec_free (locator_set_name);
17023 /* Wait for a reply... */
17028 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
17031 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
17033 u32 dp_table = 0, vni = 0;;
17034 unformat_input_t *input = vam->input;
17035 vl_api_gpe_add_del_fwd_entry_t *mp;
17037 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
17038 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
17039 u8 rmt_eid_set = 0, lcl_eid_set = 0;
17040 u32 action = ~0, w;
17041 ip4_address_t rmt_rloc4, lcl_rloc4;
17042 ip6_address_t rmt_rloc6, lcl_rloc6;
17043 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
17046 memset (&rloc, 0, sizeof (rloc));
17048 /* Parse args required to build the message */
17049 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17051 if (unformat (input, "del"))
17053 else if (unformat (input, "add"))
17055 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
17059 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
17063 else if (unformat (input, "vrf %d", &dp_table))
17065 else if (unformat (input, "bd %d", &dp_table))
17067 else if (unformat (input, "vni %d", &vni))
17069 else if (unformat (input, "w %d", &w))
17073 errmsg ("No RLOC configured for setting priority/weight!");
17076 curr_rloc->weight = w;
17078 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
17079 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
17083 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
17085 vec_add1 (lcl_locs, rloc);
17087 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
17088 vec_add1 (rmt_locs, rloc);
17089 /* weight saved in rmt loc */
17090 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
17092 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
17093 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
17096 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
17098 vec_add1 (lcl_locs, rloc);
17100 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
17101 vec_add1 (rmt_locs, rloc);
17102 /* weight saved in rmt loc */
17103 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
17105 else if (unformat (input, "action %d", &action))
17111 clib_warning ("parse error '%U'", format_unformat_error, input);
17118 errmsg ("remote eid addresses not set");
17122 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
17124 errmsg ("eid types don't match");
17128 if (0 == rmt_locs && (u32) ~ 0 == action)
17130 errmsg ("action not set for negative mapping");
17134 /* Construct the API message */
17135 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
17136 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
17138 mp->is_add = is_add;
17139 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
17140 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
17141 mp->eid_type = rmt_eid->type;
17142 mp->dp_table = clib_host_to_net_u32 (dp_table);
17143 mp->vni = clib_host_to_net_u32 (vni);
17144 mp->rmt_len = rmt_eid->len;
17145 mp->lcl_len = lcl_eid->len;
17146 mp->action = action;
17148 if (0 != rmt_locs && 0 != lcl_locs)
17150 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
17151 clib_memcpy (mp->locs, lcl_locs,
17152 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
17154 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
17155 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
17156 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
17158 vec_free (lcl_locs);
17159 vec_free (rmt_locs);
17164 /* Wait for a reply... */
17170 api_one_add_del_map_server (vat_main_t * vam)
17172 unformat_input_t *input = vam->input;
17173 vl_api_one_add_del_map_server_t *mp;
17177 ip4_address_t ipv4;
17178 ip6_address_t ipv6;
17181 /* Parse args required to build the message */
17182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17184 if (unformat (input, "del"))
17188 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
17192 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
17200 if (ipv4_set && ipv6_set)
17202 errmsg ("both eid v4 and v6 addresses set");
17206 if (!ipv4_set && !ipv6_set)
17208 errmsg ("eid addresses not set");
17212 /* Construct the API message */
17213 M (ONE_ADD_DEL_MAP_SERVER, mp);
17215 mp->is_add = is_add;
17219 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
17224 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
17230 /* Wait for a reply... */
17235 #define api_lisp_add_del_map_server api_one_add_del_map_server
17238 api_one_add_del_map_resolver (vat_main_t * vam)
17240 unformat_input_t *input = vam->input;
17241 vl_api_one_add_del_map_resolver_t *mp;
17245 ip4_address_t ipv4;
17246 ip6_address_t ipv6;
17249 /* Parse args required to build the message */
17250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17252 if (unformat (input, "del"))
17256 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
17260 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
17268 if (ipv4_set && ipv6_set)
17270 errmsg ("both eid v4 and v6 addresses set");
17274 if (!ipv4_set && !ipv6_set)
17276 errmsg ("eid addresses not set");
17280 /* Construct the API message */
17281 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
17283 mp->is_add = is_add;
17287 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
17292 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
17298 /* Wait for a reply... */
17303 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
17306 api_lisp_gpe_enable_disable (vat_main_t * vam)
17308 unformat_input_t *input = vam->input;
17309 vl_api_gpe_enable_disable_t *mp;
17314 /* Parse args required to build the message */
17315 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17317 if (unformat (input, "enable"))
17322 else if (unformat (input, "disable"))
17333 errmsg ("Value not set");
17337 /* Construct the API message */
17338 M (GPE_ENABLE_DISABLE, mp);
17345 /* Wait for a reply... */
17351 api_one_rloc_probe_enable_disable (vat_main_t * vam)
17353 unformat_input_t *input = vam->input;
17354 vl_api_one_rloc_probe_enable_disable_t *mp;
17359 /* Parse args required to build the message */
17360 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17362 if (unformat (input, "enable"))
17367 else if (unformat (input, "disable"))
17375 errmsg ("Value not set");
17379 /* Construct the API message */
17380 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
17382 mp->is_enabled = is_en;
17387 /* Wait for a reply... */
17392 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
17395 api_one_map_register_enable_disable (vat_main_t * vam)
17397 unformat_input_t *input = vam->input;
17398 vl_api_one_map_register_enable_disable_t *mp;
17403 /* Parse args required to build the message */
17404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17406 if (unformat (input, "enable"))
17411 else if (unformat (input, "disable"))
17419 errmsg ("Value not set");
17423 /* Construct the API message */
17424 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
17426 mp->is_enabled = is_en;
17431 /* Wait for a reply... */
17436 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
17439 api_one_enable_disable (vat_main_t * vam)
17441 unformat_input_t *input = vam->input;
17442 vl_api_one_enable_disable_t *mp;
17447 /* Parse args required to build the message */
17448 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17450 if (unformat (input, "enable"))
17455 else if (unformat (input, "disable"))
17465 errmsg ("Value not set");
17469 /* Construct the API message */
17470 M (ONE_ENABLE_DISABLE, mp);
17477 /* Wait for a reply... */
17482 #define api_lisp_enable_disable api_one_enable_disable
17485 api_one_enable_disable_xtr_mode (vat_main_t * vam)
17487 unformat_input_t *input = vam->input;
17488 vl_api_one_enable_disable_xtr_mode_t *mp;
17493 /* Parse args required to build the message */
17494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17496 if (unformat (input, "enable"))
17501 else if (unformat (input, "disable"))
17511 errmsg ("Value not set");
17515 /* Construct the API message */
17516 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
17523 /* Wait for a reply... */
17529 api_one_show_xtr_mode (vat_main_t * vam)
17531 vl_api_one_show_xtr_mode_t *mp;
17534 /* Construct the API message */
17535 M (ONE_SHOW_XTR_MODE, mp);
17540 /* Wait for a reply... */
17546 api_one_enable_disable_pitr_mode (vat_main_t * vam)
17548 unformat_input_t *input = vam->input;
17549 vl_api_one_enable_disable_pitr_mode_t *mp;
17554 /* Parse args required to build the message */
17555 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17557 if (unformat (input, "enable"))
17562 else if (unformat (input, "disable"))
17572 errmsg ("Value not set");
17576 /* Construct the API message */
17577 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17584 /* Wait for a reply... */
17590 api_one_show_pitr_mode (vat_main_t * vam)
17592 vl_api_one_show_pitr_mode_t *mp;
17595 /* Construct the API message */
17596 M (ONE_SHOW_PITR_MODE, mp);
17601 /* Wait for a reply... */
17607 api_one_enable_disable_petr_mode (vat_main_t * vam)
17609 unformat_input_t *input = vam->input;
17610 vl_api_one_enable_disable_petr_mode_t *mp;
17615 /* Parse args required to build the message */
17616 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17618 if (unformat (input, "enable"))
17623 else if (unformat (input, "disable"))
17633 errmsg ("Value not set");
17637 /* Construct the API message */
17638 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17645 /* Wait for a reply... */
17651 api_one_show_petr_mode (vat_main_t * vam)
17653 vl_api_one_show_petr_mode_t *mp;
17656 /* Construct the API message */
17657 M (ONE_SHOW_PETR_MODE, mp);
17662 /* Wait for a reply... */
17668 api_show_one_map_register_state (vat_main_t * vam)
17670 vl_api_show_one_map_register_state_t *mp;
17673 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17678 /* wait for reply */
17683 #define api_show_lisp_map_register_state api_show_one_map_register_state
17686 api_show_one_rloc_probe_state (vat_main_t * vam)
17688 vl_api_show_one_rloc_probe_state_t *mp;
17691 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17696 /* wait for reply */
17701 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17704 api_one_add_del_ndp_entry (vat_main_t * vam)
17706 vl_api_one_add_del_ndp_entry_t *mp;
17707 unformat_input_t *input = vam->input;
17712 u8 mac[6] = { 0, };
17713 u8 ip6[16] = { 0, };
17717 /* Parse args required to build the message */
17718 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17720 if (unformat (input, "del"))
17722 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17724 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17726 else if (unformat (input, "bd %d", &bd))
17730 errmsg ("parse error '%U'", format_unformat_error, input);
17735 if (!bd_set || !ip_set || (!mac_set && is_add))
17737 errmsg ("Missing BD, IP or MAC!");
17741 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17742 mp->is_add = is_add;
17743 clib_memcpy (mp->mac, mac, 6);
17744 mp->bd = clib_host_to_net_u32 (bd);
17745 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17750 /* wait for reply */
17756 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17758 vl_api_one_add_del_l2_arp_entry_t *mp;
17759 unformat_input_t *input = vam->input;
17764 u8 mac[6] = { 0, };
17765 u32 ip4 = 0, bd = ~0;
17768 /* Parse args required to build the message */
17769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17771 if (unformat (input, "del"))
17773 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17775 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17777 else if (unformat (input, "bd %d", &bd))
17781 errmsg ("parse error '%U'", format_unformat_error, input);
17786 if (!bd_set || !ip_set || (!mac_set && is_add))
17788 errmsg ("Missing BD, IP or MAC!");
17792 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17793 mp->is_add = is_add;
17794 clib_memcpy (mp->mac, mac, 6);
17795 mp->bd = clib_host_to_net_u32 (bd);
17801 /* wait for reply */
17807 api_one_ndp_bd_get (vat_main_t * vam)
17809 vl_api_one_ndp_bd_get_t *mp;
17812 M (ONE_NDP_BD_GET, mp);
17817 /* wait for reply */
17823 api_one_ndp_entries_get (vat_main_t * vam)
17825 vl_api_one_ndp_entries_get_t *mp;
17826 unformat_input_t *input = vam->input;
17831 /* Parse args required to build the message */
17832 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17834 if (unformat (input, "bd %d", &bd))
17838 errmsg ("parse error '%U'", format_unformat_error, input);
17845 errmsg ("Expected bridge domain!");
17849 M (ONE_NDP_ENTRIES_GET, mp);
17850 mp->bd = clib_host_to_net_u32 (bd);
17855 /* wait for reply */
17861 api_one_l2_arp_bd_get (vat_main_t * vam)
17863 vl_api_one_l2_arp_bd_get_t *mp;
17866 M (ONE_L2_ARP_BD_GET, mp);
17871 /* wait for reply */
17877 api_one_l2_arp_entries_get (vat_main_t * vam)
17879 vl_api_one_l2_arp_entries_get_t *mp;
17880 unformat_input_t *input = vam->input;
17885 /* Parse args required to build the message */
17886 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17888 if (unformat (input, "bd %d", &bd))
17892 errmsg ("parse error '%U'", format_unformat_error, input);
17899 errmsg ("Expected bridge domain!");
17903 M (ONE_L2_ARP_ENTRIES_GET, mp);
17904 mp->bd = clib_host_to_net_u32 (bd);
17909 /* wait for reply */
17915 api_one_stats_enable_disable (vat_main_t * vam)
17917 vl_api_one_stats_enable_disable_t *mp;
17918 unformat_input_t *input = vam->input;
17923 /* Parse args required to build the message */
17924 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17926 if (unformat (input, "enable"))
17931 else if (unformat (input, "disable"))
17941 errmsg ("Value not set");
17945 M (ONE_STATS_ENABLE_DISABLE, mp);
17951 /* wait for reply */
17957 api_show_one_stats_enable_disable (vat_main_t * vam)
17959 vl_api_show_one_stats_enable_disable_t *mp;
17962 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17967 /* wait for reply */
17973 api_show_one_map_request_mode (vat_main_t * vam)
17975 vl_api_show_one_map_request_mode_t *mp;
17978 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17983 /* wait for reply */
17988 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17991 api_one_map_request_mode (vat_main_t * vam)
17993 unformat_input_t *input = vam->input;
17994 vl_api_one_map_request_mode_t *mp;
17998 /* Parse args required to build the message */
17999 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18001 if (unformat (input, "dst-only"))
18003 else if (unformat (input, "src-dst"))
18007 errmsg ("parse error '%U'", format_unformat_error, input);
18012 M (ONE_MAP_REQUEST_MODE, mp);
18019 /* wait for reply */
18024 #define api_lisp_map_request_mode api_one_map_request_mode
18027 * Enable/disable ONE proxy ITR.
18029 * @param vam vpp API test context
18030 * @return return code
18033 api_one_pitr_set_locator_set (vat_main_t * vam)
18035 u8 ls_name_set = 0;
18036 unformat_input_t *input = vam->input;
18037 vl_api_one_pitr_set_locator_set_t *mp;
18042 /* Parse args required to build the message */
18043 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18045 if (unformat (input, "del"))
18047 else if (unformat (input, "locator-set %s", &ls_name))
18051 errmsg ("parse error '%U'", format_unformat_error, input);
18058 errmsg ("locator-set name not set!");
18062 M (ONE_PITR_SET_LOCATOR_SET, mp);
18064 mp->is_add = is_add;
18065 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
18066 vec_free (ls_name);
18071 /* wait for reply */
18076 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
18079 api_one_nsh_set_locator_set (vat_main_t * vam)
18081 u8 ls_name_set = 0;
18082 unformat_input_t *input = vam->input;
18083 vl_api_one_nsh_set_locator_set_t *mp;
18088 /* Parse args required to build the message */
18089 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18091 if (unformat (input, "del"))
18093 else if (unformat (input, "ls %s", &ls_name))
18097 errmsg ("parse error '%U'", format_unformat_error, input);
18102 if (!ls_name_set && is_add)
18104 errmsg ("locator-set name not set!");
18108 M (ONE_NSH_SET_LOCATOR_SET, mp);
18110 mp->is_add = is_add;
18111 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
18112 vec_free (ls_name);
18117 /* wait for reply */
18123 api_show_one_pitr (vat_main_t * vam)
18125 vl_api_show_one_pitr_t *mp;
18128 if (!vam->json_output)
18130 print (vam->ofp, "%=20s", "lisp status:");
18133 M (SHOW_ONE_PITR, mp);
18137 /* Wait for a reply... */
18142 #define api_show_lisp_pitr api_show_one_pitr
18145 api_one_use_petr (vat_main_t * vam)
18147 unformat_input_t *input = vam->input;
18148 vl_api_one_use_petr_t *mp;
18153 memset (&ip, 0, sizeof (ip));
18155 /* Parse args required to build the message */
18156 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18158 if (unformat (input, "disable"))
18161 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
18164 ip_addr_version (&ip) = IP4;
18167 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
18170 ip_addr_version (&ip) = IP6;
18174 errmsg ("parse error '%U'", format_unformat_error, input);
18179 M (ONE_USE_PETR, mp);
18181 mp->is_add = is_add;
18184 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
18186 clib_memcpy (mp->address, &ip, 4);
18188 clib_memcpy (mp->address, &ip, 16);
18194 /* wait for reply */
18199 #define api_lisp_use_petr api_one_use_petr
18202 api_show_one_nsh_mapping (vat_main_t * vam)
18204 vl_api_show_one_use_petr_t *mp;
18207 if (!vam->json_output)
18209 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
18212 M (SHOW_ONE_NSH_MAPPING, mp);
18216 /* Wait for a reply... */
18222 api_show_one_use_petr (vat_main_t * vam)
18224 vl_api_show_one_use_petr_t *mp;
18227 if (!vam->json_output)
18229 print (vam->ofp, "%=20s", "Proxy-ETR status:");
18232 M (SHOW_ONE_USE_PETR, mp);
18236 /* Wait for a reply... */
18241 #define api_show_lisp_use_petr api_show_one_use_petr
18244 * Add/delete mapping between vni and vrf
18247 api_one_eid_table_add_del_map (vat_main_t * vam)
18249 unformat_input_t *input = vam->input;
18250 vl_api_one_eid_table_add_del_map_t *mp;
18251 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
18252 u32 vni, vrf, bd_index;
18255 /* Parse args required to build the message */
18256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18258 if (unformat (input, "del"))
18260 else if (unformat (input, "vrf %d", &vrf))
18262 else if (unformat (input, "bd_index %d", &bd_index))
18264 else if (unformat (input, "vni %d", &vni))
18270 if (!vni_set || (!vrf_set && !bd_index_set))
18272 errmsg ("missing arguments!");
18276 if (vrf_set && bd_index_set)
18278 errmsg ("error: both vrf and bd entered!");
18282 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
18284 mp->is_add = is_add;
18285 mp->vni = htonl (vni);
18286 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
18287 mp->is_l2 = bd_index_set;
18292 /* wait for reply */
18297 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
18300 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
18302 u32 *action = va_arg (*args, u32 *);
18305 if (unformat (input, "%s", &s))
18307 if (!strcmp ((char *) s, "no-action"))
18309 else if (!strcmp ((char *) s, "natively-forward"))
18311 else if (!strcmp ((char *) s, "send-map-request"))
18313 else if (!strcmp ((char *) s, "drop"))
18317 clib_warning ("invalid action: '%s'", s);
18329 * Add/del remote mapping to/from ONE control plane
18331 * @param vam vpp API test context
18332 * @return return code
18335 api_one_add_del_remote_mapping (vat_main_t * vam)
18337 unformat_input_t *input = vam->input;
18338 vl_api_one_add_del_remote_mapping_t *mp;
18340 lisp_eid_vat_t _eid, *eid = &_eid;
18341 lisp_eid_vat_t _seid, *seid = &_seid;
18342 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
18343 u32 action = ~0, p, w, data_len;
18344 ip4_address_t rloc4;
18345 ip6_address_t rloc6;
18346 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
18349 memset (&rloc, 0, sizeof (rloc));
18351 /* Parse args required to build the message */
18352 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18354 if (unformat (input, "del-all"))
18358 else if (unformat (input, "del"))
18362 else if (unformat (input, "add"))
18366 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
18370 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
18374 else if (unformat (input, "vni %d", &vni))
18378 else if (unformat (input, "p %d w %d", &p, &w))
18382 errmsg ("No RLOC configured for setting priority/weight!");
18385 curr_rloc->priority = p;
18386 curr_rloc->weight = w;
18388 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
18391 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
18392 vec_add1 (rlocs, rloc);
18393 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18395 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
18398 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
18399 vec_add1 (rlocs, rloc);
18400 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18402 else if (unformat (input, "action %U",
18403 unformat_negative_mapping_action, &action))
18409 clib_warning ("parse error '%U'", format_unformat_error, input);
18416 errmsg ("missing params!");
18420 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
18422 errmsg ("no action set for negative map-reply!");
18426 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
18428 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
18429 mp->is_add = is_add;
18430 mp->vni = htonl (vni);
18431 mp->action = (u8) action;
18432 mp->is_src_dst = seid_set;
18433 mp->eid_len = eid->len;
18434 mp->seid_len = seid->len;
18435 mp->del_all = del_all;
18436 mp->eid_type = eid->type;
18437 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
18438 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
18440 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
18441 clib_memcpy (mp->rlocs, rlocs, data_len);
18447 /* Wait for a reply... */
18452 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
18455 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
18456 * forwarding entries in data-plane accordingly.
18458 * @param vam vpp API test context
18459 * @return return code
18462 api_one_add_del_adjacency (vat_main_t * vam)
18464 unformat_input_t *input = vam->input;
18465 vl_api_one_add_del_adjacency_t *mp;
18467 ip4_address_t leid4, reid4;
18468 ip6_address_t leid6, reid6;
18469 u8 reid_mac[6] = { 0 };
18470 u8 leid_mac[6] = { 0 };
18471 u8 reid_type, leid_type;
18472 u32 leid_len = 0, reid_len = 0, len;
18476 leid_type = reid_type = (u8) ~ 0;
18478 /* Parse args required to build the message */
18479 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18481 if (unformat (input, "del"))
18485 else if (unformat (input, "add"))
18489 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
18492 reid_type = 0; /* ipv4 */
18495 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
18498 reid_type = 1; /* ipv6 */
18501 else if (unformat (input, "reid %U", unformat_ethernet_address,
18504 reid_type = 2; /* mac */
18506 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
18509 leid_type = 0; /* ipv4 */
18512 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
18515 leid_type = 1; /* ipv6 */
18518 else if (unformat (input, "leid %U", unformat_ethernet_address,
18521 leid_type = 2; /* mac */
18523 else if (unformat (input, "vni %d", &vni))
18529 errmsg ("parse error '%U'", format_unformat_error, input);
18534 if ((u8) ~ 0 == reid_type)
18536 errmsg ("missing params!");
18540 if (leid_type != reid_type)
18542 errmsg ("remote and local EIDs are of different types!");
18546 M (ONE_ADD_DEL_ADJACENCY, mp);
18547 mp->is_add = is_add;
18548 mp->vni = htonl (vni);
18549 mp->leid_len = leid_len;
18550 mp->reid_len = reid_len;
18551 mp->eid_type = reid_type;
18553 switch (mp->eid_type)
18556 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18557 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18560 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18561 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18564 clib_memcpy (mp->leid, leid_mac, 6);
18565 clib_memcpy (mp->reid, reid_mac, 6);
18568 errmsg ("unknown EID type %d!", mp->eid_type);
18575 /* Wait for a reply... */
18580 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18583 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18585 u32 *mode = va_arg (*args, u32 *);
18587 if (unformat (input, "lisp"))
18589 else if (unformat (input, "vxlan"))
18598 api_gpe_get_encap_mode (vat_main_t * vam)
18600 vl_api_gpe_get_encap_mode_t *mp;
18603 /* Construct the API message */
18604 M (GPE_GET_ENCAP_MODE, mp);
18609 /* Wait for a reply... */
18615 api_gpe_set_encap_mode (vat_main_t * vam)
18617 unformat_input_t *input = vam->input;
18618 vl_api_gpe_set_encap_mode_t *mp;
18622 /* Parse args required to build the message */
18623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18625 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18631 /* Construct the API message */
18632 M (GPE_SET_ENCAP_MODE, mp);
18639 /* Wait for a reply... */
18645 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18647 unformat_input_t *input = vam->input;
18648 vl_api_gpe_add_del_iface_t *mp;
18649 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18650 u32 dp_table = 0, vni = 0;
18653 /* Parse args required to build the message */
18654 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18656 if (unformat (input, "up"))
18661 else if (unformat (input, "down"))
18666 else if (unformat (input, "table_id %d", &dp_table))
18670 else if (unformat (input, "bd_id %d", &dp_table))
18675 else if (unformat (input, "vni %d", &vni))
18683 if (action_set == 0)
18685 errmsg ("Action not set");
18688 if (dp_table_set == 0 || vni_set == 0)
18690 errmsg ("vni and dp_table must be set");
18694 /* Construct the API message */
18695 M (GPE_ADD_DEL_IFACE, mp);
18697 mp->is_add = is_add;
18698 mp->dp_table = clib_host_to_net_u32 (dp_table);
18700 mp->vni = clib_host_to_net_u32 (vni);
18705 /* Wait for a reply... */
18711 api_one_map_register_fallback_threshold (vat_main_t * vam)
18713 unformat_input_t *input = vam->input;
18714 vl_api_one_map_register_fallback_threshold_t *mp;
18719 /* Parse args required to build the message */
18720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18722 if (unformat (input, "%u", &value))
18726 clib_warning ("parse error '%U'", format_unformat_error, input);
18733 errmsg ("fallback threshold value is missing!");
18737 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18738 mp->value = clib_host_to_net_u32 (value);
18743 /* Wait for a reply... */
18749 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18751 vl_api_show_one_map_register_fallback_threshold_t *mp;
18754 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18759 /* Wait for a reply... */
18765 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18767 u32 *proto = va_arg (*args, u32 *);
18769 if (unformat (input, "udp"))
18771 else if (unformat (input, "api"))
18780 api_one_set_transport_protocol (vat_main_t * vam)
18782 unformat_input_t *input = vam->input;
18783 vl_api_one_set_transport_protocol_t *mp;
18788 /* Parse args required to build the message */
18789 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18791 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18795 clib_warning ("parse error '%U'", format_unformat_error, input);
18802 errmsg ("Transport protocol missing!");
18806 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18807 mp->protocol = (u8) protocol;
18812 /* Wait for a reply... */
18818 api_one_get_transport_protocol (vat_main_t * vam)
18820 vl_api_one_get_transport_protocol_t *mp;
18823 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18828 /* Wait for a reply... */
18834 api_one_map_register_set_ttl (vat_main_t * vam)
18836 unformat_input_t *input = vam->input;
18837 vl_api_one_map_register_set_ttl_t *mp;
18842 /* Parse args required to build the message */
18843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18845 if (unformat (input, "%u", &ttl))
18849 clib_warning ("parse error '%U'", format_unformat_error, input);
18856 errmsg ("TTL value missing!");
18860 M (ONE_MAP_REGISTER_SET_TTL, mp);
18861 mp->ttl = clib_host_to_net_u32 (ttl);
18866 /* Wait for a reply... */
18872 api_show_one_map_register_ttl (vat_main_t * vam)
18874 vl_api_show_one_map_register_ttl_t *mp;
18877 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18882 /* Wait for a reply... */
18888 * Add/del map request itr rlocs from ONE control plane and updates
18890 * @param vam vpp API test context
18891 * @return return code
18894 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18896 unformat_input_t *input = vam->input;
18897 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18898 u8 *locator_set_name = 0;
18899 u8 locator_set_name_set = 0;
18903 /* Parse args required to build the message */
18904 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18906 if (unformat (input, "del"))
18910 else if (unformat (input, "%_%v%_", &locator_set_name))
18912 locator_set_name_set = 1;
18916 clib_warning ("parse error '%U'", format_unformat_error, input);
18921 if (is_add && !locator_set_name_set)
18923 errmsg ("itr-rloc is not set!");
18927 if (is_add && vec_len (locator_set_name) > 64)
18929 errmsg ("itr-rloc locator-set name too long");
18930 vec_free (locator_set_name);
18934 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18935 mp->is_add = is_add;
18938 clib_memcpy (mp->locator_set_name, locator_set_name,
18939 vec_len (locator_set_name));
18943 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18945 vec_free (locator_set_name);
18950 /* Wait for a reply... */
18955 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18958 api_one_locator_dump (vat_main_t * vam)
18960 unformat_input_t *input = vam->input;
18961 vl_api_one_locator_dump_t *mp;
18962 vl_api_control_ping_t *mp_ping;
18963 u8 is_index_set = 0, is_name_set = 0;
18968 /* Parse args required to build the message */
18969 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18971 if (unformat (input, "ls_name %_%v%_", &ls_name))
18975 else if (unformat (input, "ls_index %d", &ls_index))
18981 errmsg ("parse error '%U'", format_unformat_error, input);
18986 if (!is_index_set && !is_name_set)
18988 errmsg ("error: expected one of index or name!");
18992 if (is_index_set && is_name_set)
18994 errmsg ("error: only one param expected!");
18998 if (vec_len (ls_name) > 62)
19000 errmsg ("error: locator set name too long!");
19004 if (!vam->json_output)
19006 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
19009 M (ONE_LOCATOR_DUMP, mp);
19010 mp->is_index_set = is_index_set;
19013 mp->ls_index = clib_host_to_net_u32 (ls_index);
19016 vec_add1 (ls_name, 0);
19017 strncpy ((char *) mp->ls_name, (char *) ls_name,
19018 sizeof (mp->ls_name) - 1);
19024 /* Use a control ping for synchronization */
19025 MPING (CONTROL_PING, mp_ping);
19028 /* Wait for a reply... */
19033 #define api_lisp_locator_dump api_one_locator_dump
19036 api_one_locator_set_dump (vat_main_t * vam)
19038 vl_api_one_locator_set_dump_t *mp;
19039 vl_api_control_ping_t *mp_ping;
19040 unformat_input_t *input = vam->input;
19044 /* Parse args required to build the message */
19045 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19047 if (unformat (input, "local"))
19051 else if (unformat (input, "remote"))
19057 errmsg ("parse error '%U'", format_unformat_error, input);
19062 if (!vam->json_output)
19064 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
19067 M (ONE_LOCATOR_SET_DUMP, mp);
19069 mp->filter = filter;
19074 /* Use a control ping for synchronization */
19075 MPING (CONTROL_PING, mp_ping);
19078 /* Wait for a reply... */
19083 #define api_lisp_locator_set_dump api_one_locator_set_dump
19086 api_one_eid_table_map_dump (vat_main_t * vam)
19090 unformat_input_t *input = vam->input;
19091 vl_api_one_eid_table_map_dump_t *mp;
19092 vl_api_control_ping_t *mp_ping;
19095 /* Parse args required to build the message */
19096 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19098 if (unformat (input, "l2"))
19103 else if (unformat (input, "l3"))
19110 errmsg ("parse error '%U'", format_unformat_error, input);
19117 errmsg ("expected one of 'l2' or 'l3' parameter!");
19121 if (!vam->json_output)
19123 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
19126 M (ONE_EID_TABLE_MAP_DUMP, mp);
19132 /* Use a control ping for synchronization */
19133 MPING (CONTROL_PING, mp_ping);
19136 /* Wait for a reply... */
19141 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
19144 api_one_eid_table_vni_dump (vat_main_t * vam)
19146 vl_api_one_eid_table_vni_dump_t *mp;
19147 vl_api_control_ping_t *mp_ping;
19150 if (!vam->json_output)
19152 print (vam->ofp, "VNI");
19155 M (ONE_EID_TABLE_VNI_DUMP, mp);
19160 /* Use a control ping for synchronization */
19161 MPING (CONTROL_PING, mp_ping);
19164 /* Wait for a reply... */
19169 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
19172 api_one_eid_table_dump (vat_main_t * vam)
19174 unformat_input_t *i = vam->input;
19175 vl_api_one_eid_table_dump_t *mp;
19176 vl_api_control_ping_t *mp_ping;
19177 struct in_addr ip4;
19178 struct in6_addr ip6;
19180 u8 eid_type = ~0, eid_set = 0;
19181 u32 prefix_length = ~0, t, vni = 0;
19184 lisp_nsh_api_t nsh;
19186 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19188 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
19194 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
19200 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
19205 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
19210 else if (unformat (i, "vni %d", &t))
19214 else if (unformat (i, "local"))
19218 else if (unformat (i, "remote"))
19224 errmsg ("parse error '%U'", format_unformat_error, i);
19229 if (!vam->json_output)
19231 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
19232 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
19235 M (ONE_EID_TABLE_DUMP, mp);
19237 mp->filter = filter;
19241 mp->vni = htonl (vni);
19242 mp->eid_type = eid_type;
19246 mp->prefix_length = prefix_length;
19247 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
19250 mp->prefix_length = prefix_length;
19251 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
19254 clib_memcpy (mp->eid, mac, sizeof (mac));
19257 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
19260 errmsg ("unknown EID type %d!", eid_type);
19268 /* Use a control ping for synchronization */
19269 MPING (CONTROL_PING, mp_ping);
19272 /* Wait for a reply... */
19277 #define api_lisp_eid_table_dump api_one_eid_table_dump
19280 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
19282 unformat_input_t *i = vam->input;
19283 vl_api_gpe_fwd_entries_get_t *mp;
19288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19290 if (unformat (i, "vni %d", &vni))
19296 errmsg ("parse error '%U'", format_unformat_error, i);
19303 errmsg ("vni not set!");
19307 if (!vam->json_output)
19309 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
19313 M (GPE_FWD_ENTRIES_GET, mp);
19314 mp->vni = clib_host_to_net_u32 (vni);
19319 /* Wait for a reply... */
19324 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
19325 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
19326 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
19327 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
19328 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
19329 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
19330 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
19331 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
19334 api_one_adjacencies_get (vat_main_t * vam)
19336 unformat_input_t *i = vam->input;
19337 vl_api_one_adjacencies_get_t *mp;
19342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19344 if (unformat (i, "vni %d", &vni))
19350 errmsg ("parse error '%U'", format_unformat_error, i);
19357 errmsg ("vni not set!");
19361 if (!vam->json_output)
19363 print (vam->ofp, "%s %40s", "leid", "reid");
19366 M (ONE_ADJACENCIES_GET, mp);
19367 mp->vni = clib_host_to_net_u32 (vni);
19372 /* Wait for a reply... */
19377 #define api_lisp_adjacencies_get api_one_adjacencies_get
19380 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
19382 unformat_input_t *i = vam->input;
19383 vl_api_gpe_native_fwd_rpaths_get_t *mp;
19385 u8 ip_family_set = 0, is_ip4 = 1;
19387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19389 if (unformat (i, "ip4"))
19394 else if (unformat (i, "ip6"))
19401 errmsg ("parse error '%U'", format_unformat_error, i);
19406 if (!ip_family_set)
19408 errmsg ("ip family not set!");
19412 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
19413 mp->is_ip4 = is_ip4;
19418 /* Wait for a reply... */
19424 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
19426 vl_api_gpe_fwd_entry_vnis_get_t *mp;
19429 if (!vam->json_output)
19431 print (vam->ofp, "VNIs");
19434 M (GPE_FWD_ENTRY_VNIS_GET, mp);
19439 /* Wait for a reply... */
19445 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
19447 unformat_input_t *i = vam->input;
19448 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
19450 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
19451 struct in_addr ip4;
19452 struct in6_addr ip6;
19453 u32 table_id = 0, nh_sw_if_index = ~0;
19455 memset (&ip4, 0, sizeof (ip4));
19456 memset (&ip6, 0, sizeof (ip6));
19458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19460 if (unformat (i, "del"))
19462 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
19463 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19468 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
19469 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19474 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
19478 nh_sw_if_index = ~0;
19480 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
19484 nh_sw_if_index = ~0;
19486 else if (unformat (i, "table %d", &table_id))
19490 errmsg ("parse error '%U'", format_unformat_error, i);
19497 errmsg ("nh addr not set!");
19501 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
19502 mp->is_add = is_add;
19503 mp->table_id = clib_host_to_net_u32 (table_id);
19504 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
19505 mp->is_ip4 = is_ip4;
19507 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
19509 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
19514 /* Wait for a reply... */
19520 api_one_map_server_dump (vat_main_t * vam)
19522 vl_api_one_map_server_dump_t *mp;
19523 vl_api_control_ping_t *mp_ping;
19526 if (!vam->json_output)
19528 print (vam->ofp, "%=20s", "Map server");
19531 M (ONE_MAP_SERVER_DUMP, mp);
19535 /* Use a control ping for synchronization */
19536 MPING (CONTROL_PING, mp_ping);
19539 /* Wait for a reply... */
19544 #define api_lisp_map_server_dump api_one_map_server_dump
19547 api_one_map_resolver_dump (vat_main_t * vam)
19549 vl_api_one_map_resolver_dump_t *mp;
19550 vl_api_control_ping_t *mp_ping;
19553 if (!vam->json_output)
19555 print (vam->ofp, "%=20s", "Map resolver");
19558 M (ONE_MAP_RESOLVER_DUMP, mp);
19562 /* Use a control ping for synchronization */
19563 MPING (CONTROL_PING, mp_ping);
19566 /* Wait for a reply... */
19571 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19574 api_one_stats_flush (vat_main_t * vam)
19576 vl_api_one_stats_flush_t *mp;
19579 M (ONE_STATS_FLUSH, mp);
19586 api_one_stats_dump (vat_main_t * vam)
19588 vl_api_one_stats_dump_t *mp;
19589 vl_api_control_ping_t *mp_ping;
19592 M (ONE_STATS_DUMP, mp);
19596 /* Use a control ping for synchronization */
19597 MPING (CONTROL_PING, mp_ping);
19600 /* Wait for a reply... */
19606 api_show_one_status (vat_main_t * vam)
19608 vl_api_show_one_status_t *mp;
19611 if (!vam->json_output)
19613 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19616 M (SHOW_ONE_STATUS, mp);
19619 /* Wait for a reply... */
19624 #define api_show_lisp_status api_show_one_status
19627 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19629 vl_api_gpe_fwd_entry_path_dump_t *mp;
19630 vl_api_control_ping_t *mp_ping;
19631 unformat_input_t *i = vam->input;
19632 u32 fwd_entry_index = ~0;
19635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19637 if (unformat (i, "index %d", &fwd_entry_index))
19643 if (~0 == fwd_entry_index)
19645 errmsg ("no index specified!");
19649 if (!vam->json_output)
19651 print (vam->ofp, "first line");
19654 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19658 /* Use a control ping for synchronization */
19659 MPING (CONTROL_PING, mp_ping);
19662 /* Wait for a reply... */
19668 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19670 vl_api_one_get_map_request_itr_rlocs_t *mp;
19673 if (!vam->json_output)
19675 print (vam->ofp, "%=20s", "itr-rlocs:");
19678 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19681 /* Wait for a reply... */
19686 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19689 api_af_packet_create (vat_main_t * vam)
19691 unformat_input_t *i = vam->input;
19692 vl_api_af_packet_create_t *mp;
19693 u8 *host_if_name = 0;
19695 u8 random_hw_addr = 1;
19698 memset (hw_addr, 0, sizeof (hw_addr));
19700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19702 if (unformat (i, "name %s", &host_if_name))
19703 vec_add1 (host_if_name, 0);
19704 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19705 random_hw_addr = 0;
19710 if (!vec_len (host_if_name))
19712 errmsg ("host-interface name must be specified");
19716 if (vec_len (host_if_name) > 64)
19718 errmsg ("host-interface name too long");
19722 M (AF_PACKET_CREATE, mp);
19724 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19725 clib_memcpy (mp->hw_addr, hw_addr, 6);
19726 mp->use_random_hw_addr = random_hw_addr;
19727 vec_free (host_if_name);
19735 fprintf (vam->ofp ? vam->ofp : stderr,
19736 " new sw_if_index = %d\n", vam->sw_if_index);
19743 api_af_packet_delete (vat_main_t * vam)
19745 unformat_input_t *i = vam->input;
19746 vl_api_af_packet_delete_t *mp;
19747 u8 *host_if_name = 0;
19750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19752 if (unformat (i, "name %s", &host_if_name))
19753 vec_add1 (host_if_name, 0);
19758 if (!vec_len (host_if_name))
19760 errmsg ("host-interface name must be specified");
19764 if (vec_len (host_if_name) > 64)
19766 errmsg ("host-interface name too long");
19770 M (AF_PACKET_DELETE, mp);
19772 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19773 vec_free (host_if_name);
19781 api_policer_add_del (vat_main_t * vam)
19783 unformat_input_t *i = vam->input;
19784 vl_api_policer_add_del_t *mp;
19794 u8 color_aware = 0;
19795 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19798 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19799 conform_action.dscp = 0;
19800 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19801 exceed_action.dscp = 0;
19802 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19803 violate_action.dscp = 0;
19805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19807 if (unformat (i, "del"))
19809 else if (unformat (i, "name %s", &name))
19810 vec_add1 (name, 0);
19811 else if (unformat (i, "cir %u", &cir))
19813 else if (unformat (i, "eir %u", &eir))
19815 else if (unformat (i, "cb %u", &cb))
19817 else if (unformat (i, "eb %u", &eb))
19819 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19822 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19825 else if (unformat (i, "type %U", unformat_policer_type, &type))
19827 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19830 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19833 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19836 else if (unformat (i, "color-aware"))
19842 if (!vec_len (name))
19844 errmsg ("policer name must be specified");
19848 if (vec_len (name) > 64)
19850 errmsg ("policer name too long");
19854 M (POLICER_ADD_DEL, mp);
19856 clib_memcpy (mp->name, name, vec_len (name));
19858 mp->is_add = is_add;
19859 mp->cir = ntohl (cir);
19860 mp->eir = ntohl (eir);
19861 mp->cb = clib_net_to_host_u64 (cb);
19862 mp->eb = clib_net_to_host_u64 (eb);
19863 mp->rate_type = rate_type;
19864 mp->round_type = round_type;
19866 mp->conform_action_type = conform_action.action_type;
19867 mp->conform_dscp = conform_action.dscp;
19868 mp->exceed_action_type = exceed_action.action_type;
19869 mp->exceed_dscp = exceed_action.dscp;
19870 mp->violate_action_type = violate_action.action_type;
19871 mp->violate_dscp = violate_action.dscp;
19872 mp->color_aware = color_aware;
19880 api_policer_dump (vat_main_t * vam)
19882 unformat_input_t *i = vam->input;
19883 vl_api_policer_dump_t *mp;
19884 vl_api_control_ping_t *mp_ping;
19885 u8 *match_name = 0;
19886 u8 match_name_valid = 0;
19889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19891 if (unformat (i, "name %s", &match_name))
19893 vec_add1 (match_name, 0);
19894 match_name_valid = 1;
19900 M (POLICER_DUMP, mp);
19901 mp->match_name_valid = match_name_valid;
19902 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19903 vec_free (match_name);
19907 /* Use a control ping for synchronization */
19908 MPING (CONTROL_PING, mp_ping);
19911 /* Wait for a reply... */
19917 api_policer_classify_set_interface (vat_main_t * vam)
19919 unformat_input_t *i = vam->input;
19920 vl_api_policer_classify_set_interface_t *mp;
19922 int sw_if_index_set;
19923 u32 ip4_table_index = ~0;
19924 u32 ip6_table_index = ~0;
19925 u32 l2_table_index = ~0;
19929 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19931 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19932 sw_if_index_set = 1;
19933 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19934 sw_if_index_set = 1;
19935 else if (unformat (i, "del"))
19937 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19939 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19941 else if (unformat (i, "l2-table %d", &l2_table_index))
19945 clib_warning ("parse error '%U'", format_unformat_error, i);
19950 if (sw_if_index_set == 0)
19952 errmsg ("missing interface name or sw_if_index");
19956 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19958 mp->sw_if_index = ntohl (sw_if_index);
19959 mp->ip4_table_index = ntohl (ip4_table_index);
19960 mp->ip6_table_index = ntohl (ip6_table_index);
19961 mp->l2_table_index = ntohl (l2_table_index);
19962 mp->is_add = is_add;
19970 api_policer_classify_dump (vat_main_t * vam)
19972 unformat_input_t *i = vam->input;
19973 vl_api_policer_classify_dump_t *mp;
19974 vl_api_control_ping_t *mp_ping;
19975 u8 type = POLICER_CLASSIFY_N_TABLES;
19978 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19982 errmsg ("classify table type must be specified");
19986 if (!vam->json_output)
19988 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19991 M (POLICER_CLASSIFY_DUMP, mp);
19996 /* Use a control ping for synchronization */
19997 MPING (CONTROL_PING, mp_ping);
20000 /* Wait for a reply... */
20006 api_netmap_create (vat_main_t * vam)
20008 unformat_input_t *i = vam->input;
20009 vl_api_netmap_create_t *mp;
20012 u8 random_hw_addr = 1;
20017 memset (hw_addr, 0, sizeof (hw_addr));
20019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20021 if (unformat (i, "name %s", &if_name))
20022 vec_add1 (if_name, 0);
20023 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
20024 random_hw_addr = 0;
20025 else if (unformat (i, "pipe"))
20027 else if (unformat (i, "master"))
20029 else if (unformat (i, "slave"))
20035 if (!vec_len (if_name))
20037 errmsg ("interface name must be specified");
20041 if (vec_len (if_name) > 64)
20043 errmsg ("interface name too long");
20047 M (NETMAP_CREATE, mp);
20049 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
20050 clib_memcpy (mp->hw_addr, hw_addr, 6);
20051 mp->use_random_hw_addr = random_hw_addr;
20052 mp->is_pipe = is_pipe;
20053 mp->is_master = is_master;
20054 vec_free (if_name);
20062 api_netmap_delete (vat_main_t * vam)
20064 unformat_input_t *i = vam->input;
20065 vl_api_netmap_delete_t *mp;
20069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20071 if (unformat (i, "name %s", &if_name))
20072 vec_add1 (if_name, 0);
20077 if (!vec_len (if_name))
20079 errmsg ("interface name must be specified");
20083 if (vec_len (if_name) > 64)
20085 errmsg ("interface name too long");
20089 M (NETMAP_DELETE, mp);
20091 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
20092 vec_free (if_name);
20100 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
20102 if (fp->afi == IP46_TYPE_IP6)
20104 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20105 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20106 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20107 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20108 format_ip6_address, fp->next_hop);
20109 else if (fp->afi == IP46_TYPE_IP4)
20111 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20112 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20113 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20114 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20115 format_ip4_address, fp->next_hop);
20119 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
20120 vl_api_fib_path_t * fp)
20122 struct in_addr ip4;
20123 struct in6_addr ip6;
20125 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20126 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20127 vat_json_object_add_uint (node, "is_local", fp->is_local);
20128 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20129 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20130 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20131 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20132 if (fp->afi == IP46_TYPE_IP4)
20134 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20135 vat_json_object_add_ip4 (node, "next_hop", ip4);
20137 else if (fp->afi == IP46_TYPE_IP6)
20139 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20140 vat_json_object_add_ip6 (node, "next_hop", ip6);
20145 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
20147 vat_main_t *vam = &vat_main;
20148 int count = ntohl (mp->mt_count);
20149 vl_api_fib_path_t *fp;
20152 print (vam->ofp, "[%d]: sw_if_index %d via:",
20153 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
20155 for (i = 0; i < count; i++)
20157 vl_api_mpls_fib_path_print (vam, fp);
20161 print (vam->ofp, "");
20164 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
20165 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
20168 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
20170 vat_main_t *vam = &vat_main;
20171 vat_json_node_t *node = NULL;
20172 int count = ntohl (mp->mt_count);
20173 vl_api_fib_path_t *fp;
20176 if (VAT_JSON_ARRAY != vam->json_tree.type)
20178 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20179 vat_json_init_array (&vam->json_tree);
20181 node = vat_json_array_add (&vam->json_tree);
20183 vat_json_init_object (node);
20184 vat_json_object_add_uint (node, "tunnel_index",
20185 ntohl (mp->mt_tunnel_index));
20186 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
20188 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
20191 for (i = 0; i < count; i++)
20193 vl_api_mpls_fib_path_json_print (node, fp);
20199 api_mpls_tunnel_dump (vat_main_t * vam)
20201 vl_api_mpls_tunnel_dump_t *mp;
20202 vl_api_control_ping_t *mp_ping;
20206 /* Parse args required to build the message */
20207 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
20209 if (!unformat (vam->input, "tunnel_index %d", &index))
20216 print (vam->ofp, " tunnel_index %d", index);
20218 M (MPLS_TUNNEL_DUMP, mp);
20219 mp->tunnel_index = htonl (index);
20222 /* Use a control ping for synchronization */
20223 MPING (CONTROL_PING, mp_ping);
20230 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
20231 #define vl_api_mpls_fib_details_t_print vl_noop_handler
20235 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
20237 vat_main_t *vam = &vat_main;
20238 int count = ntohl (mp->count);
20239 vl_api_fib_path_t *fp;
20243 "table-id %d, label %u, ess_bit %u",
20244 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
20246 for (i = 0; i < count; i++)
20248 vl_api_mpls_fib_path_print (vam, fp);
20253 static void vl_api_mpls_fib_details_t_handler_json
20254 (vl_api_mpls_fib_details_t * mp)
20256 vat_main_t *vam = &vat_main;
20257 int count = ntohl (mp->count);
20258 vat_json_node_t *node = NULL;
20259 vl_api_fib_path_t *fp;
20262 if (VAT_JSON_ARRAY != vam->json_tree.type)
20264 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20265 vat_json_init_array (&vam->json_tree);
20267 node = vat_json_array_add (&vam->json_tree);
20269 vat_json_init_object (node);
20270 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20271 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
20272 vat_json_object_add_uint (node, "label", ntohl (mp->label));
20273 vat_json_object_add_uint (node, "path_count", count);
20275 for (i = 0; i < count; i++)
20277 vl_api_mpls_fib_path_json_print (node, fp);
20283 api_mpls_fib_dump (vat_main_t * vam)
20285 vl_api_mpls_fib_dump_t *mp;
20286 vl_api_control_ping_t *mp_ping;
20289 M (MPLS_FIB_DUMP, mp);
20292 /* Use a control ping for synchronization */
20293 MPING (CONTROL_PING, mp_ping);
20300 #define vl_api_ip_fib_details_t_endian vl_noop_handler
20301 #define vl_api_ip_fib_details_t_print vl_noop_handler
20304 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
20306 vat_main_t *vam = &vat_main;
20307 int count = ntohl (mp->count);
20308 vl_api_fib_path_t *fp;
20312 "table-id %d, prefix %U/%d",
20313 ntohl (mp->table_id), format_ip4_address, mp->address,
20314 mp->address_length);
20316 for (i = 0; i < count; i++)
20318 if (fp->afi == IP46_TYPE_IP6)
20320 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20321 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20322 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20323 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20324 format_ip6_address, fp->next_hop);
20325 else if (fp->afi == IP46_TYPE_IP4)
20327 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20328 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20329 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20330 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20331 format_ip4_address, fp->next_hop);
20336 static void vl_api_ip_fib_details_t_handler_json
20337 (vl_api_ip_fib_details_t * mp)
20339 vat_main_t *vam = &vat_main;
20340 int count = ntohl (mp->count);
20341 vat_json_node_t *node = NULL;
20342 struct in_addr ip4;
20343 struct in6_addr ip6;
20344 vl_api_fib_path_t *fp;
20347 if (VAT_JSON_ARRAY != vam->json_tree.type)
20349 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20350 vat_json_init_array (&vam->json_tree);
20352 node = vat_json_array_add (&vam->json_tree);
20354 vat_json_init_object (node);
20355 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20356 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
20357 vat_json_object_add_ip4 (node, "prefix", ip4);
20358 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20359 vat_json_object_add_uint (node, "path_count", count);
20361 for (i = 0; i < count; i++)
20363 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20364 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20365 vat_json_object_add_uint (node, "is_local", fp->is_local);
20366 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20367 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20368 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20369 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20370 if (fp->afi == IP46_TYPE_IP4)
20372 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20373 vat_json_object_add_ip4 (node, "next_hop", ip4);
20375 else if (fp->afi == IP46_TYPE_IP6)
20377 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20378 vat_json_object_add_ip6 (node, "next_hop", ip6);
20384 api_ip_fib_dump (vat_main_t * vam)
20386 vl_api_ip_fib_dump_t *mp;
20387 vl_api_control_ping_t *mp_ping;
20390 M (IP_FIB_DUMP, mp);
20393 /* Use a control ping for synchronization */
20394 MPING (CONTROL_PING, mp_ping);
20402 api_ip_mfib_dump (vat_main_t * vam)
20404 vl_api_ip_mfib_dump_t *mp;
20405 vl_api_control_ping_t *mp_ping;
20408 M (IP_MFIB_DUMP, mp);
20411 /* Use a control ping for synchronization */
20412 MPING (CONTROL_PING, mp_ping);
20419 static void vl_api_ip_neighbor_details_t_handler
20420 (vl_api_ip_neighbor_details_t * mp)
20422 vat_main_t *vam = &vat_main;
20424 print (vam->ofp, "%c %U %U",
20425 (mp->is_static) ? 'S' : 'D',
20426 format_ethernet_address, &mp->mac_address,
20427 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
20431 static void vl_api_ip_neighbor_details_t_handler_json
20432 (vl_api_ip_neighbor_details_t * mp)
20435 vat_main_t *vam = &vat_main;
20436 vat_json_node_t *node;
20437 struct in_addr ip4;
20438 struct in6_addr ip6;
20440 if (VAT_JSON_ARRAY != vam->json_tree.type)
20442 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20443 vat_json_init_array (&vam->json_tree);
20445 node = vat_json_array_add (&vam->json_tree);
20447 vat_json_init_object (node);
20448 vat_json_object_add_string_copy (node, "flag",
20449 (mp->is_static) ? (u8 *) "static" : (u8 *)
20452 vat_json_object_add_string_copy (node, "link_layer",
20453 format (0, "%U", format_ethernet_address,
20454 &mp->mac_address));
20458 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
20459 vat_json_object_add_ip6 (node, "ip_address", ip6);
20463 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
20464 vat_json_object_add_ip4 (node, "ip_address", ip4);
20469 api_ip_neighbor_dump (vat_main_t * vam)
20471 unformat_input_t *i = vam->input;
20472 vl_api_ip_neighbor_dump_t *mp;
20473 vl_api_control_ping_t *mp_ping;
20475 u32 sw_if_index = ~0;
20478 /* Parse args required to build the message */
20479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20481 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20483 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20485 else if (unformat (i, "ip6"))
20491 if (sw_if_index == ~0)
20493 errmsg ("missing interface name or sw_if_index");
20497 M (IP_NEIGHBOR_DUMP, mp);
20498 mp->is_ipv6 = (u8) is_ipv6;
20499 mp->sw_if_index = ntohl (sw_if_index);
20502 /* Use a control ping for synchronization */
20503 MPING (CONTROL_PING, mp_ping);
20510 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
20511 #define vl_api_ip6_fib_details_t_print vl_noop_handler
20514 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
20516 vat_main_t *vam = &vat_main;
20517 int count = ntohl (mp->count);
20518 vl_api_fib_path_t *fp;
20522 "table-id %d, prefix %U/%d",
20523 ntohl (mp->table_id), format_ip6_address, mp->address,
20524 mp->address_length);
20526 for (i = 0; i < count; i++)
20528 if (fp->afi == IP46_TYPE_IP6)
20530 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20531 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20532 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20533 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20534 format_ip6_address, fp->next_hop);
20535 else if (fp->afi == IP46_TYPE_IP4)
20537 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20538 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20539 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20540 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20541 format_ip4_address, fp->next_hop);
20546 static void vl_api_ip6_fib_details_t_handler_json
20547 (vl_api_ip6_fib_details_t * mp)
20549 vat_main_t *vam = &vat_main;
20550 int count = ntohl (mp->count);
20551 vat_json_node_t *node = NULL;
20552 struct in_addr ip4;
20553 struct in6_addr ip6;
20554 vl_api_fib_path_t *fp;
20557 if (VAT_JSON_ARRAY != vam->json_tree.type)
20559 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20560 vat_json_init_array (&vam->json_tree);
20562 node = vat_json_array_add (&vam->json_tree);
20564 vat_json_init_object (node);
20565 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20566 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20567 vat_json_object_add_ip6 (node, "prefix", ip6);
20568 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20569 vat_json_object_add_uint (node, "path_count", count);
20571 for (i = 0; i < count; i++)
20573 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20574 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20575 vat_json_object_add_uint (node, "is_local", fp->is_local);
20576 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20577 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20578 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20579 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20580 if (fp->afi == IP46_TYPE_IP4)
20582 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20583 vat_json_object_add_ip4 (node, "next_hop", ip4);
20585 else if (fp->afi == IP46_TYPE_IP6)
20587 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20588 vat_json_object_add_ip6 (node, "next_hop", ip6);
20594 api_ip6_fib_dump (vat_main_t * vam)
20596 vl_api_ip6_fib_dump_t *mp;
20597 vl_api_control_ping_t *mp_ping;
20600 M (IP6_FIB_DUMP, mp);
20603 /* Use a control ping for synchronization */
20604 MPING (CONTROL_PING, mp_ping);
20612 api_ip6_mfib_dump (vat_main_t * vam)
20614 vl_api_ip6_mfib_dump_t *mp;
20615 vl_api_control_ping_t *mp_ping;
20618 M (IP6_MFIB_DUMP, mp);
20621 /* Use a control ping for synchronization */
20622 MPING (CONTROL_PING, mp_ping);
20630 api_classify_table_ids (vat_main_t * vam)
20632 vl_api_classify_table_ids_t *mp;
20635 /* Construct the API message */
20636 M (CLASSIFY_TABLE_IDS, mp);
20645 api_classify_table_by_interface (vat_main_t * vam)
20647 unformat_input_t *input = vam->input;
20648 vl_api_classify_table_by_interface_t *mp;
20650 u32 sw_if_index = ~0;
20652 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20654 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20656 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20661 if (sw_if_index == ~0)
20663 errmsg ("missing interface name or sw_if_index");
20667 /* Construct the API message */
20668 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20670 mp->sw_if_index = ntohl (sw_if_index);
20678 api_classify_table_info (vat_main_t * vam)
20680 unformat_input_t *input = vam->input;
20681 vl_api_classify_table_info_t *mp;
20685 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20687 if (unformat (input, "table_id %d", &table_id))
20692 if (table_id == ~0)
20694 errmsg ("missing table id");
20698 /* Construct the API message */
20699 M (CLASSIFY_TABLE_INFO, mp);
20701 mp->table_id = ntohl (table_id);
20709 api_classify_session_dump (vat_main_t * vam)
20711 unformat_input_t *input = vam->input;
20712 vl_api_classify_session_dump_t *mp;
20713 vl_api_control_ping_t *mp_ping;
20717 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20719 if (unformat (input, "table_id %d", &table_id))
20724 if (table_id == ~0)
20726 errmsg ("missing table id");
20730 /* Construct the API message */
20731 M (CLASSIFY_SESSION_DUMP, mp);
20733 mp->table_id = ntohl (table_id);
20736 /* Use a control ping for synchronization */
20737 MPING (CONTROL_PING, mp_ping);
20745 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20747 vat_main_t *vam = &vat_main;
20749 print (vam->ofp, "collector_address %U, collector_port %d, "
20750 "src_address %U, vrf_id %d, path_mtu %u, "
20751 "template_interval %u, udp_checksum %d",
20752 format_ip4_address, mp->collector_address,
20753 ntohs (mp->collector_port),
20754 format_ip4_address, mp->src_address,
20755 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20756 ntohl (mp->template_interval), mp->udp_checksum);
20759 vam->result_ready = 1;
20763 vl_api_ipfix_exporter_details_t_handler_json
20764 (vl_api_ipfix_exporter_details_t * mp)
20766 vat_main_t *vam = &vat_main;
20767 vat_json_node_t node;
20768 struct in_addr collector_address;
20769 struct in_addr src_address;
20771 vat_json_init_object (&node);
20772 clib_memcpy (&collector_address, &mp->collector_address,
20773 sizeof (collector_address));
20774 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20775 vat_json_object_add_uint (&node, "collector_port",
20776 ntohs (mp->collector_port));
20777 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20778 vat_json_object_add_ip4 (&node, "src_address", src_address);
20779 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20780 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20781 vat_json_object_add_uint (&node, "template_interval",
20782 ntohl (mp->template_interval));
20783 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20785 vat_json_print (vam->ofp, &node);
20786 vat_json_free (&node);
20788 vam->result_ready = 1;
20792 api_ipfix_exporter_dump (vat_main_t * vam)
20794 vl_api_ipfix_exporter_dump_t *mp;
20797 /* Construct the API message */
20798 M (IPFIX_EXPORTER_DUMP, mp);
20807 api_ipfix_classify_stream_dump (vat_main_t * vam)
20809 vl_api_ipfix_classify_stream_dump_t *mp;
20812 /* Construct the API message */
20813 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20824 vl_api_ipfix_classify_stream_details_t_handler
20825 (vl_api_ipfix_classify_stream_details_t * mp)
20827 vat_main_t *vam = &vat_main;
20828 print (vam->ofp, "domain_id %d, src_port %d",
20829 ntohl (mp->domain_id), ntohs (mp->src_port));
20831 vam->result_ready = 1;
20835 vl_api_ipfix_classify_stream_details_t_handler_json
20836 (vl_api_ipfix_classify_stream_details_t * mp)
20838 vat_main_t *vam = &vat_main;
20839 vat_json_node_t node;
20841 vat_json_init_object (&node);
20842 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20843 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20845 vat_json_print (vam->ofp, &node);
20846 vat_json_free (&node);
20848 vam->result_ready = 1;
20852 api_ipfix_classify_table_dump (vat_main_t * vam)
20854 vl_api_ipfix_classify_table_dump_t *mp;
20855 vl_api_control_ping_t *mp_ping;
20858 if (!vam->json_output)
20860 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20861 "transport_protocol");
20864 /* Construct the API message */
20865 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20870 /* Use a control ping for synchronization */
20871 MPING (CONTROL_PING, mp_ping);
20879 vl_api_ipfix_classify_table_details_t_handler
20880 (vl_api_ipfix_classify_table_details_t * mp)
20882 vat_main_t *vam = &vat_main;
20883 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20884 mp->transport_protocol);
20888 vl_api_ipfix_classify_table_details_t_handler_json
20889 (vl_api_ipfix_classify_table_details_t * mp)
20891 vat_json_node_t *node = NULL;
20892 vat_main_t *vam = &vat_main;
20894 if (VAT_JSON_ARRAY != vam->json_tree.type)
20896 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20897 vat_json_init_array (&vam->json_tree);
20900 node = vat_json_array_add (&vam->json_tree);
20901 vat_json_init_object (node);
20903 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20904 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20905 vat_json_object_add_uint (node, "transport_protocol",
20906 mp->transport_protocol);
20910 api_sw_interface_span_enable_disable (vat_main_t * vam)
20912 unformat_input_t *i = vam->input;
20913 vl_api_sw_interface_span_enable_disable_t *mp;
20914 u32 src_sw_if_index = ~0;
20915 u32 dst_sw_if_index = ~0;
20920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20923 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20925 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20929 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20931 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20933 else if (unformat (i, "disable"))
20935 else if (unformat (i, "rx"))
20937 else if (unformat (i, "tx"))
20939 else if (unformat (i, "both"))
20941 else if (unformat (i, "l2"))
20947 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20949 mp->sw_if_index_from = htonl (src_sw_if_index);
20950 mp->sw_if_index_to = htonl (dst_sw_if_index);
20960 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20963 vat_main_t *vam = &vat_main;
20964 u8 *sw_if_from_name = 0;
20965 u8 *sw_if_to_name = 0;
20966 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20967 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20968 char *states[] = { "none", "rx", "tx", "both" };
20972 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20974 if ((u32) p->value[0] == sw_if_index_from)
20976 sw_if_from_name = (u8 *)(p->key);
20980 if ((u32) p->value[0] == sw_if_index_to)
20982 sw_if_to_name = (u8 *)(p->key);
20983 if (sw_if_from_name)
20988 print (vam->ofp, "%20s => %20s (%s) %s",
20989 sw_if_from_name, sw_if_to_name, states[mp->state],
20990 mp->is_l2 ? "l2" : "device");
20994 vl_api_sw_interface_span_details_t_handler_json
20995 (vl_api_sw_interface_span_details_t * mp)
20997 vat_main_t *vam = &vat_main;
20998 vat_json_node_t *node = NULL;
20999 u8 *sw_if_from_name = 0;
21000 u8 *sw_if_to_name = 0;
21001 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
21002 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
21006 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
21008 if ((u32) p->value[0] == sw_if_index_from)
21010 sw_if_from_name = (u8 *)(p->key);
21014 if ((u32) p->value[0] == sw_if_index_to)
21016 sw_if_to_name = (u8 *)(p->key);
21017 if (sw_if_from_name)
21023 if (VAT_JSON_ARRAY != vam->json_tree.type)
21025 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21026 vat_json_init_array (&vam->json_tree);
21028 node = vat_json_array_add (&vam->json_tree);
21030 vat_json_init_object (node);
21031 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
21032 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
21033 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
21034 if (0 != sw_if_to_name)
21036 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
21038 vat_json_object_add_uint (node, "state", mp->state);
21039 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
21043 api_sw_interface_span_dump (vat_main_t * vam)
21045 unformat_input_t *input = vam->input;
21046 vl_api_sw_interface_span_dump_t *mp;
21047 vl_api_control_ping_t *mp_ping;
21051 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21053 if (unformat (input, "l2"))
21059 M (SW_INTERFACE_SPAN_DUMP, mp);
21063 /* Use a control ping for synchronization */
21064 MPING (CONTROL_PING, mp_ping);
21072 api_pg_create_interface (vat_main_t * vam)
21074 unformat_input_t *input = vam->input;
21075 vl_api_pg_create_interface_t *mp;
21079 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21081 if (unformat (input, "if_id %d", &if_id))
21088 errmsg ("missing pg interface index");
21092 /* Construct the API message */
21093 M (PG_CREATE_INTERFACE, mp);
21095 mp->interface_id = ntohl (if_id);
21103 api_pg_capture (vat_main_t * vam)
21105 unformat_input_t *input = vam->input;
21106 vl_api_pg_capture_t *mp;
21111 u8 pcap_file_set = 0;
21114 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21116 if (unformat (input, "if_id %d", &if_id))
21118 else if (unformat (input, "pcap %s", &pcap_file))
21120 else if (unformat (input, "count %d", &count))
21122 else if (unformat (input, "disable"))
21129 errmsg ("missing pg interface index");
21132 if (pcap_file_set > 0)
21134 if (vec_len (pcap_file) > 255)
21136 errmsg ("pcap file name is too long");
21141 u32 name_len = vec_len (pcap_file);
21142 /* Construct the API message */
21143 M (PG_CAPTURE, mp);
21145 mp->interface_id = ntohl (if_id);
21146 mp->is_enabled = enable;
21147 mp->count = ntohl (count);
21148 mp->pcap_name_length = ntohl (name_len);
21149 if (pcap_file_set != 0)
21151 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
21153 vec_free (pcap_file);
21161 api_pg_enable_disable (vat_main_t * vam)
21163 unformat_input_t *input = vam->input;
21164 vl_api_pg_enable_disable_t *mp;
21167 u8 stream_name_set = 0;
21168 u8 *stream_name = 0;
21170 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21172 if (unformat (input, "stream %s", &stream_name))
21173 stream_name_set = 1;
21174 else if (unformat (input, "disable"))
21180 if (stream_name_set > 0)
21182 if (vec_len (stream_name) > 255)
21184 errmsg ("stream name too long");
21189 u32 name_len = vec_len (stream_name);
21190 /* Construct the API message */
21191 M (PG_ENABLE_DISABLE, mp);
21193 mp->is_enabled = enable;
21194 if (stream_name_set != 0)
21196 mp->stream_name_length = ntohl (name_len);
21197 clib_memcpy (mp->stream_name, stream_name, name_len);
21199 vec_free (stream_name);
21207 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
21209 unformat_input_t *input = vam->input;
21210 vl_api_ip_source_and_port_range_check_add_del_t *mp;
21212 u16 *low_ports = 0;
21213 u16 *high_ports = 0;
21216 ip4_address_t ip4_addr;
21217 ip6_address_t ip6_addr;
21226 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21228 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
21234 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
21239 else if (unformat (input, "vrf %d", &vrf_id))
21241 else if (unformat (input, "del"))
21243 else if (unformat (input, "port %d", &tmp))
21245 if (tmp == 0 || tmp > 65535)
21247 errmsg ("port %d out of range", tmp);
21251 this_hi = this_low + 1;
21252 vec_add1 (low_ports, this_low);
21253 vec_add1 (high_ports, this_hi);
21255 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
21257 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
21259 errmsg ("incorrect range parameters");
21263 /* Note: in debug CLI +1 is added to high before
21264 passing to real fn that does "the work"
21265 (ip_source_and_port_range_check_add_del).
21266 This fn is a wrapper around the binary API fn a
21267 control plane will call, which expects this increment
21268 to have occurred. Hence letting the binary API control
21269 plane fn do the increment for consistency between VAT
21270 and other control planes.
21273 vec_add1 (low_ports, this_low);
21274 vec_add1 (high_ports, this_hi);
21280 if (prefix_set == 0)
21282 errmsg ("<address>/<mask> not specified");
21288 errmsg ("VRF ID required, not specified");
21295 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21299 if (vec_len (low_ports) == 0)
21301 errmsg ("At least one port or port range required");
21305 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
21307 mp->is_add = is_add;
21312 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
21317 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
21320 mp->mask_length = length;
21321 mp->number_of_ranges = vec_len (low_ports);
21323 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
21324 vec_free (low_ports);
21326 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
21327 vec_free (high_ports);
21329 mp->vrf_id = ntohl (vrf_id);
21337 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
21339 unformat_input_t *input = vam->input;
21340 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
21341 u32 sw_if_index = ~0;
21343 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
21344 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
21348 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21350 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21352 else if (unformat (input, "sw_if_index %d", &sw_if_index))
21354 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
21356 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
21358 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
21360 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
21362 else if (unformat (input, "del"))
21368 if (sw_if_index == ~0)
21370 errmsg ("Interface required but not specified");
21376 errmsg ("VRF ID required but not specified");
21380 if (tcp_out_vrf_id == 0
21381 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
21384 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21388 /* Construct the API message */
21389 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
21391 mp->sw_if_index = ntohl (sw_if_index);
21392 mp->is_add = is_add;
21393 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
21394 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
21395 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
21396 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
21401 /* Wait for a reply... */
21407 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
21409 unformat_input_t *i = vam->input;
21410 vl_api_ipsec_gre_add_del_tunnel_t *mp;
21411 u32 local_sa_id = 0;
21412 u32 remote_sa_id = 0;
21413 ip4_address_t src_address;
21414 ip4_address_t dst_address;
21418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21420 if (unformat (i, "local_sa %d", &local_sa_id))
21422 else if (unformat (i, "remote_sa %d", &remote_sa_id))
21424 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
21426 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
21428 else if (unformat (i, "del"))
21432 clib_warning ("parse error '%U'", format_unformat_error, i);
21437 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
21439 mp->local_sa_id = ntohl (local_sa_id);
21440 mp->remote_sa_id = ntohl (remote_sa_id);
21441 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
21442 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
21443 mp->is_add = is_add;
21451 api_punt (vat_main_t * vam)
21453 unformat_input_t *i = vam->input;
21461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21463 if (unformat (i, "ip %d", &ipv))
21465 else if (unformat (i, "protocol %d", &protocol))
21467 else if (unformat (i, "port %d", &port))
21469 else if (unformat (i, "del"))
21473 clib_warning ("parse error '%U'", format_unformat_error, i);
21480 mp->is_add = (u8) is_add;
21481 mp->ipv = (u8) ipv;
21482 mp->l4_protocol = (u8) protocol;
21483 mp->l4_port = htons ((u16) port);
21490 static void vl_api_ipsec_gre_tunnel_details_t_handler
21491 (vl_api_ipsec_gre_tunnel_details_t * mp)
21493 vat_main_t *vam = &vat_main;
21495 print (vam->ofp, "%11d%15U%15U%14d%14d",
21496 ntohl (mp->sw_if_index),
21497 format_ip4_address, &mp->src_address,
21498 format_ip4_address, &mp->dst_address,
21499 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
21502 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
21503 (vl_api_ipsec_gre_tunnel_details_t * mp)
21505 vat_main_t *vam = &vat_main;
21506 vat_json_node_t *node = NULL;
21507 struct in_addr ip4;
21509 if (VAT_JSON_ARRAY != vam->json_tree.type)
21511 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21512 vat_json_init_array (&vam->json_tree);
21514 node = vat_json_array_add (&vam->json_tree);
21516 vat_json_init_object (node);
21517 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
21518 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
21519 vat_json_object_add_ip4 (node, "src_address", ip4);
21520 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
21521 vat_json_object_add_ip4 (node, "dst_address", ip4);
21522 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
21523 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
21527 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
21529 unformat_input_t *i = vam->input;
21530 vl_api_ipsec_gre_tunnel_dump_t *mp;
21531 vl_api_control_ping_t *mp_ping;
21533 u8 sw_if_index_set = 0;
21536 /* Parse args required to build the message */
21537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21539 if (unformat (i, "sw_if_index %d", &sw_if_index))
21540 sw_if_index_set = 1;
21545 if (sw_if_index_set == 0)
21550 if (!vam->json_output)
21552 print (vam->ofp, "%11s%15s%15s%14s%14s",
21553 "sw_if_index", "src_address", "dst_address",
21554 "local_sa_id", "remote_sa_id");
21557 /* Get list of gre-tunnel interfaces */
21558 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21560 mp->sw_if_index = htonl (sw_if_index);
21564 /* Use a control ping for synchronization */
21565 MPING (CONTROL_PING, mp_ping);
21573 api_delete_subif (vat_main_t * vam)
21575 unformat_input_t *i = vam->input;
21576 vl_api_delete_subif_t *mp;
21577 u32 sw_if_index = ~0;
21580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21582 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21584 if (unformat (i, "sw_if_index %d", &sw_if_index))
21590 if (sw_if_index == ~0)
21592 errmsg ("missing sw_if_index");
21596 /* Construct the API message */
21597 M (DELETE_SUBIF, mp);
21598 mp->sw_if_index = ntohl (sw_if_index);
21605 #define foreach_pbb_vtr_op \
21606 _("disable", L2_VTR_DISABLED) \
21607 _("pop", L2_VTR_POP_2) \
21608 _("push", L2_VTR_PUSH_2)
21611 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21613 unformat_input_t *i = vam->input;
21614 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21615 u32 sw_if_index = ~0, vtr_op = ~0;
21616 u16 outer_tag = ~0;
21617 u8 dmac[6], smac[6];
21618 u8 dmac_set = 0, smac_set = 0;
21624 /* Shut up coverity */
21625 memset (dmac, 0, sizeof (dmac));
21626 memset (smac, 0, sizeof (smac));
21628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21630 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21632 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21634 else if (unformat (i, "vtr_op %d", &vtr_op))
21636 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21639 else if (unformat (i, "translate_pbb_stag"))
21641 if (unformat (i, "%d", &tmp))
21643 vtr_op = L2_VTR_TRANSLATE_2_1;
21649 ("translate_pbb_stag operation requires outer tag definition");
21653 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21655 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21657 else if (unformat (i, "sid %d", &sid))
21659 else if (unformat (i, "vlanid %d", &tmp))
21663 clib_warning ("parse error '%U'", format_unformat_error, i);
21668 if ((sw_if_index == ~0) || (vtr_op == ~0))
21670 errmsg ("missing sw_if_index or vtr operation");
21673 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21674 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21677 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21681 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21682 mp->sw_if_index = ntohl (sw_if_index);
21683 mp->vtr_op = ntohl (vtr_op);
21684 mp->outer_tag = ntohs (outer_tag);
21685 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21686 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21687 mp->b_vlanid = ntohs (vlanid);
21688 mp->i_sid = ntohl (sid);
21696 api_flow_classify_set_interface (vat_main_t * vam)
21698 unformat_input_t *i = vam->input;
21699 vl_api_flow_classify_set_interface_t *mp;
21701 int sw_if_index_set;
21702 u32 ip4_table_index = ~0;
21703 u32 ip6_table_index = ~0;
21707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21709 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21710 sw_if_index_set = 1;
21711 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21712 sw_if_index_set = 1;
21713 else if (unformat (i, "del"))
21715 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21717 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21721 clib_warning ("parse error '%U'", format_unformat_error, i);
21726 if (sw_if_index_set == 0)
21728 errmsg ("missing interface name or sw_if_index");
21732 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21734 mp->sw_if_index = ntohl (sw_if_index);
21735 mp->ip4_table_index = ntohl (ip4_table_index);
21736 mp->ip6_table_index = ntohl (ip6_table_index);
21737 mp->is_add = is_add;
21745 api_flow_classify_dump (vat_main_t * vam)
21747 unformat_input_t *i = vam->input;
21748 vl_api_flow_classify_dump_t *mp;
21749 vl_api_control_ping_t *mp_ping;
21750 u8 type = FLOW_CLASSIFY_N_TABLES;
21753 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21757 errmsg ("classify table type must be specified");
21761 if (!vam->json_output)
21763 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21766 M (FLOW_CLASSIFY_DUMP, mp);
21771 /* Use a control ping for synchronization */
21772 MPING (CONTROL_PING, mp_ping);
21775 /* Wait for a reply... */
21781 api_feature_enable_disable (vat_main_t * vam)
21783 unformat_input_t *i = vam->input;
21784 vl_api_feature_enable_disable_t *mp;
21786 u8 *feature_name = 0;
21787 u32 sw_if_index = ~0;
21791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21793 if (unformat (i, "arc_name %s", &arc_name))
21795 else if (unformat (i, "feature_name %s", &feature_name))
21798 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21800 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21802 else if (unformat (i, "disable"))
21810 errmsg ("missing arc name");
21813 if (vec_len (arc_name) > 63)
21815 errmsg ("arc name too long");
21818 if (feature_name == 0)
21820 errmsg ("missing feature name");
21823 if (vec_len (feature_name) > 63)
21825 errmsg ("feature name too long");
21828 if (sw_if_index == ~0)
21830 errmsg ("missing interface name or sw_if_index");
21834 /* Construct the API message */
21835 M (FEATURE_ENABLE_DISABLE, mp);
21836 mp->sw_if_index = ntohl (sw_if_index);
21837 mp->enable = enable;
21838 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21839 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21840 vec_free (arc_name);
21841 vec_free (feature_name);
21849 api_sw_interface_tag_add_del (vat_main_t * vam)
21851 unformat_input_t *i = vam->input;
21852 vl_api_sw_interface_tag_add_del_t *mp;
21853 u32 sw_if_index = ~0;
21858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21860 if (unformat (i, "tag %s", &tag))
21862 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21864 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21866 else if (unformat (i, "del"))
21872 if (sw_if_index == ~0)
21874 errmsg ("missing interface name or sw_if_index");
21878 if (enable && (tag == 0))
21880 errmsg ("no tag specified");
21884 /* Construct the API message */
21885 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21886 mp->sw_if_index = ntohl (sw_if_index);
21887 mp->is_add = enable;
21889 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21897 static void vl_api_l2_xconnect_details_t_handler
21898 (vl_api_l2_xconnect_details_t * mp)
21900 vat_main_t *vam = &vat_main;
21902 print (vam->ofp, "%15d%15d",
21903 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21906 static void vl_api_l2_xconnect_details_t_handler_json
21907 (vl_api_l2_xconnect_details_t * mp)
21909 vat_main_t *vam = &vat_main;
21910 vat_json_node_t *node = NULL;
21912 if (VAT_JSON_ARRAY != vam->json_tree.type)
21914 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21915 vat_json_init_array (&vam->json_tree);
21917 node = vat_json_array_add (&vam->json_tree);
21919 vat_json_init_object (node);
21920 vat_json_object_add_uint (node, "rx_sw_if_index",
21921 ntohl (mp->rx_sw_if_index));
21922 vat_json_object_add_uint (node, "tx_sw_if_index",
21923 ntohl (mp->tx_sw_if_index));
21927 api_l2_xconnect_dump (vat_main_t * vam)
21929 vl_api_l2_xconnect_dump_t *mp;
21930 vl_api_control_ping_t *mp_ping;
21933 if (!vam->json_output)
21935 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21938 M (L2_XCONNECT_DUMP, mp);
21942 /* Use a control ping for synchronization */
21943 MPING (CONTROL_PING, mp_ping);
21951 api_sw_interface_set_mtu (vat_main_t * vam)
21953 unformat_input_t *i = vam->input;
21954 vl_api_sw_interface_set_mtu_t *mp;
21955 u32 sw_if_index = ~0;
21959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21961 if (unformat (i, "mtu %d", &mtu))
21963 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21965 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21971 if (sw_if_index == ~0)
21973 errmsg ("missing interface name or sw_if_index");
21979 errmsg ("no mtu specified");
21983 /* Construct the API message */
21984 M (SW_INTERFACE_SET_MTU, mp);
21985 mp->sw_if_index = ntohl (sw_if_index);
21986 mp->mtu = ntohs ((u16) mtu);
21994 api_p2p_ethernet_add (vat_main_t * vam)
21996 unformat_input_t *i = vam->input;
21997 vl_api_p2p_ethernet_add_t *mp;
21998 u32 parent_if_index = ~0;
22004 memset (remote_mac, 0, sizeof (remote_mac));
22005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22007 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
22009 else if (unformat (i, "sw_if_index %d", &parent_if_index))
22013 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
22015 else if (unformat (i, "sub_id %d", &sub_id))
22019 clib_warning ("parse error '%U'", format_unformat_error, i);
22024 if (parent_if_index == ~0)
22026 errmsg ("missing interface name or sw_if_index");
22031 errmsg ("missing remote mac address");
22036 errmsg ("missing sub-interface id");
22040 M (P2P_ETHERNET_ADD, mp);
22041 mp->parent_if_index = ntohl (parent_if_index);
22042 mp->subif_id = ntohl (sub_id);
22043 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
22051 api_p2p_ethernet_del (vat_main_t * vam)
22053 unformat_input_t *i = vam->input;
22054 vl_api_p2p_ethernet_del_t *mp;
22055 u32 parent_if_index = ~0;
22060 memset (remote_mac, 0, sizeof (remote_mac));
22061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22063 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
22065 else if (unformat (i, "sw_if_index %d", &parent_if_index))
22069 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
22073 clib_warning ("parse error '%U'", format_unformat_error, i);
22078 if (parent_if_index == ~0)
22080 errmsg ("missing interface name or sw_if_index");
22085 errmsg ("missing remote mac address");
22089 M (P2P_ETHERNET_DEL, mp);
22090 mp->parent_if_index = ntohl (parent_if_index);
22091 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
22099 api_lldp_config (vat_main_t * vam)
22101 unformat_input_t *i = vam->input;
22102 vl_api_lldp_config_t *mp;
22104 int tx_interval = 0;
22105 u8 *sys_name = NULL;
22108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22110 if (unformat (i, "system-name %s", &sys_name))
22112 else if (unformat (i, "tx-hold %d", &tx_hold))
22114 else if (unformat (i, "tx-interval %d", &tx_interval))
22118 clib_warning ("parse error '%U'", format_unformat_error, i);
22123 vec_add1 (sys_name, 0);
22125 M (LLDP_CONFIG, mp);
22126 mp->tx_hold = htonl (tx_hold);
22127 mp->tx_interval = htonl (tx_interval);
22128 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
22129 vec_free (sys_name);
22137 api_sw_interface_set_lldp (vat_main_t * vam)
22139 unformat_input_t *i = vam->input;
22140 vl_api_sw_interface_set_lldp_t *mp;
22141 u32 sw_if_index = ~0;
22143 u8 *port_desc = NULL, *mgmt_oid = NULL;
22144 ip4_address_t ip4_addr;
22145 ip6_address_t ip6_addr;
22148 memset (&ip4_addr, 0, sizeof (ip4_addr));
22149 memset (&ip6_addr, 0, sizeof (ip6_addr));
22151 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22153 if (unformat (i, "disable"))
22156 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22158 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22160 else if (unformat (i, "port-desc %s", &port_desc))
22162 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
22164 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
22166 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
22172 if (sw_if_index == ~0)
22174 errmsg ("missing interface name or sw_if_index");
22178 /* Construct the API message */
22179 vec_add1 (port_desc, 0);
22180 vec_add1 (mgmt_oid, 0);
22181 M (SW_INTERFACE_SET_LLDP, mp);
22182 mp->sw_if_index = ntohl (sw_if_index);
22183 mp->enable = enable;
22184 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
22185 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
22186 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
22187 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
22188 vec_free (port_desc);
22189 vec_free (mgmt_oid);
22197 api_tcp_configure_src_addresses (vat_main_t * vam)
22199 vl_api_tcp_configure_src_addresses_t *mp;
22200 unformat_input_t *i = vam->input;
22201 ip4_address_t v4first, v4last;
22202 ip6_address_t v6first, v6last;
22207 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22209 if (unformat (i, "%U - %U",
22210 unformat_ip4_address, &v4first,
22211 unformat_ip4_address, &v4last))
22215 errmsg ("one range per message (range already set)");
22220 else if (unformat (i, "%U - %U",
22221 unformat_ip6_address, &v6first,
22222 unformat_ip6_address, &v6last))
22226 errmsg ("one range per message (range already set)");
22231 else if (unformat (i, "vrf %d", &vrf_id))
22237 if (range_set == 0)
22239 errmsg ("address range not set");
22243 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
22244 mp->vrf_id = ntohl (vrf_id);
22246 if (range_set == 2)
22249 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
22250 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
22255 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
22256 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
22263 static void vl_api_app_namespace_add_del_reply_t_handler
22264 (vl_api_app_namespace_add_del_reply_t * mp)
22266 vat_main_t *vam = &vat_main;
22267 i32 retval = ntohl (mp->retval);
22268 if (vam->async_mode)
22270 vam->async_errors += (retval < 0);
22274 vam->retval = retval;
22276 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
22277 vam->result_ready = 1;
22281 static void vl_api_app_namespace_add_del_reply_t_handler_json
22282 (vl_api_app_namespace_add_del_reply_t * mp)
22284 vat_main_t *vam = &vat_main;
22285 vat_json_node_t node;
22287 vat_json_init_object (&node);
22288 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
22289 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
22291 vat_json_print (vam->ofp, &node);
22292 vat_json_free (&node);
22294 vam->retval = ntohl (mp->retval);
22295 vam->result_ready = 1;
22299 api_app_namespace_add_del (vat_main_t * vam)
22301 vl_api_app_namespace_add_del_t *mp;
22302 unformat_input_t *i = vam->input;
22303 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
22304 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
22308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22310 if (unformat (i, "id %_%v%_", &ns_id))
22312 else if (unformat (i, "secret %lu", &secret))
22314 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22315 sw_if_index_set = 1;
22316 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
22318 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
22323 if (!ns_id || !secret_set || !sw_if_index_set)
22325 errmsg ("namespace id, secret and sw_if_index must be set");
22328 if (vec_len (ns_id) > 64)
22330 errmsg ("namespace id too long");
22333 M (APP_NAMESPACE_ADD_DEL, mp);
22335 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
22336 mp->namespace_id_len = vec_len (ns_id);
22337 mp->secret = clib_host_to_net_u64 (secret);
22338 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22339 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
22340 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
22348 api_memfd_segment_create (vat_main_t * vam)
22350 #if VPP_API_TEST_BUILTIN == 0
22351 unformat_input_t *i = vam->input;
22352 vl_api_memfd_segment_create_t *mp;
22353 u64 size = 64 << 20;
22356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22358 if (unformat (i, "size %U", unformat_memory_size, &size))
22364 M (MEMFD_SEGMENT_CREATE, mp);
22365 mp->requested_size = size;
22371 errmsg ("memfd_segment_create (builtin) not supported");
22377 api_sock_init_shm (vat_main_t * vam)
22379 #if VPP_API_TEST_BUILTIN == 0
22380 unformat_input_t *i = vam->input;
22381 vl_api_shm_elem_config_t *config = 0;
22382 u64 size = 64 << 20;
22385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22387 if (unformat (i, "size %U", unformat_memory_size, &size))
22393 /* Try customized config to see if it works */
22394 vec_validate (config, 3);
22395 config[0].type = VL_API_VLIB_RING;
22396 config[0].count = 256;
22397 config[0].size = 256;
22398 config[1].type = VL_API_CLIENT_RING;
22399 config[1].count = 256;
22400 config[1].size = 1024;
22401 config[2].type = VL_API_CLIENT_RING;
22402 config[2].count = 8;
22403 config[2].size = 4096;
22404 config[3].type = VL_API_QUEUE;
22405 config[3].count = 256;
22406 config[3].size = sizeof (uword);
22407 rv = vl_socket_client_init_shm (config);
22409 vam->client_index_invalid = 1;
22417 api_dns_enable_disable (vat_main_t * vam)
22419 unformat_input_t *line_input = vam->input;
22420 vl_api_dns_enable_disable_t *mp;
22421 u8 enable_disable = 1;
22424 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22426 if (unformat (line_input, "disable"))
22427 enable_disable = 0;
22428 if (unformat (line_input, "enable"))
22429 enable_disable = 1;
22434 /* Construct the API message */
22435 M (DNS_ENABLE_DISABLE, mp);
22436 mp->enable = enable_disable;
22440 /* Wait for the reply */
22446 api_dns_resolve_name (vat_main_t * vam)
22448 unformat_input_t *line_input = vam->input;
22449 vl_api_dns_resolve_name_t *mp;
22453 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22455 if (unformat (line_input, "%s", &name))
22461 if (vec_len (name) > 127)
22463 errmsg ("name too long");
22467 /* Construct the API message */
22468 M (DNS_RESOLVE_NAME, mp);
22469 memcpy (mp->name, name, vec_len (name));
22474 /* Wait for the reply */
22480 api_dns_resolve_ip (vat_main_t * vam)
22482 unformat_input_t *line_input = vam->input;
22483 vl_api_dns_resolve_ip_t *mp;
22485 ip4_address_t addr4;
22486 ip6_address_t addr6;
22489 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22491 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
22493 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
22501 errmsg ("missing address");
22505 /* Construct the API message */
22506 M (DNS_RESOLVE_IP, mp);
22507 mp->is_ip6 = is_ip6;
22509 memcpy (mp->address, &addr6, sizeof (addr6));
22511 memcpy (mp->address, &addr4, sizeof (addr4));
22515 /* Wait for the reply */
22521 api_dns_name_server_add_del (vat_main_t * vam)
22523 unformat_input_t *i = vam->input;
22524 vl_api_dns_name_server_add_del_t *mp;
22526 ip6_address_t ip6_server;
22527 ip4_address_t ip4_server;
22532 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22534 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
22536 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
22538 else if (unformat (i, "del"))
22542 clib_warning ("parse error '%U'", format_unformat_error, i);
22547 if (ip4_set && ip6_set)
22549 errmsg ("Only one server address allowed per message");
22552 if ((ip4_set + ip6_set) == 0)
22554 errmsg ("Server address required");
22558 /* Construct the API message */
22559 M (DNS_NAME_SERVER_ADD_DEL, mp);
22563 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22568 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22572 mp->is_add = is_add;
22577 /* Wait for a reply, return good/bad news */
22583 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22585 vat_main_t *vam = &vat_main;
22590 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22591 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22592 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22593 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22594 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22595 clib_net_to_host_u32 (mp->action_index), mp->tag);
22600 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22601 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22602 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22603 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22604 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22605 clib_net_to_host_u32 (mp->action_index), mp->tag);
22610 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22613 vat_main_t *vam = &vat_main;
22614 vat_json_node_t *node = NULL;
22615 struct in6_addr ip6;
22616 struct in_addr ip4;
22618 if (VAT_JSON_ARRAY != vam->json_tree.type)
22620 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22621 vat_json_init_array (&vam->json_tree);
22623 node = vat_json_array_add (&vam->json_tree);
22624 vat_json_init_object (node);
22626 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22627 vat_json_object_add_uint (node, "appns_index",
22628 clib_net_to_host_u32 (mp->appns_index));
22629 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22630 vat_json_object_add_uint (node, "scope", mp->scope);
22631 vat_json_object_add_uint (node, "action_index",
22632 clib_net_to_host_u32 (mp->action_index));
22633 vat_json_object_add_uint (node, "lcl_port",
22634 clib_net_to_host_u16 (mp->lcl_port));
22635 vat_json_object_add_uint (node, "rmt_port",
22636 clib_net_to_host_u16 (mp->rmt_port));
22637 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22638 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22639 vat_json_object_add_string_copy (node, "tag", mp->tag);
22642 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22643 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22644 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22645 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22649 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22650 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22651 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22652 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22657 api_session_rule_add_del (vat_main_t * vam)
22659 vl_api_session_rule_add_del_t *mp;
22660 unformat_input_t *i = vam->input;
22661 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22662 u32 appns_index = 0, scope = 0;
22663 ip4_address_t lcl_ip4, rmt_ip4;
22664 ip6_address_t lcl_ip6, rmt_ip6;
22665 u8 is_ip4 = 1, conn_set = 0;
22666 u8 is_add = 1, *tag = 0;
22669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22671 if (unformat (i, "del"))
22673 else if (unformat (i, "add"))
22675 else if (unformat (i, "proto tcp"))
22677 else if (unformat (i, "proto udp"))
22679 else if (unformat (i, "appns %d", &appns_index))
22681 else if (unformat (i, "scope %d", &scope))
22683 else if (unformat (i, "tag %_%v%_", &tag))
22687 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22688 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22696 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22697 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22703 else if (unformat (i, "action %d", &action))
22708 if (proto == ~0 || !conn_set || action == ~0)
22710 errmsg ("transport proto, connection and action must be set");
22716 errmsg ("scope should be 0-3");
22720 M (SESSION_RULE_ADD_DEL, mp);
22722 mp->is_ip4 = is_ip4;
22723 mp->transport_proto = proto;
22724 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22725 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22726 mp->lcl_plen = lcl_plen;
22727 mp->rmt_plen = rmt_plen;
22728 mp->action_index = clib_host_to_net_u32 (action);
22729 mp->appns_index = clib_host_to_net_u32 (appns_index);
22731 mp->is_add = is_add;
22734 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22735 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22739 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22740 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22744 clib_memcpy (mp->tag, tag, vec_len (tag));
22754 api_session_rules_dump (vat_main_t * vam)
22756 vl_api_session_rules_dump_t *mp;
22757 vl_api_control_ping_t *mp_ping;
22760 if (!vam->json_output)
22762 print (vam->ofp, "%=20s", "Session Rules");
22765 M (SESSION_RULES_DUMP, mp);
22769 /* Use a control ping for synchronization */
22770 MPING (CONTROL_PING, mp_ping);
22773 /* Wait for a reply... */
22779 api_ip_container_proxy_add_del (vat_main_t * vam)
22781 vl_api_ip_container_proxy_add_del_t *mp;
22782 unformat_input_t *i = vam->input;
22783 u32 plen = ~0, sw_if_index = ~0;
22790 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22792 if (unformat (i, "del"))
22794 else if (unformat (i, "add"))
22796 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22801 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22806 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22811 if (sw_if_index == ~0 || plen == ~0)
22813 errmsg ("address and sw_if_index must be set");
22817 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22819 mp->is_ip4 = is_ip4;
22820 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22822 mp->is_add = is_add;
22824 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22826 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22834 q_or_quit (vat_main_t * vam)
22836 #if VPP_API_TEST_BUILTIN == 0
22837 longjmp (vam->jump_buf, 1);
22839 return 0; /* not so much */
22843 q (vat_main_t * vam)
22845 return q_or_quit (vam);
22849 quit (vat_main_t * vam)
22851 return q_or_quit (vam);
22855 comment (vat_main_t * vam)
22861 cmd_cmp (void *a1, void *a2)
22866 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22870 help (vat_main_t * vam)
22875 unformat_input_t *i = vam->input;
22878 if (unformat (i, "%s", &name))
22882 vec_add1 (name, 0);
22884 hs = hash_get_mem (vam->help_by_name, name);
22886 print (vam->ofp, "usage: %s %s", name, hs[0]);
22888 print (vam->ofp, "No such msg / command '%s'", name);
22893 print (vam->ofp, "Help is available for the following:");
22896 hash_foreach_pair (p, vam->function_by_name,
22898 vec_add1 (cmds, (u8 *)(p->key));
22902 vec_sort_with_function (cmds, cmd_cmp);
22904 for (j = 0; j < vec_len (cmds); j++)
22905 print (vam->ofp, "%s", cmds[j]);
22912 set (vat_main_t * vam)
22914 u8 *name = 0, *value = 0;
22915 unformat_input_t *i = vam->input;
22917 if (unformat (i, "%s", &name))
22919 /* The input buffer is a vector, not a string. */
22920 value = vec_dup (i->buffer);
22921 vec_delete (value, i->index, 0);
22922 /* Almost certainly has a trailing newline */
22923 if (value[vec_len (value) - 1] == '\n')
22924 value[vec_len (value) - 1] = 0;
22925 /* Make sure it's a proper string, one way or the other */
22926 vec_add1 (value, 0);
22927 (void) clib_macro_set_value (&vam->macro_main,
22928 (char *) name, (char *) value);
22931 errmsg ("usage: set <name> <value>");
22939 unset (vat_main_t * vam)
22943 if (unformat (vam->input, "%s", &name))
22944 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22945 errmsg ("unset: %s wasn't set", name);
22958 macro_sort_cmp (void *a1, void *a2)
22960 macro_sort_t *s1 = a1;
22961 macro_sort_t *s2 = a2;
22963 return strcmp ((char *) (s1->name), (char *) (s2->name));
22967 dump_macro_table (vat_main_t * vam)
22969 macro_sort_t *sort_me = 0, *sm;
22974 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22976 vec_add2 (sort_me, sm, 1);
22977 sm->name = (u8 *)(p->key);
22978 sm->value = (u8 *) (p->value[0]);
22982 vec_sort_with_function (sort_me, macro_sort_cmp);
22984 if (vec_len (sort_me))
22985 print (vam->ofp, "%-15s%s", "Name", "Value");
22987 print (vam->ofp, "The macro table is empty...");
22989 for (i = 0; i < vec_len (sort_me); i++)
22990 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22995 dump_node_table (vat_main_t * vam)
22998 vlib_node_t *node, *next_node;
23000 if (vec_len (vam->graph_nodes) == 0)
23002 print (vam->ofp, "Node table empty, issue get_node_graph...");
23006 for (i = 0; i < vec_len (vam->graph_nodes); i++)
23008 node = vam->graph_nodes[i];
23009 print (vam->ofp, "[%d] %s", i, node->name);
23010 for (j = 0; j < vec_len (node->next_nodes); j++)
23012 if (node->next_nodes[j] != ~0)
23014 next_node = vam->graph_nodes[node->next_nodes[j]];
23015 print (vam->ofp, " [%d] %s", j, next_node->name);
23023 value_sort_cmp (void *a1, void *a2)
23025 name_sort_t *n1 = a1;
23026 name_sort_t *n2 = a2;
23028 if (n1->value < n2->value)
23030 if (n1->value > n2->value)
23037 dump_msg_api_table (vat_main_t * vam)
23039 api_main_t *am = &api_main;
23040 name_sort_t *nses = 0, *ns;
23045 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
23047 vec_add2 (nses, ns, 1);
23048 ns->name = (u8 *)(hp->key);
23049 ns->value = (u32) hp->value[0];
23053 vec_sort_with_function (nses, value_sort_cmp);
23055 for (i = 0; i < vec_len (nses); i++)
23056 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
23062 get_msg_id (vat_main_t * vam)
23067 if (unformat (vam->input, "%s", &name_and_crc))
23069 message_index = vl_msg_api_get_msg_index (name_and_crc);
23070 if (message_index == ~0)
23072 print (vam->ofp, " '%s' not found", name_and_crc);
23075 print (vam->ofp, " '%s' has message index %d",
23076 name_and_crc, message_index);
23079 errmsg ("name_and_crc required...");
23084 search_node_table (vat_main_t * vam)
23086 unformat_input_t *line_input = vam->input;
23089 vlib_node_t *node, *next_node;
23092 if (vam->graph_node_index_by_name == 0)
23094 print (vam->ofp, "Node table empty, issue get_node_graph...");
23098 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
23100 if (unformat (line_input, "%s", &node_to_find))
23102 vec_add1 (node_to_find, 0);
23103 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
23106 print (vam->ofp, "%s not found...", node_to_find);
23109 node = vam->graph_nodes[p[0]];
23110 print (vam->ofp, "[%d] %s", p[0], node->name);
23111 for (j = 0; j < vec_len (node->next_nodes); j++)
23113 if (node->next_nodes[j] != ~0)
23115 next_node = vam->graph_nodes[node->next_nodes[j]];
23116 print (vam->ofp, " [%d] %s", j, next_node->name);
23123 clib_warning ("parse error '%U'", format_unformat_error,
23129 vec_free (node_to_find);
23138 script (vat_main_t * vam)
23140 #if (VPP_API_TEST_BUILTIN==0)
23142 char *save_current_file;
23143 unformat_input_t save_input;
23144 jmp_buf save_jump_buf;
23145 u32 save_line_number;
23147 FILE *new_fp, *save_ifp;
23149 if (unformat (vam->input, "%s", &s))
23151 new_fp = fopen ((char *) s, "r");
23154 errmsg ("Couldn't open script file %s", s);
23161 errmsg ("Missing script name");
23165 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
23166 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
23167 save_ifp = vam->ifp;
23168 save_line_number = vam->input_line_number;
23169 save_current_file = (char *) vam->current_file;
23171 vam->input_line_number = 0;
23173 vam->current_file = s;
23176 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
23177 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
23178 vam->ifp = save_ifp;
23179 vam->input_line_number = save_line_number;
23180 vam->current_file = (u8 *) save_current_file;
23185 clib_warning ("use the exec command...");
23191 echo (vat_main_t * vam)
23193 print (vam->ofp, "%v", vam->input->buffer);
23197 /* List of API message constructors, CLI names map to api_xxx */
23198 #define foreach_vpe_api_msg \
23199 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
23200 _(sw_interface_dump,"") \
23201 _(sw_interface_set_flags, \
23202 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
23203 _(sw_interface_add_del_address, \
23204 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
23205 _(sw_interface_set_rx_mode, \
23206 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
23207 _(sw_interface_set_table, \
23208 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
23209 _(sw_interface_set_mpls_enable, \
23210 "<intfc> | sw_if_index [disable | dis]") \
23211 _(sw_interface_set_vpath, \
23212 "<intfc> | sw_if_index <id> enable | disable") \
23213 _(sw_interface_set_vxlan_bypass, \
23214 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23215 _(sw_interface_set_geneve_bypass, \
23216 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23217 _(sw_interface_set_l2_xconnect, \
23218 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23219 "enable | disable") \
23220 _(sw_interface_set_l2_bridge, \
23221 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
23222 "[shg <split-horizon-group>] [bvi]\n" \
23223 "enable | disable") \
23224 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
23225 _(bridge_domain_add_del, \
23226 "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") \
23227 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
23229 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
23230 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
23231 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
23233 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23235 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23237 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
23239 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
23241 "<vpp-if-name> | sw_if_index <id>") \
23242 _(sw_interface_tap_dump, "") \
23244 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
23246 "<vpp-if-name> | sw_if_index <id>") \
23247 _(sw_interface_tap_v2_dump, "") \
23249 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
23250 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]}") \
23252 "<vpp-if-name> | sw_if_index <id>") \
23254 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
23255 _(bond_detach_slave, \
23256 "sw_if_index <n>") \
23257 _(sw_interface_bond_dump, "") \
23258 _(sw_interface_slave_dump, \
23259 "<vpp-if-name> | sw_if_index <id>") \
23260 _(ip_table_add_del, \
23261 "table-id <n> [ipv6]\n") \
23262 _(ip_add_del_route, \
23263 "<addr>/<mask> via <addr> [table-id <n>]\n" \
23264 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
23265 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
23266 "[multipath] [count <n>]") \
23267 _(ip_mroute_add_del, \
23268 "<src> <grp>/<mask> [table-id <n>]\n" \
23269 "[<intfc> | sw_if_index <id>] [local] [del]") \
23270 _(mpls_table_add_del, \
23271 "table-id <n>\n") \
23272 _(mpls_route_add_del, \
23273 "<label> <eos> via <addr> [table-id <n>]\n" \
23274 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
23275 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
23276 "[multipath] [count <n>]") \
23277 _(mpls_ip_bind_unbind, \
23278 "<label> <addr/len>") \
23279 _(mpls_tunnel_add_del, \
23280 " via <addr> [table-id <n>]\n" \
23281 "sw_if_index <id>] [l2] [del]") \
23282 _(bier_table_add_del, \
23283 "<label> <sub-domain> <set> <bsl> [del]") \
23284 _(bier_route_add_del, \
23285 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
23286 "[<intfc> | sw_if_index <id>]" \
23287 "[weight <n>] [del] [multipath]") \
23288 _(proxy_arp_add_del, \
23289 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
23290 _(proxy_arp_intfc_enable_disable, \
23291 "<intfc> | sw_if_index <id> enable | disable") \
23292 _(sw_interface_set_unnumbered, \
23293 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
23294 _(ip_neighbor_add_del, \
23295 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
23296 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
23297 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
23298 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
23299 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
23300 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
23301 "[outer_vlan_id_any][inner_vlan_id_any]") \
23302 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
23303 _(reset_fib, "vrf <n> [ipv6]") \
23304 _(dhcp_proxy_config, \
23305 "svr <v46-address> src <v46-address>\n" \
23306 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
23307 _(dhcp_proxy_set_vss, \
23308 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
23309 _(dhcp_proxy_dump, "ip6") \
23310 _(dhcp_client_config, \
23311 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
23312 _(set_ip_flow_hash, \
23313 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
23314 _(sw_interface_ip6_enable_disable, \
23315 "<intfc> | sw_if_index <id> enable | disable") \
23316 _(sw_interface_ip6_set_link_local_address, \
23317 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
23318 _(ip6nd_proxy_add_del, \
23319 "<intfc> | sw_if_index <id> <ip6-address>") \
23320 _(ip6nd_proxy_dump, "") \
23321 _(sw_interface_ip6nd_ra_prefix, \
23322 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
23323 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
23324 "[nolink] [isno]") \
23325 _(sw_interface_ip6nd_ra_config, \
23326 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
23327 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
23328 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
23329 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
23330 _(l2_patch_add_del, \
23331 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23332 "enable | disable") \
23333 _(sr_localsid_add_del, \
23334 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
23335 "fib-table <num> (end.psp) sw_if_index <num>") \
23336 _(classify_add_del_table, \
23337 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
23338 " [del] [del-chain] mask <mask-value>\n" \
23339 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
23340 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
23341 _(classify_add_del_session, \
23342 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
23343 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
23344 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
23345 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
23346 _(classify_set_interface_ip_table, \
23347 "<intfc> | sw_if_index <nn> table <nn>") \
23348 _(classify_set_interface_l2_tables, \
23349 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23350 " [other-table <nn>]") \
23351 _(get_node_index, "node <node-name") \
23352 _(add_node_next, "node <node-name> next <next-node-name>") \
23353 _(l2tpv3_create_tunnel, \
23354 "client_address <ip6-addr> our_address <ip6-addr>\n" \
23355 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
23356 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
23357 _(l2tpv3_set_tunnel_cookies, \
23358 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
23359 "[new_remote_cookie <nn>]\n") \
23360 _(l2tpv3_interface_enable_disable, \
23361 "<intfc> | sw_if_index <nn> enable | disable") \
23362 _(l2tpv3_set_lookup_key, \
23363 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
23364 _(sw_if_l2tpv3_tunnel_dump, "") \
23365 _(vxlan_add_del_tunnel, \
23366 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23367 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
23368 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23369 _(geneve_add_del_tunnel, \
23370 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23371 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23372 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23373 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23374 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23375 _(gre_add_del_tunnel, \
23376 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
23377 "[teb | erspan <session-id>] [del]") \
23378 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23379 _(l2_fib_clear_table, "") \
23380 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
23381 _(l2_interface_vlan_tag_rewrite, \
23382 "<intfc> | sw_if_index <nn> \n" \
23383 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
23384 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
23385 _(create_vhost_user_if, \
23386 "socket <filename> [server] [renumber <dev_instance>] " \
23387 "[mac <mac_address>]") \
23388 _(modify_vhost_user_if, \
23389 "<intfc> | sw_if_index <nn> socket <filename>\n" \
23390 "[server] [renumber <dev_instance>]") \
23391 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
23392 _(sw_interface_vhost_user_dump, "") \
23393 _(show_version, "") \
23394 _(vxlan_gpe_add_del_tunnel, \
23395 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
23396 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23397 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
23398 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
23399 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23400 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
23401 _(interface_name_renumber, \
23402 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
23403 _(input_acl_set_interface, \
23404 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23405 " [l2-table <nn>] [del]") \
23406 _(want_ip4_arp_events, "address <ip4-address> [del]") \
23407 _(want_ip6_nd_events, "address <ip6-address> [del]") \
23408 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
23409 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
23410 _(ip_dump, "ipv4 | ipv6") \
23411 _(ipsec_spd_add_del, "spd_id <n> [del]") \
23412 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
23414 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
23415 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
23416 " integ_alg <alg> integ_key <hex>") \
23417 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
23418 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
23419 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
23420 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
23421 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
23422 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
23423 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
23424 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
23425 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
23426 _(ipsec_sa_dump, "[sa_id <n>]") \
23427 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
23428 " <alg> <hex>\n") \
23429 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
23430 _(ikev2_profile_add_del, "name <profile_name> [del]") \
23431 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
23432 "(auth_data 0x<data> | auth_data <data>)") \
23433 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
23434 "(id_data 0x<data> | id_data <data>) (local|remote)") \
23435 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
23436 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
23437 "(local|remote)") \
23438 _(ikev2_set_local_key, "file <absolute_file_path>") \
23439 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
23440 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23441 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23442 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
23443 _(ikev2_initiate_sa_init, "<profile_name>") \
23444 _(ikev2_initiate_del_ike_sa, "<ispi>") \
23445 _(ikev2_initiate_del_child_sa, "<ispi>") \
23446 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
23447 _(delete_loopback,"sw_if_index <nn>") \
23448 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
23449 _(map_add_domain, \
23450 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
23451 "ip6-src <ip6addr> " \
23452 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
23453 _(map_del_domain, "index <n>") \
23454 _(map_add_del_rule, \
23455 "index <n> psid <n> dst <ip6addr> [del]") \
23456 _(map_domain_dump, "") \
23457 _(map_rule_dump, "index <map-domain>") \
23458 _(want_interface_events, "enable|disable") \
23459 _(want_stats,"enable|disable") \
23460 _(get_first_msg_id, "client <name>") \
23461 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
23462 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
23463 "fib-id <nn> [ip4][ip6][default]") \
23464 _(get_node_graph, " ") \
23465 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
23466 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
23467 _(ioam_disable, "") \
23468 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
23469 " sw_if_index <sw_if_index> p <priority> " \
23470 "w <weight>] [del]") \
23471 _(one_add_del_locator, "locator-set <locator_name> " \
23472 "iface <intf> | sw_if_index <sw_if_index> " \
23473 "p <priority> w <weight> [del]") \
23474 _(one_add_del_local_eid,"vni <vni> eid " \
23475 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23476 "locator-set <locator_name> [del]" \
23477 "[key-id sha1|sha256 secret-key <secret-key>]")\
23478 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
23479 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
23480 _(one_enable_disable, "enable|disable") \
23481 _(one_map_register_enable_disable, "enable|disable") \
23482 _(one_map_register_fallback_threshold, "<value>") \
23483 _(one_rloc_probe_enable_disable, "enable|disable") \
23484 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23486 "rloc <locator> p <prio> " \
23487 "w <weight> [rloc <loc> ... ] " \
23488 "action <action> [del-all]") \
23489 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23491 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23492 _(one_use_petr, "ip-address> | disable") \
23493 _(one_map_request_mode, "src-dst|dst-only") \
23494 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23495 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23496 _(one_locator_set_dump, "[local | remote]") \
23497 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
23498 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23499 "[local] | [remote]") \
23500 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
23501 _(one_ndp_bd_get, "") \
23502 _(one_ndp_entries_get, "bd <bridge-domain>") \
23503 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
23504 _(one_l2_arp_bd_get, "") \
23505 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
23506 _(one_stats_enable_disable, "enable|disalbe") \
23507 _(show_one_stats_enable_disable, "") \
23508 _(one_eid_table_vni_dump, "") \
23509 _(one_eid_table_map_dump, "l2|l3") \
23510 _(one_map_resolver_dump, "") \
23511 _(one_map_server_dump, "") \
23512 _(one_adjacencies_get, "vni <vni>") \
23513 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
23514 _(show_one_rloc_probe_state, "") \
23515 _(show_one_map_register_state, "") \
23516 _(show_one_status, "") \
23517 _(one_stats_dump, "") \
23518 _(one_stats_flush, "") \
23519 _(one_get_map_request_itr_rlocs, "") \
23520 _(one_map_register_set_ttl, "<ttl>") \
23521 _(one_set_transport_protocol, "udp|api") \
23522 _(one_get_transport_protocol, "") \
23523 _(one_enable_disable_xtr_mode, "enable|disable") \
23524 _(one_show_xtr_mode, "") \
23525 _(one_enable_disable_pitr_mode, "enable|disable") \
23526 _(one_show_pitr_mode, "") \
23527 _(one_enable_disable_petr_mode, "enable|disable") \
23528 _(one_show_petr_mode, "") \
23529 _(show_one_nsh_mapping, "") \
23530 _(show_one_pitr, "") \
23531 _(show_one_use_petr, "") \
23532 _(show_one_map_request_mode, "") \
23533 _(show_one_map_register_ttl, "") \
23534 _(show_one_map_register_fallback_threshold, "") \
23535 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
23536 " sw_if_index <sw_if_index> p <priority> " \
23537 "w <weight>] [del]") \
23538 _(lisp_add_del_locator, "locator-set <locator_name> " \
23539 "iface <intf> | sw_if_index <sw_if_index> " \
23540 "p <priority> w <weight> [del]") \
23541 _(lisp_add_del_local_eid,"vni <vni> eid " \
23542 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23543 "locator-set <locator_name> [del]" \
23544 "[key-id sha1|sha256 secret-key <secret-key>]") \
23545 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
23546 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
23547 _(lisp_enable_disable, "enable|disable") \
23548 _(lisp_map_register_enable_disable, "enable|disable") \
23549 _(lisp_rloc_probe_enable_disable, "enable|disable") \
23550 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23552 "rloc <locator> p <prio> " \
23553 "w <weight> [rloc <loc> ... ] " \
23554 "action <action> [del-all]") \
23555 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23557 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23558 _(lisp_use_petr, "<ip-address> | disable") \
23559 _(lisp_map_request_mode, "src-dst|dst-only") \
23560 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23561 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23562 _(lisp_locator_set_dump, "[local | remote]") \
23563 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
23564 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23565 "[local] | [remote]") \
23566 _(lisp_eid_table_vni_dump, "") \
23567 _(lisp_eid_table_map_dump, "l2|l3") \
23568 _(lisp_map_resolver_dump, "") \
23569 _(lisp_map_server_dump, "") \
23570 _(lisp_adjacencies_get, "vni <vni>") \
23571 _(gpe_fwd_entry_vnis_get, "") \
23572 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23573 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23574 "[table <table-id>]") \
23575 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23576 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23577 _(gpe_set_encap_mode, "lisp|vxlan") \
23578 _(gpe_get_encap_mode, "") \
23579 _(lisp_gpe_add_del_iface, "up|down") \
23580 _(lisp_gpe_enable_disable, "enable|disable") \
23581 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23582 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23583 _(show_lisp_rloc_probe_state, "") \
23584 _(show_lisp_map_register_state, "") \
23585 _(show_lisp_status, "") \
23586 _(lisp_get_map_request_itr_rlocs, "") \
23587 _(show_lisp_pitr, "") \
23588 _(show_lisp_use_petr, "") \
23589 _(show_lisp_map_request_mode, "") \
23590 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23591 _(af_packet_delete, "name <host interface name>") \
23592 _(policer_add_del, "name <policer name> <params> [del]") \
23593 _(policer_dump, "[name <policer name>]") \
23594 _(policer_classify_set_interface, \
23595 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23596 " [l2-table <nn>] [del]") \
23597 _(policer_classify_dump, "type [ip4|ip6|l2]") \
23598 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
23599 "[master|slave]") \
23600 _(netmap_delete, "name <interface name>") \
23601 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
23602 _(mpls_fib_dump, "") \
23603 _(classify_table_ids, "") \
23604 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
23605 _(classify_table_info, "table_id <nn>") \
23606 _(classify_session_dump, "table_id <nn>") \
23607 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
23608 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
23609 "[template_interval <nn>] [udp_checksum]") \
23610 _(ipfix_exporter_dump, "") \
23611 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
23612 _(ipfix_classify_stream_dump, "") \
23613 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
23614 _(ipfix_classify_table_dump, "") \
23615 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
23616 _(sw_interface_span_dump, "[l2]") \
23617 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
23618 _(pg_create_interface, "if_id <nn>") \
23619 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
23620 _(pg_enable_disable, "[stream <id>] disable") \
23621 _(ip_source_and_port_range_check_add_del, \
23622 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
23623 _(ip_source_and_port_range_check_interface_add_del, \
23624 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23625 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23626 _(ipsec_gre_add_del_tunnel, \
23627 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23628 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23629 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23630 _(l2_interface_pbb_tag_rewrite, \
23631 "<intfc> | sw_if_index <nn> \n" \
23632 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23633 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23634 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23635 _(flow_classify_set_interface, \
23636 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23637 _(flow_classify_dump, "type [ip4|ip6]") \
23638 _(ip_fib_dump, "") \
23639 _(ip_mfib_dump, "") \
23640 _(ip6_fib_dump, "") \
23641 _(ip6_mfib_dump, "") \
23642 _(feature_enable_disable, "arc_name <arc_name> " \
23643 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23644 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23646 _(l2_xconnect_dump, "") \
23647 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23648 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23649 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23650 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23651 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23652 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23653 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23654 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23655 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23656 _(memfd_segment_create,"size <nnn>") \
23657 _(sock_init_shm, "size <nnn>") \
23658 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23659 _(dns_enable_disable, "[enable][disable]") \
23660 _(dns_name_server_add_del, "<ip-address> [del]") \
23661 _(dns_resolve_name, "<hostname>") \
23662 _(dns_resolve_ip, "<ip4|ip6>") \
23663 _(dns_name_server_add_del, "<ip-address> [del]") \
23664 _(dns_resolve_name, "<hostname>") \
23665 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23666 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23667 _(session_rules_dump, "") \
23668 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23669 _(output_acl_set_interface, \
23670 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23671 " [l2-table <nn>] [del]") \
23673 /* List of command functions, CLI names map directly to functions */
23674 #define foreach_cli_function \
23675 _(comment, "usage: comment <ignore-rest-of-line>") \
23676 _(dump_interface_table, "usage: dump_interface_table") \
23677 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23678 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23679 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23680 _(dump_stats_table, "usage: dump_stats_table") \
23681 _(dump_macro_table, "usage: dump_macro_table ") \
23682 _(dump_node_table, "usage: dump_node_table") \
23683 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23684 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23685 _(echo, "usage: echo <message>") \
23686 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23687 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23688 _(help, "usage: help") \
23689 _(q, "usage: quit") \
23690 _(quit, "usage: quit") \
23691 _(search_node_table, "usage: search_node_table <name>...") \
23692 _(set, "usage: set <variable-name> <value>") \
23693 _(script, "usage: script <file-name>") \
23694 _(unset, "usage: unset <variable-name>")
23696 static void vl_api_##n##_t_handler_uni \
23697 (vl_api_##n##_t * mp) \
23699 vat_main_t * vam = &vat_main; \
23700 if (vam->json_output) { \
23701 vl_api_##n##_t_handler_json(mp); \
23703 vl_api_##n##_t_handler(mp); \
23706 foreach_vpe_api_reply_msg;
23707 #if VPP_API_TEST_BUILTIN == 0
23708 foreach_standalone_reply_msg;
23713 vat_api_hookup (vat_main_t * vam)
23716 vl_msg_api_set_handlers(VL_API_##N, #n, \
23717 vl_api_##n##_t_handler_uni, \
23719 vl_api_##n##_t_endian, \
23720 vl_api_##n##_t_print, \
23721 sizeof(vl_api_##n##_t), 1);
23722 foreach_vpe_api_reply_msg;
23723 #if VPP_API_TEST_BUILTIN == 0
23724 foreach_standalone_reply_msg;
23728 #if (VPP_API_TEST_BUILTIN==0)
23729 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23731 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23733 vam->function_by_name = hash_create_string (0, sizeof (uword));
23735 vam->help_by_name = hash_create_string (0, sizeof (uword));
23738 /* API messages we can send */
23739 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23740 foreach_vpe_api_msg;
23744 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23745 foreach_vpe_api_msg;
23748 /* CLI functions */
23749 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23750 foreach_cli_function;
23754 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23755 foreach_cli_function;
23759 #if VPP_API_TEST_BUILTIN
23760 static clib_error_t *
23761 vat_api_hookup_shim (vlib_main_t * vm)
23763 vat_api_hookup (&vat_main);
23767 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23771 * fd.io coding-style-patch-verification: ON
23774 * eval: (c-set-style "gnu")