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 <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/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/gre/gre.h>
29 #include <vnet/vxlan-gpe/vxlan_gpe.h>
30 #include <vnet/lisp-gpe/lisp_gpe.h>
32 #include <vpp/api/vpe_msg_enum.h>
33 #include <vnet/l2/l2_classify.h>
34 #include <vnet/l2/l2_vtr.h>
35 #include <vnet/classify/input_acl.h>
36 #include <vnet/classify/policer_classify.h>
37 #include <vnet/classify/flow_classify.h>
38 #include <vnet/mpls/mpls.h>
39 #include <vnet/ipsec/ipsec.h>
40 #include <vnet/ipsec/ikev2.h>
42 #include <vnet/map/map.h>
43 #include <vnet/cop/cop.h>
44 #include <vnet/ip/ip6_hop_by_hop.h>
45 #include <vnet/ip/ip_source_and_port_range_check.h>
46 #include <vnet/policer/xlate.h>
47 #include <vnet/span/span.h>
48 #include <vnet/policer/policer.h>
49 #include <vnet/policer/police.h>
50 #include <vnet/mfib/mfib_types.h>
52 #include "vat/json_format.h"
57 #define vl_typedefs /* define message structures */
58 #include <vpp/api/vpe_all_api_h.h>
61 /* declare message handlers for each api */
63 #define vl_endianfun /* define message structures */
64 #include <vpp/api/vpe_all_api_h.h>
67 /* instantiate all the print functions we know about */
68 #define vl_print(handle, ...)
70 #include <vpp/api/vpe_all_api_h.h>
73 #define __plugin_msg_base 0
74 #include <vlibapi/vat_helper_macros.h>
77 vat_time_now (vat_main_t * vam)
79 #if VPP_API_TEST_BUILTIN
80 return vlib_time_now (vam->vlib_main);
82 return clib_time_now (&vam->clib_time);
87 errmsg (char *fmt, ...)
89 vat_main_t *vam = &vat_main;
94 s = va_format (0, fmt, &va);
99 #if VPP_API_TEST_BUILTIN
100 vlib_cli_output (vam->vlib_main, (char *) s);
103 if (vam->ifp != stdin)
104 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
105 vam->input_line_number);
106 fformat (vam->ofp, (char *) s);
114 #if VPP_API_TEST_BUILTIN == 0
116 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
118 vat_main_t *vam = va_arg (*args, vat_main_t *);
119 u32 *result = va_arg (*args, u32 *);
123 if (!unformat (input, "%s", &if_name))
126 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
133 /* Parse an IP4 address %d.%d.%d.%d. */
135 unformat_ip4_address (unformat_input_t * input, va_list * args)
137 u8 *result = va_arg (*args, u8 *);
140 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
143 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
155 unformat_ethernet_address (unformat_input_t * input, va_list * args)
157 u8 *result = va_arg (*args, u8 *);
160 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
161 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
165 for (i = 0; i < 6; i++)
166 if (a[i] >= (1 << 8))
169 for (i = 0; i < 6; i++)
175 /* Returns ethernet type as an int in host byte order. */
177 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
180 u16 *result = va_arg (*args, u16 *);
184 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
186 if (type >= (1 << 16))
194 /* Parse an IP6 address. */
196 unformat_ip6_address (unformat_input_t * input, va_list * args)
198 ip6_address_t *result = va_arg (*args, ip6_address_t *);
200 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
201 uword c, n_colon, double_colon_index;
203 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
204 double_colon_index = ARRAY_LEN (hex_quads);
205 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
208 if (c >= '0' && c <= '9')
210 else if (c >= 'a' && c <= 'f')
211 hex_digit = c + 10 - 'a';
212 else if (c >= 'A' && c <= 'F')
213 hex_digit = c + 10 - 'A';
214 else if (c == ':' && n_colon < 2)
218 unformat_put_input (input);
222 /* Too many hex quads. */
223 if (n_hex_quads >= ARRAY_LEN (hex_quads))
228 hex_quad = (hex_quad << 4) | hex_digit;
230 /* Hex quad must fit in 16 bits. */
231 if (n_hex_digits >= 4)
238 /* Save position of :: */
241 /* More than one :: ? */
242 if (double_colon_index < ARRAY_LEN (hex_quads))
244 double_colon_index = n_hex_quads;
247 if (n_colon > 0 && n_hex_digits > 0)
249 hex_quads[n_hex_quads++] = hex_quad;
255 if (n_hex_digits > 0)
256 hex_quads[n_hex_quads++] = hex_quad;
261 /* Expand :: to appropriate number of zero hex quads. */
262 if (double_colon_index < ARRAY_LEN (hex_quads))
264 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
266 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
267 hex_quads[n_zero + i] = hex_quads[i];
269 for (i = 0; i < n_zero; i++)
270 hex_quads[double_colon_index + i] = 0;
272 n_hex_quads = ARRAY_LEN (hex_quads);
275 /* Too few hex quads given. */
276 if (n_hex_quads < ARRAY_LEN (hex_quads))
279 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
280 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
287 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
289 u32 *r = va_arg (*args, u32 *);
292 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
293 foreach_ipsec_policy_action
301 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
303 u32 *r = va_arg (*args, u32 *);
306 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
307 foreach_ipsec_crypto_alg
315 format_ipsec_crypto_alg (u8 * s, va_list * args)
317 u32 i = va_arg (*args, u32);
322 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
323 foreach_ipsec_crypto_alg
326 return format (s, "unknown");
328 return format (s, "%s", t);
332 unformat_ipsec_integ_alg (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_INTEG_ALG_##f;
338 foreach_ipsec_integ_alg
346 format_ipsec_integ_alg (u8 * s, va_list * args)
348 u32 i = va_arg (*args, u32);
353 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
354 foreach_ipsec_integ_alg
357 return format (s, "unknown");
359 return format (s, "%s", t);
363 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
365 u32 *r = va_arg (*args, u32 *);
368 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
369 foreach_ikev2_auth_method
377 unformat_ikev2_id_type (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 = IKEV2_ID_TYPE_##f;
383 foreach_ikev2_id_type
389 #else /* VPP_API_TEST_BUILTIN == 1 */
391 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
393 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
394 vnet_main_t *vnm = vnet_get_main ();
395 u32 *result = va_arg (*args, u32 *);
398 if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
401 *result = sw_if_index;
404 #endif /* VPP_API_TEST_BUILTIN */
407 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
409 u8 *r = va_arg (*args, u8 *);
411 if (unformat (input, "kbps"))
412 *r = SSE2_QOS_RATE_KBPS;
413 else if (unformat (input, "pps"))
414 *r = SSE2_QOS_RATE_PPS;
421 unformat_policer_round_type (unformat_input_t * input, va_list * args)
423 u8 *r = va_arg (*args, u8 *);
425 if (unformat (input, "closest"))
426 *r = SSE2_QOS_ROUND_TO_CLOSEST;
427 else if (unformat (input, "up"))
428 *r = SSE2_QOS_ROUND_TO_UP;
429 else if (unformat (input, "down"))
430 *r = SSE2_QOS_ROUND_TO_DOWN;
437 unformat_policer_type (unformat_input_t * input, va_list * args)
439 u8 *r = va_arg (*args, u8 *);
441 if (unformat (input, "1r2c"))
442 *r = SSE2_QOS_POLICER_TYPE_1R2C;
443 else if (unformat (input, "1r3c"))
444 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
445 else if (unformat (input, "2r3c-2698"))
446 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
447 else if (unformat (input, "2r3c-4115"))
448 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
449 else if (unformat (input, "2r3c-mef5cf1"))
450 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
457 unformat_dscp (unformat_input_t * input, va_list * va)
459 u8 *r = va_arg (*va, u8 *);
462 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
471 unformat_policer_action_type (unformat_input_t * input, va_list * va)
473 sse2_qos_pol_action_params_st *a
474 = va_arg (*va, sse2_qos_pol_action_params_st *);
476 if (unformat (input, "drop"))
477 a->action_type = SSE2_QOS_ACTION_DROP;
478 else if (unformat (input, "transmit"))
479 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
480 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
481 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
488 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
490 u32 *r = va_arg (*va, u32 *);
493 if (unformat (input, "ip4"))
494 tid = POLICER_CLASSIFY_TABLE_IP4;
495 else if (unformat (input, "ip6"))
496 tid = POLICER_CLASSIFY_TABLE_IP6;
497 else if (unformat (input, "l2"))
498 tid = POLICER_CLASSIFY_TABLE_L2;
507 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
509 u32 *r = va_arg (*va, u32 *);
512 if (unformat (input, "ip4"))
513 tid = FLOW_CLASSIFY_TABLE_IP4;
514 else if (unformat (input, "ip6"))
515 tid = FLOW_CLASSIFY_TABLE_IP6;
523 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
524 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
525 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
526 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
528 #if (VPP_API_TEST_BUILTIN==0)
530 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
532 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
533 mfib_itf_attribute_t attr;
536 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
538 if (unformat (input, mfib_itf_flag_long_names[attr]))
539 *iflags |= (1 << attr);
541 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
543 if (unformat (input, mfib_itf_flag_names[attr]))
544 *iflags |= (1 << attr);
547 return (old == *iflags ? 0 : 1);
551 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
553 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
554 mfib_entry_attribute_t attr;
557 FOR_EACH_MFIB_ATTRIBUTE (attr)
559 if (unformat (input, mfib_flag_long_names[attr]))
560 *eflags |= (1 << attr);
562 FOR_EACH_MFIB_ATTRIBUTE (attr)
564 if (unformat (input, mfib_flag_names[attr]))
565 *eflags |= (1 << attr);
568 return (old == *eflags ? 0 : 1);
572 format_ip4_address (u8 * s, va_list * args)
574 u8 *a = va_arg (*args, u8 *);
575 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
579 format_ip6_address (u8 * s, va_list * args)
581 ip6_address_t *a = va_arg (*args, ip6_address_t *);
582 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
584 i_max_n_zero = ARRAY_LEN (a->as_u16);
586 i_first_zero = i_max_n_zero;
588 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
590 u32 is_zero = a->as_u16[i] == 0;
591 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
597 if ((!is_zero && n_zeros > max_n_zeros)
598 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
600 i_max_n_zero = i_first_zero;
601 max_n_zeros = n_zeros;
602 i_first_zero = ARRAY_LEN (a->as_u16);
607 last_double_colon = 0;
608 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
610 if (i == i_max_n_zero && max_n_zeros > 1)
612 s = format (s, "::");
613 i += max_n_zeros - 1;
614 last_double_colon = 1;
618 s = format (s, "%s%x",
619 (last_double_colon || i == 0) ? "" : ":",
620 clib_net_to_host_u16 (a->as_u16[i]));
621 last_double_colon = 0;
628 /* Format an IP46 address. */
630 format_ip46_address (u8 * s, va_list * args)
632 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
633 ip46_type_t type = va_arg (*args, ip46_type_t);
639 is_ip4 = ip46_address_is_ip4 (ip46);
650 format (s, "%U", format_ip4_address, &ip46->ip4) :
651 format (s, "%U", format_ip6_address, &ip46->ip6);
655 format_ethernet_address (u8 * s, va_list * args)
657 u8 *a = va_arg (*args, u8 *);
659 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
660 a[0], a[1], a[2], a[3], a[4], a[5]);
665 increment_v4_address (ip4_address_t * a)
669 v = ntohl (a->as_u32) + 1;
670 a->as_u32 = ntohl (v);
674 increment_v6_address (ip6_address_t * a)
678 v0 = clib_net_to_host_u64 (a->as_u64[0]);
679 v1 = clib_net_to_host_u64 (a->as_u64[1]);
684 a->as_u64[0] = clib_net_to_host_u64 (v0);
685 a->as_u64[1] = clib_net_to_host_u64 (v1);
689 increment_mac_address (u64 * mac)
693 tmp = clib_net_to_host_u64 (tmp);
694 tmp += 1 << 16; /* skip unused (least significant) octets */
695 tmp = clib_host_to_net_u64 (tmp);
699 static void vl_api_create_loopback_reply_t_handler
700 (vl_api_create_loopback_reply_t * mp)
702 vat_main_t *vam = &vat_main;
703 i32 retval = ntohl (mp->retval);
705 vam->retval = retval;
706 vam->regenerate_interface_table = 1;
707 vam->sw_if_index = ntohl (mp->sw_if_index);
708 vam->result_ready = 1;
711 static void vl_api_create_loopback_reply_t_handler_json
712 (vl_api_create_loopback_reply_t * mp)
714 vat_main_t *vam = &vat_main;
715 vat_json_node_t node;
717 vat_json_init_object (&node);
718 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
719 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
721 vat_json_print (vam->ofp, &node);
722 vat_json_free (&node);
723 vam->retval = ntohl (mp->retval);
724 vam->result_ready = 1;
727 static void vl_api_create_loopback_instance_reply_t_handler
728 (vl_api_create_loopback_instance_reply_t * mp)
730 vat_main_t *vam = &vat_main;
731 i32 retval = ntohl (mp->retval);
733 vam->retval = retval;
734 vam->regenerate_interface_table = 1;
735 vam->sw_if_index = ntohl (mp->sw_if_index);
736 vam->result_ready = 1;
739 static void vl_api_create_loopback_instance_reply_t_handler_json
740 (vl_api_create_loopback_instance_reply_t * mp)
742 vat_main_t *vam = &vat_main;
743 vat_json_node_t node;
745 vat_json_init_object (&node);
746 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
747 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
749 vat_json_print (vam->ofp, &node);
750 vat_json_free (&node);
751 vam->retval = ntohl (mp->retval);
752 vam->result_ready = 1;
755 static void vl_api_af_packet_create_reply_t_handler
756 (vl_api_af_packet_create_reply_t * mp)
758 vat_main_t *vam = &vat_main;
759 i32 retval = ntohl (mp->retval);
761 vam->retval = retval;
762 vam->regenerate_interface_table = 1;
763 vam->sw_if_index = ntohl (mp->sw_if_index);
764 vam->result_ready = 1;
767 static void vl_api_af_packet_create_reply_t_handler_json
768 (vl_api_af_packet_create_reply_t * mp)
770 vat_main_t *vam = &vat_main;
771 vat_json_node_t node;
773 vat_json_init_object (&node);
774 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
775 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
777 vat_json_print (vam->ofp, &node);
778 vat_json_free (&node);
780 vam->retval = ntohl (mp->retval);
781 vam->result_ready = 1;
784 static void vl_api_create_vlan_subif_reply_t_handler
785 (vl_api_create_vlan_subif_reply_t * mp)
787 vat_main_t *vam = &vat_main;
788 i32 retval = ntohl (mp->retval);
790 vam->retval = retval;
791 vam->regenerate_interface_table = 1;
792 vam->sw_if_index = ntohl (mp->sw_if_index);
793 vam->result_ready = 1;
796 static void vl_api_create_vlan_subif_reply_t_handler_json
797 (vl_api_create_vlan_subif_reply_t * mp)
799 vat_main_t *vam = &vat_main;
800 vat_json_node_t node;
802 vat_json_init_object (&node);
803 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
804 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
806 vat_json_print (vam->ofp, &node);
807 vat_json_free (&node);
809 vam->retval = ntohl (mp->retval);
810 vam->result_ready = 1;
813 static void vl_api_create_subif_reply_t_handler
814 (vl_api_create_subif_reply_t * mp)
816 vat_main_t *vam = &vat_main;
817 i32 retval = ntohl (mp->retval);
819 vam->retval = retval;
820 vam->regenerate_interface_table = 1;
821 vam->sw_if_index = ntohl (mp->sw_if_index);
822 vam->result_ready = 1;
825 static void vl_api_create_subif_reply_t_handler_json
826 (vl_api_create_subif_reply_t * mp)
828 vat_main_t *vam = &vat_main;
829 vat_json_node_t node;
831 vat_json_init_object (&node);
832 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
833 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
835 vat_json_print (vam->ofp, &node);
836 vat_json_free (&node);
838 vam->retval = ntohl (mp->retval);
839 vam->result_ready = 1;
842 static void vl_api_interface_name_renumber_reply_t_handler
843 (vl_api_interface_name_renumber_reply_t * mp)
845 vat_main_t *vam = &vat_main;
846 i32 retval = ntohl (mp->retval);
848 vam->retval = retval;
849 vam->regenerate_interface_table = 1;
850 vam->result_ready = 1;
853 static void vl_api_interface_name_renumber_reply_t_handler_json
854 (vl_api_interface_name_renumber_reply_t * mp)
856 vat_main_t *vam = &vat_main;
857 vat_json_node_t node;
859 vat_json_init_object (&node);
860 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
862 vat_json_print (vam->ofp, &node);
863 vat_json_free (&node);
865 vam->retval = ntohl (mp->retval);
866 vam->result_ready = 1;
870 * Special-case: build the interface table, maintain
871 * the next loopback sw_if_index vbl.
873 static void vl_api_sw_interface_details_t_handler
874 (vl_api_sw_interface_details_t * mp)
876 vat_main_t *vam = &vat_main;
877 u8 *s = format (0, "%s%c", mp->interface_name, 0);
879 hash_set_mem (vam->sw_if_index_by_interface_name, s,
880 ntohl (mp->sw_if_index));
882 /* In sub interface case, fill the sub interface table entry */
883 if (mp->sw_if_index != mp->sup_sw_if_index)
885 sw_interface_subif_t *sub = NULL;
887 vec_add2 (vam->sw_if_subif_table, sub, 1);
889 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
890 strncpy ((char *) sub->interface_name, (char *) s,
891 vec_len (sub->interface_name));
892 sub->sw_if_index = ntohl (mp->sw_if_index);
893 sub->sub_id = ntohl (mp->sub_id);
895 sub->sub_dot1ad = mp->sub_dot1ad;
896 sub->sub_number_of_tags = mp->sub_number_of_tags;
897 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
898 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
899 sub->sub_exact_match = mp->sub_exact_match;
900 sub->sub_default = mp->sub_default;
901 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
902 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
904 /* vlan tag rewrite */
905 sub->vtr_op = ntohl (mp->vtr_op);
906 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
907 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
908 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
912 static void vl_api_sw_interface_details_t_handler_json
913 (vl_api_sw_interface_details_t * mp)
915 vat_main_t *vam = &vat_main;
916 vat_json_node_t *node = NULL;
918 if (VAT_JSON_ARRAY != vam->json_tree.type)
920 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
921 vat_json_init_array (&vam->json_tree);
923 node = vat_json_array_add (&vam->json_tree);
925 vat_json_init_object (node);
926 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
927 vat_json_object_add_uint (node, "sup_sw_if_index",
928 ntohl (mp->sup_sw_if_index));
929 vat_json_object_add_uint (node, "l2_address_length",
930 ntohl (mp->l2_address_length));
931 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
932 sizeof (mp->l2_address));
933 vat_json_object_add_string_copy (node, "interface_name",
935 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
936 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
937 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
938 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
939 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
940 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
941 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
942 vat_json_object_add_uint (node, "sub_number_of_tags",
943 mp->sub_number_of_tags);
944 vat_json_object_add_uint (node, "sub_outer_vlan_id",
945 ntohs (mp->sub_outer_vlan_id));
946 vat_json_object_add_uint (node, "sub_inner_vlan_id",
947 ntohs (mp->sub_inner_vlan_id));
948 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
949 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
950 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
951 mp->sub_outer_vlan_id_any);
952 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
953 mp->sub_inner_vlan_id_any);
954 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
955 vat_json_object_add_uint (node, "vtr_push_dot1q",
956 ntohl (mp->vtr_push_dot1q));
957 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
958 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
961 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
963 format_ethernet_address,
965 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
967 format_ethernet_address,
969 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
970 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
974 #if VPP_API_TEST_BUILTIN == 0
975 static void vl_api_sw_interface_event_t_handler
976 (vl_api_sw_interface_event_t * mp)
978 vat_main_t *vam = &vat_main;
979 if (vam->interface_event_display)
980 errmsg ("interface flags: sw_if_index %d %s %s",
981 ntohl (mp->sw_if_index),
982 mp->admin_up_down ? "admin-up" : "admin-down",
983 mp->link_up_down ? "link-up" : "link-down");
987 static void vl_api_sw_interface_event_t_handler_json
988 (vl_api_sw_interface_event_t * mp)
990 /* JSON output not supported */
994 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
996 vat_main_t *vam = &vat_main;
997 i32 retval = ntohl (mp->retval);
999 vam->retval = retval;
1000 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1001 vam->result_ready = 1;
1005 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1007 vat_main_t *vam = &vat_main;
1008 vat_json_node_t node;
1009 api_main_t *am = &api_main;
1013 vat_json_init_object (&node);
1014 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1015 vat_json_object_add_uint (&node, "reply_in_shmem",
1016 ntohl (mp->reply_in_shmem));
1017 /* Toss the shared-memory original... */
1018 pthread_mutex_lock (&am->vlib_rp->mutex);
1019 oldheap = svm_push_data_heap (am->vlib_rp);
1021 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1024 svm_pop_heap (oldheap);
1025 pthread_mutex_unlock (&am->vlib_rp->mutex);
1027 vat_json_print (vam->ofp, &node);
1028 vat_json_free (&node);
1030 vam->retval = ntohl (mp->retval);
1031 vam->result_ready = 1;
1035 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1037 vat_main_t *vam = &vat_main;
1038 i32 retval = ntohl (mp->retval);
1040 vam->retval = retval;
1041 vam->cmd_reply = mp->reply;
1042 vam->result_ready = 1;
1046 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1048 vat_main_t *vam = &vat_main;
1049 vat_json_node_t node;
1051 vat_json_init_object (&node);
1052 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1053 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1055 vat_json_print (vam->ofp, &node);
1056 vat_json_free (&node);
1058 vam->retval = ntohl (mp->retval);
1059 vam->result_ready = 1;
1062 static void vl_api_classify_add_del_table_reply_t_handler
1063 (vl_api_classify_add_del_table_reply_t * mp)
1065 vat_main_t *vam = &vat_main;
1066 i32 retval = ntohl (mp->retval);
1067 if (vam->async_mode)
1069 vam->async_errors += (retval < 0);
1073 vam->retval = retval;
1075 ((mp->new_table_index != 0xFFFFFFFF) ||
1076 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1077 (mp->match_n_vectors != 0xFFFFFFFF)))
1079 * Note: this is just barely thread-safe, depends on
1080 * the main thread spinning waiting for an answer...
1082 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1083 ntohl (mp->new_table_index),
1084 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1085 vam->result_ready = 1;
1089 static void vl_api_classify_add_del_table_reply_t_handler_json
1090 (vl_api_classify_add_del_table_reply_t * mp)
1092 vat_main_t *vam = &vat_main;
1093 vat_json_node_t node;
1095 vat_json_init_object (&node);
1096 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1097 vat_json_object_add_uint (&node, "new_table_index",
1098 ntohl (mp->new_table_index));
1099 vat_json_object_add_uint (&node, "skip_n_vectors",
1100 ntohl (mp->skip_n_vectors));
1101 vat_json_object_add_uint (&node, "match_n_vectors",
1102 ntohl (mp->match_n_vectors));
1104 vat_json_print (vam->ofp, &node);
1105 vat_json_free (&node);
1107 vam->retval = ntohl (mp->retval);
1108 vam->result_ready = 1;
1111 static void vl_api_get_node_index_reply_t_handler
1112 (vl_api_get_node_index_reply_t * mp)
1114 vat_main_t *vam = &vat_main;
1115 i32 retval = ntohl (mp->retval);
1116 if (vam->async_mode)
1118 vam->async_errors += (retval < 0);
1122 vam->retval = retval;
1124 errmsg ("node index %d", ntohl (mp->node_index));
1125 vam->result_ready = 1;
1129 static void vl_api_get_node_index_reply_t_handler_json
1130 (vl_api_get_node_index_reply_t * mp)
1132 vat_main_t *vam = &vat_main;
1133 vat_json_node_t node;
1135 vat_json_init_object (&node);
1136 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1137 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1139 vat_json_print (vam->ofp, &node);
1140 vat_json_free (&node);
1142 vam->retval = ntohl (mp->retval);
1143 vam->result_ready = 1;
1146 static void vl_api_get_next_index_reply_t_handler
1147 (vl_api_get_next_index_reply_t * mp)
1149 vat_main_t *vam = &vat_main;
1150 i32 retval = ntohl (mp->retval);
1151 if (vam->async_mode)
1153 vam->async_errors += (retval < 0);
1157 vam->retval = retval;
1159 errmsg ("next node index %d", ntohl (mp->next_index));
1160 vam->result_ready = 1;
1164 static void vl_api_get_next_index_reply_t_handler_json
1165 (vl_api_get_next_index_reply_t * mp)
1167 vat_main_t *vam = &vat_main;
1168 vat_json_node_t node;
1170 vat_json_init_object (&node);
1171 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1172 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1174 vat_json_print (vam->ofp, &node);
1175 vat_json_free (&node);
1177 vam->retval = ntohl (mp->retval);
1178 vam->result_ready = 1;
1181 static void vl_api_add_node_next_reply_t_handler
1182 (vl_api_add_node_next_reply_t * mp)
1184 vat_main_t *vam = &vat_main;
1185 i32 retval = ntohl (mp->retval);
1186 if (vam->async_mode)
1188 vam->async_errors += (retval < 0);
1192 vam->retval = retval;
1194 errmsg ("next index %d", ntohl (mp->next_index));
1195 vam->result_ready = 1;
1199 static void vl_api_add_node_next_reply_t_handler_json
1200 (vl_api_add_node_next_reply_t * mp)
1202 vat_main_t *vam = &vat_main;
1203 vat_json_node_t node;
1205 vat_json_init_object (&node);
1206 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1207 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1209 vat_json_print (vam->ofp, &node);
1210 vat_json_free (&node);
1212 vam->retval = ntohl (mp->retval);
1213 vam->result_ready = 1;
1216 static void vl_api_show_version_reply_t_handler
1217 (vl_api_show_version_reply_t * mp)
1219 vat_main_t *vam = &vat_main;
1220 i32 retval = ntohl (mp->retval);
1224 errmsg (" program: %s", mp->program);
1225 errmsg (" version: %s", mp->version);
1226 errmsg (" build date: %s", mp->build_date);
1227 errmsg ("build directory: %s", mp->build_directory);
1229 vam->retval = retval;
1230 vam->result_ready = 1;
1233 static void vl_api_show_version_reply_t_handler_json
1234 (vl_api_show_version_reply_t * mp)
1236 vat_main_t *vam = &vat_main;
1237 vat_json_node_t node;
1239 vat_json_init_object (&node);
1240 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1241 vat_json_object_add_string_copy (&node, "program", mp->program);
1242 vat_json_object_add_string_copy (&node, "version", mp->version);
1243 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1244 vat_json_object_add_string_copy (&node, "build_directory",
1245 mp->build_directory);
1247 vat_json_print (vam->ofp, &node);
1248 vat_json_free (&node);
1250 vam->retval = ntohl (mp->retval);
1251 vam->result_ready = 1;
1255 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1257 u32 sw_if_index = ntohl (mp->sw_if_index);
1258 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1259 mp->mac_ip ? "mac/ip binding" : "address resolution",
1260 ntohl (mp->pid), format_ip4_address, &mp->address,
1261 format_ethernet_address, mp->new_mac, sw_if_index);
1265 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1267 /* JSON output not supported */
1271 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1273 u32 sw_if_index = ntohl (mp->sw_if_index);
1274 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1275 mp->mac_ip ? "mac/ip binding" : "address resolution",
1276 ntohl (mp->pid), format_ip6_address, mp->address,
1277 format_ethernet_address, mp->new_mac, sw_if_index);
1281 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1283 /* JSON output not supported */
1287 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1289 u32 n_macs = ntohl (mp->n_macs);
1290 errmsg ("L2MAC event recived with pid %d cl-idx %d for %d macs: \n",
1291 ntohl (mp->pid), mp->client_index, n_macs);
1293 for (i = 0; i < n_macs; i++)
1295 vl_api_mac_entry_t *mac = &mp->mac[i];
1296 errmsg (" [%d] sw_if_index %d mac_addr %U is_del %d \n",
1297 i + 1, ntohl (mac->sw_if_index),
1298 format_ethernet_address, mac->mac_addr, mac->is_del);
1305 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1307 /* JSON output not supported */
1310 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1311 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1314 * Special-case: build the bridge domain table, maintain
1315 * the next bd id vbl.
1317 static void vl_api_bridge_domain_details_t_handler
1318 (vl_api_bridge_domain_details_t * mp)
1320 vat_main_t *vam = &vat_main;
1321 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1324 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1325 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1327 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1328 ntohl (mp->bd_id), mp->learn, mp->forward,
1329 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1333 vl_api_bridge_domain_sw_if_t *sw_ifs;
1334 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1337 sw_ifs = mp->sw_if_details;
1338 for (i = 0; i < n_sw_ifs; i++)
1344 sw_if_index = ntohl (sw_ifs->sw_if_index);
1347 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1349 if ((u32) p->value[0] == sw_if_index)
1351 sw_if_name = (u8 *)(p->key);
1356 print (vam->ofp, "%7d %3d %s", sw_if_index,
1357 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1358 "sw_if_index not found!");
1365 static void vl_api_bridge_domain_details_t_handler_json
1366 (vl_api_bridge_domain_details_t * mp)
1368 vat_main_t *vam = &vat_main;
1369 vat_json_node_t *node, *array = NULL;
1370 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1372 if (VAT_JSON_ARRAY != vam->json_tree.type)
1374 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1375 vat_json_init_array (&vam->json_tree);
1377 node = vat_json_array_add (&vam->json_tree);
1379 vat_json_init_object (node);
1380 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1381 vat_json_object_add_uint (node, "flood", mp->flood);
1382 vat_json_object_add_uint (node, "forward", mp->forward);
1383 vat_json_object_add_uint (node, "learn", mp->learn);
1384 vat_json_object_add_uint (node, "bvi_sw_if_index",
1385 ntohl (mp->bvi_sw_if_index));
1386 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1387 array = vat_json_object_add (node, "sw_if");
1388 vat_json_init_array (array);
1394 vl_api_bridge_domain_sw_if_t *sw_ifs;
1397 sw_ifs = mp->sw_if_details;
1398 for (i = 0; i < n_sw_ifs; i++)
1400 node = vat_json_array_add (array);
1401 vat_json_init_object (node);
1402 vat_json_object_add_uint (node, "sw_if_index",
1403 ntohl (sw_ifs->sw_if_index));
1404 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1410 static void vl_api_control_ping_reply_t_handler
1411 (vl_api_control_ping_reply_t * mp)
1413 vat_main_t *vam = &vat_main;
1414 i32 retval = ntohl (mp->retval);
1415 if (vam->async_mode)
1417 vam->async_errors += (retval < 0);
1421 vam->retval = retval;
1422 vam->result_ready = 1;
1426 static void vl_api_control_ping_reply_t_handler_json
1427 (vl_api_control_ping_reply_t * mp)
1429 vat_main_t *vam = &vat_main;
1430 i32 retval = ntohl (mp->retval);
1432 if (VAT_JSON_NONE != vam->json_tree.type)
1434 vat_json_print (vam->ofp, &vam->json_tree);
1435 vat_json_free (&vam->json_tree);
1436 vam->json_tree.type = VAT_JSON_NONE;
1441 vat_json_init_array (&vam->json_tree);
1442 vat_json_print (vam->ofp, &vam->json_tree);
1443 vam->json_tree.type = VAT_JSON_NONE;
1446 vam->retval = retval;
1447 vam->result_ready = 1;
1451 vl_api_bridge_domain_set_mac_age_reply_t_handler
1452 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1454 vat_main_t *vam = &vat_main;
1455 i32 retval = ntohl (mp->retval);
1456 if (vam->async_mode)
1458 vam->async_errors += (retval < 0);
1462 vam->retval = retval;
1463 vam->result_ready = 1;
1467 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1468 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1470 vat_main_t *vam = &vat_main;
1471 vat_json_node_t node;
1473 vat_json_init_object (&node);
1474 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1476 vat_json_print (vam->ofp, &node);
1477 vat_json_free (&node);
1479 vam->retval = ntohl (mp->retval);
1480 vam->result_ready = 1;
1484 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1486 vat_main_t *vam = &vat_main;
1487 i32 retval = ntohl (mp->retval);
1488 if (vam->async_mode)
1490 vam->async_errors += (retval < 0);
1494 vam->retval = retval;
1495 vam->result_ready = 1;
1499 static void vl_api_l2_flags_reply_t_handler_json
1500 (vl_api_l2_flags_reply_t * mp)
1502 vat_main_t *vam = &vat_main;
1503 vat_json_node_t node;
1505 vat_json_init_object (&node);
1506 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1507 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1508 ntohl (mp->resulting_feature_bitmap));
1510 vat_json_print (vam->ofp, &node);
1511 vat_json_free (&node);
1513 vam->retval = ntohl (mp->retval);
1514 vam->result_ready = 1;
1517 static void vl_api_bridge_flags_reply_t_handler
1518 (vl_api_bridge_flags_reply_t * mp)
1520 vat_main_t *vam = &vat_main;
1521 i32 retval = ntohl (mp->retval);
1522 if (vam->async_mode)
1524 vam->async_errors += (retval < 0);
1528 vam->retval = retval;
1529 vam->result_ready = 1;
1533 static void vl_api_bridge_flags_reply_t_handler_json
1534 (vl_api_bridge_flags_reply_t * mp)
1536 vat_main_t *vam = &vat_main;
1537 vat_json_node_t node;
1539 vat_json_init_object (&node);
1540 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1541 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1542 ntohl (mp->resulting_feature_bitmap));
1544 vat_json_print (vam->ofp, &node);
1545 vat_json_free (&node);
1547 vam->retval = ntohl (mp->retval);
1548 vam->result_ready = 1;
1551 static void vl_api_tap_connect_reply_t_handler
1552 (vl_api_tap_connect_reply_t * mp)
1554 vat_main_t *vam = &vat_main;
1555 i32 retval = ntohl (mp->retval);
1556 if (vam->async_mode)
1558 vam->async_errors += (retval < 0);
1562 vam->retval = retval;
1563 vam->sw_if_index = ntohl (mp->sw_if_index);
1564 vam->result_ready = 1;
1569 static void vl_api_tap_connect_reply_t_handler_json
1570 (vl_api_tap_connect_reply_t * mp)
1572 vat_main_t *vam = &vat_main;
1573 vat_json_node_t node;
1575 vat_json_init_object (&node);
1576 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1577 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1579 vat_json_print (vam->ofp, &node);
1580 vat_json_free (&node);
1582 vam->retval = ntohl (mp->retval);
1583 vam->result_ready = 1;
1588 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1590 vat_main_t *vam = &vat_main;
1591 i32 retval = ntohl (mp->retval);
1592 if (vam->async_mode)
1594 vam->async_errors += (retval < 0);
1598 vam->retval = retval;
1599 vam->sw_if_index = ntohl (mp->sw_if_index);
1600 vam->result_ready = 1;
1604 static void vl_api_tap_modify_reply_t_handler_json
1605 (vl_api_tap_modify_reply_t * mp)
1607 vat_main_t *vam = &vat_main;
1608 vat_json_node_t node;
1610 vat_json_init_object (&node);
1611 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1612 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1614 vat_json_print (vam->ofp, &node);
1615 vat_json_free (&node);
1617 vam->retval = ntohl (mp->retval);
1618 vam->result_ready = 1;
1622 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1624 vat_main_t *vam = &vat_main;
1625 i32 retval = ntohl (mp->retval);
1626 if (vam->async_mode)
1628 vam->async_errors += (retval < 0);
1632 vam->retval = retval;
1633 vam->result_ready = 1;
1637 static void vl_api_tap_delete_reply_t_handler_json
1638 (vl_api_tap_delete_reply_t * mp)
1640 vat_main_t *vam = &vat_main;
1641 vat_json_node_t node;
1643 vat_json_init_object (&node);
1644 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1646 vat_json_print (vam->ofp, &node);
1647 vat_json_free (&node);
1649 vam->retval = ntohl (mp->retval);
1650 vam->result_ready = 1;
1653 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1654 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1656 vat_main_t *vam = &vat_main;
1657 i32 retval = ntohl (mp->retval);
1658 if (vam->async_mode)
1660 vam->async_errors += (retval < 0);
1664 vam->retval = retval;
1665 vam->result_ready = 1;
1669 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1670 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1672 vat_main_t *vam = &vat_main;
1673 vat_json_node_t node;
1675 vat_json_init_object (&node);
1676 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1677 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1678 ntohl (mp->sw_if_index));
1680 vat_json_print (vam->ofp, &node);
1681 vat_json_free (&node);
1683 vam->retval = ntohl (mp->retval);
1684 vam->result_ready = 1;
1687 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1688 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1690 vat_main_t *vam = &vat_main;
1691 i32 retval = ntohl (mp->retval);
1692 if (vam->async_mode)
1694 vam->async_errors += (retval < 0);
1698 vam->retval = retval;
1699 vam->sw_if_index = ntohl (mp->sw_if_index);
1700 vam->result_ready = 1;
1704 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1705 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1707 vat_main_t *vam = &vat_main;
1708 vat_json_node_t node;
1710 vat_json_init_object (&node);
1711 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1712 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1714 vat_json_print (vam->ofp, &node);
1715 vat_json_free (&node);
1717 vam->retval = ntohl (mp->retval);
1718 vam->result_ready = 1;
1721 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
1722 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1724 vat_main_t *vam = &vat_main;
1725 i32 retval = ntohl (mp->retval);
1726 if (vam->async_mode)
1728 vam->async_errors += (retval < 0);
1732 vam->retval = retval;
1733 vam->result_ready = 1;
1737 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
1738 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1740 vat_main_t *vam = &vat_main;
1741 vat_json_node_t node;
1743 vat_json_init_object (&node);
1744 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1745 vat_json_object_add_uint (&node, "fwd_entry_index",
1746 clib_net_to_host_u32 (mp->fwd_entry_index));
1748 vat_json_print (vam->ofp, &node);
1749 vat_json_free (&node);
1751 vam->retval = ntohl (mp->retval);
1752 vam->result_ready = 1;
1755 static void vl_api_one_add_del_locator_set_reply_t_handler
1756 (vl_api_one_add_del_locator_set_reply_t * mp)
1758 vat_main_t *vam = &vat_main;
1759 i32 retval = ntohl (mp->retval);
1760 if (vam->async_mode)
1762 vam->async_errors += (retval < 0);
1766 vam->retval = retval;
1767 vam->result_ready = 1;
1771 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1772 (vl_api_one_add_del_locator_set_reply_t * mp)
1774 vat_main_t *vam = &vat_main;
1775 vat_json_node_t node;
1777 vat_json_init_object (&node);
1778 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1779 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1781 vat_json_print (vam->ofp, &node);
1782 vat_json_free (&node);
1784 vam->retval = ntohl (mp->retval);
1785 vam->result_ready = 1;
1788 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1789 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1791 vat_main_t *vam = &vat_main;
1792 i32 retval = ntohl (mp->retval);
1793 if (vam->async_mode)
1795 vam->async_errors += (retval < 0);
1799 vam->retval = retval;
1800 vam->sw_if_index = ntohl (mp->sw_if_index);
1801 vam->result_ready = 1;
1805 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1806 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1808 vat_main_t *vam = &vat_main;
1809 vat_json_node_t node;
1811 vat_json_init_object (&node);
1812 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1813 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1815 vat_json_print (vam->ofp, &node);
1816 vat_json_free (&node);
1818 vam->retval = ntohl (mp->retval);
1819 vam->result_ready = 1;
1822 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
1823 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
1825 vat_main_t *vam = &vat_main;
1826 i32 retval = ntohl (mp->retval);
1827 if (vam->async_mode)
1829 vam->async_errors += (retval < 0);
1833 vam->retval = retval;
1834 vam->sw_if_index = ntohl (mp->sw_if_index);
1835 vam->result_ready = 1;
1839 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
1840 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
1842 vat_main_t *vam = &vat_main;
1843 vat_json_node_t node;
1845 vat_json_init_object (&node);
1846 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1847 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1849 vat_json_print (vam->ofp, &node);
1850 vat_json_free (&node);
1852 vam->retval = ntohl (mp->retval);
1853 vam->result_ready = 1;
1856 static void vl_api_gre_add_del_tunnel_reply_t_handler
1857 (vl_api_gre_add_del_tunnel_reply_t * mp)
1859 vat_main_t *vam = &vat_main;
1860 i32 retval = ntohl (mp->retval);
1861 if (vam->async_mode)
1863 vam->async_errors += (retval < 0);
1867 vam->retval = retval;
1868 vam->sw_if_index = ntohl (mp->sw_if_index);
1869 vam->result_ready = 1;
1873 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1874 (vl_api_gre_add_del_tunnel_reply_t * mp)
1876 vat_main_t *vam = &vat_main;
1877 vat_json_node_t node;
1879 vat_json_init_object (&node);
1880 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1881 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1883 vat_json_print (vam->ofp, &node);
1884 vat_json_free (&node);
1886 vam->retval = ntohl (mp->retval);
1887 vam->result_ready = 1;
1890 static void vl_api_create_vhost_user_if_reply_t_handler
1891 (vl_api_create_vhost_user_if_reply_t * mp)
1893 vat_main_t *vam = &vat_main;
1894 i32 retval = ntohl (mp->retval);
1895 if (vam->async_mode)
1897 vam->async_errors += (retval < 0);
1901 vam->retval = retval;
1902 vam->sw_if_index = ntohl (mp->sw_if_index);
1903 vam->result_ready = 1;
1907 static void vl_api_create_vhost_user_if_reply_t_handler_json
1908 (vl_api_create_vhost_user_if_reply_t * mp)
1910 vat_main_t *vam = &vat_main;
1911 vat_json_node_t node;
1913 vat_json_init_object (&node);
1914 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1915 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1917 vat_json_print (vam->ofp, &node);
1918 vat_json_free (&node);
1920 vam->retval = ntohl (mp->retval);
1921 vam->result_ready = 1;
1924 static void vl_api_ip_address_details_t_handler
1925 (vl_api_ip_address_details_t * mp)
1927 vat_main_t *vam = &vat_main;
1928 static ip_address_details_t empty_ip_address_details = { {0} };
1929 ip_address_details_t *address = NULL;
1930 ip_details_t *current_ip_details = NULL;
1931 ip_details_t *details = NULL;
1933 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1935 if (!details || vam->current_sw_if_index >= vec_len (details)
1936 || !details[vam->current_sw_if_index].present)
1938 errmsg ("ip address details arrived but not stored");
1939 errmsg ("ip_dump should be called first");
1943 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1945 #define addresses (current_ip_details->addr)
1947 vec_validate_init_empty (addresses, vec_len (addresses),
1948 empty_ip_address_details);
1950 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1952 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1953 address->prefix_length = mp->prefix_length;
1957 static void vl_api_ip_address_details_t_handler_json
1958 (vl_api_ip_address_details_t * mp)
1960 vat_main_t *vam = &vat_main;
1961 vat_json_node_t *node = NULL;
1962 struct in6_addr ip6;
1965 if (VAT_JSON_ARRAY != vam->json_tree.type)
1967 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1968 vat_json_init_array (&vam->json_tree);
1970 node = vat_json_array_add (&vam->json_tree);
1972 vat_json_init_object (node);
1975 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1976 vat_json_object_add_ip6 (node, "ip", ip6);
1980 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1981 vat_json_object_add_ip4 (node, "ip", ip4);
1983 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1987 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1989 vat_main_t *vam = &vat_main;
1990 static ip_details_t empty_ip_details = { 0 };
1991 ip_details_t *ip = NULL;
1992 u32 sw_if_index = ~0;
1994 sw_if_index = ntohl (mp->sw_if_index);
1996 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1997 sw_if_index, empty_ip_details);
1999 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2006 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2008 vat_main_t *vam = &vat_main;
2010 if (VAT_JSON_ARRAY != vam->json_tree.type)
2012 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2013 vat_json_init_array (&vam->json_tree);
2015 vat_json_array_add_uint (&vam->json_tree,
2016 clib_net_to_host_u32 (mp->sw_if_index));
2019 static void vl_api_map_domain_details_t_handler_json
2020 (vl_api_map_domain_details_t * mp)
2022 vat_json_node_t *node = NULL;
2023 vat_main_t *vam = &vat_main;
2024 struct in6_addr ip6;
2027 if (VAT_JSON_ARRAY != vam->json_tree.type)
2029 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2030 vat_json_init_array (&vam->json_tree);
2033 node = vat_json_array_add (&vam->json_tree);
2034 vat_json_init_object (node);
2036 vat_json_object_add_uint (node, "domain_index",
2037 clib_net_to_host_u32 (mp->domain_index));
2038 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
2039 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
2040 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
2041 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
2042 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
2043 vat_json_object_add_ip6 (node, "ip6_src", ip6);
2044 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
2045 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
2046 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
2047 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
2048 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
2049 vat_json_object_add_int (node, "psid_length", mp->psid_length);
2050 vat_json_object_add_uint (node, "flags", mp->flags);
2051 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
2052 vat_json_object_add_int (node, "is_translation", mp->is_translation);
2055 static void vl_api_map_domain_details_t_handler
2056 (vl_api_map_domain_details_t * mp)
2058 vat_main_t *vam = &vat_main;
2060 if (mp->is_translation)
2063 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2064 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2065 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2066 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2067 clib_net_to_host_u32 (mp->domain_index));
2072 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2073 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2074 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2075 format_ip6_address, mp->ip6_src,
2076 clib_net_to_host_u32 (mp->domain_index));
2078 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2079 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2080 mp->is_translation ? "map-t" : "");
2083 static void vl_api_map_rule_details_t_handler_json
2084 (vl_api_map_rule_details_t * mp)
2086 struct in6_addr ip6;
2087 vat_json_node_t *node = NULL;
2088 vat_main_t *vam = &vat_main;
2090 if (VAT_JSON_ARRAY != vam->json_tree.type)
2092 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2093 vat_json_init_array (&vam->json_tree);
2096 node = vat_json_array_add (&vam->json_tree);
2097 vat_json_init_object (node);
2099 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2100 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2101 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2105 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2107 vat_main_t *vam = &vat_main;
2108 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2109 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2113 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2115 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2116 "router_addr %U host_mac %U",
2117 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2118 format_ip4_address, &mp->host_address,
2119 format_ip4_address, &mp->router_address,
2120 format_ethernet_address, mp->host_mac);
2123 static void vl_api_dhcp_compl_event_t_handler_json
2124 (vl_api_dhcp_compl_event_t * mp)
2126 /* JSON output not supported */
2130 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2133 vat_main_t *vam = &vat_main;
2134 static u64 default_counter = 0;
2136 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2138 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2139 sw_if_index, default_counter);
2140 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2144 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2145 interface_counter_t counter)
2147 vat_main_t *vam = &vat_main;
2148 static interface_counter_t default_counter = { 0, };
2150 vec_validate_init_empty (vam->combined_interface_counters,
2151 vnet_counter_type, NULL);
2152 vec_validate_init_empty (vam->combined_interface_counters
2153 [vnet_counter_type], sw_if_index, default_counter);
2154 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2157 static void vl_api_vnet_interface_simple_counters_t_handler
2158 (vl_api_vnet_interface_simple_counters_t * mp)
2163 static void vl_api_vnet_interface_combined_counters_t_handler
2164 (vl_api_vnet_interface_combined_counters_t * mp)
2169 static void vl_api_vnet_interface_simple_counters_t_handler_json
2170 (vl_api_vnet_interface_simple_counters_t * mp)
2175 u32 first_sw_if_index;
2178 count = ntohl (mp->count);
2179 first_sw_if_index = ntohl (mp->first_sw_if_index);
2181 v_packets = (u64 *) & mp->data;
2182 for (i = 0; i < count; i++)
2184 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2185 set_simple_interface_counter (mp->vnet_counter_type,
2186 first_sw_if_index + i, packets);
2191 static void vl_api_vnet_interface_combined_counters_t_handler_json
2192 (vl_api_vnet_interface_combined_counters_t * mp)
2194 interface_counter_t counter;
2196 u32 first_sw_if_index;
2200 count = ntohl (mp->count);
2201 first_sw_if_index = ntohl (mp->first_sw_if_index);
2203 v = (vlib_counter_t *) & mp->data;
2204 for (i = 0; i < count; i++)
2207 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2209 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2210 set_combined_interface_counter (mp->vnet_counter_type,
2211 first_sw_if_index + i, counter);
2217 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2219 vat_main_t *vam = &vat_main;
2222 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2224 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2233 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2235 vat_main_t *vam = &vat_main;
2238 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2240 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2248 static void vl_api_vnet_ip4_fib_counters_t_handler
2249 (vl_api_vnet_ip4_fib_counters_t * mp)
2254 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2255 (vl_api_vnet_ip4_fib_counters_t * mp)
2257 vat_main_t *vam = &vat_main;
2258 vl_api_ip4_fib_counter_t *v;
2259 ip4_fib_counter_t *counter;
2266 vrf_id = ntohl (mp->vrf_id);
2267 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2268 if (~0 == vrf_index)
2270 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2271 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2272 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2273 vec_validate (vam->ip4_fib_counters, vrf_index);
2274 vam->ip4_fib_counters[vrf_index] = NULL;
2277 vec_free (vam->ip4_fib_counters[vrf_index]);
2278 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2279 count = ntohl (mp->count);
2280 for (i = 0; i < count; i++)
2282 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2283 counter = &vam->ip4_fib_counters[vrf_index][i];
2284 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2285 counter->address = ip4;
2286 counter->address_length = v->address_length;
2287 counter->packets = clib_net_to_host_u64 (v->packets);
2288 counter->bytes = clib_net_to_host_u64 (v->bytes);
2293 static void vl_api_vnet_ip4_nbr_counters_t_handler
2294 (vl_api_vnet_ip4_nbr_counters_t * mp)
2299 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2300 (vl_api_vnet_ip4_nbr_counters_t * mp)
2302 vat_main_t *vam = &vat_main;
2303 vl_api_ip4_nbr_counter_t *v;
2304 ip4_nbr_counter_t *counter;
2309 sw_if_index = ntohl (mp->sw_if_index);
2310 count = ntohl (mp->count);
2311 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2314 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2316 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2317 for (i = 0; i < count; i++)
2319 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2320 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2321 counter->address.s_addr = v->address;
2322 counter->packets = clib_net_to_host_u64 (v->packets);
2323 counter->bytes = clib_net_to_host_u64 (v->bytes);
2324 counter->linkt = v->link_type;
2329 static void vl_api_vnet_ip6_fib_counters_t_handler
2330 (vl_api_vnet_ip6_fib_counters_t * mp)
2335 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2336 (vl_api_vnet_ip6_fib_counters_t * mp)
2338 vat_main_t *vam = &vat_main;
2339 vl_api_ip6_fib_counter_t *v;
2340 ip6_fib_counter_t *counter;
2341 struct in6_addr ip6;
2347 vrf_id = ntohl (mp->vrf_id);
2348 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2349 if (~0 == vrf_index)
2351 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2352 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2353 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2354 vec_validate (vam->ip6_fib_counters, vrf_index);
2355 vam->ip6_fib_counters[vrf_index] = NULL;
2358 vec_free (vam->ip6_fib_counters[vrf_index]);
2359 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2360 count = ntohl (mp->count);
2361 for (i = 0; i < count; i++)
2363 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2364 counter = &vam->ip6_fib_counters[vrf_index][i];
2365 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2366 counter->address = ip6;
2367 counter->address_length = v->address_length;
2368 counter->packets = clib_net_to_host_u64 (v->packets);
2369 counter->bytes = clib_net_to_host_u64 (v->bytes);
2374 static void vl_api_vnet_ip6_nbr_counters_t_handler
2375 (vl_api_vnet_ip6_nbr_counters_t * mp)
2380 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2381 (vl_api_vnet_ip6_nbr_counters_t * mp)
2383 vat_main_t *vam = &vat_main;
2384 vl_api_ip6_nbr_counter_t *v;
2385 ip6_nbr_counter_t *counter;
2386 struct in6_addr ip6;
2391 sw_if_index = ntohl (mp->sw_if_index);
2392 count = ntohl (mp->count);
2393 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2396 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2398 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2399 for (i = 0; i < count; i++)
2401 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2402 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2403 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2404 counter->address = ip6;
2405 counter->packets = clib_net_to_host_u64 (v->packets);
2406 counter->bytes = clib_net_to_host_u64 (v->bytes);
2411 static void vl_api_get_first_msg_id_reply_t_handler
2412 (vl_api_get_first_msg_id_reply_t * mp)
2414 vat_main_t *vam = &vat_main;
2415 i32 retval = ntohl (mp->retval);
2417 if (vam->async_mode)
2419 vam->async_errors += (retval < 0);
2423 vam->retval = retval;
2424 vam->result_ready = 1;
2428 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2432 static void vl_api_get_first_msg_id_reply_t_handler_json
2433 (vl_api_get_first_msg_id_reply_t * mp)
2435 vat_main_t *vam = &vat_main;
2436 vat_json_node_t node;
2438 vat_json_init_object (&node);
2439 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2440 vat_json_object_add_uint (&node, "first_msg_id",
2441 (uint) ntohs (mp->first_msg_id));
2443 vat_json_print (vam->ofp, &node);
2444 vat_json_free (&node);
2446 vam->retval = ntohl (mp->retval);
2447 vam->result_ready = 1;
2450 static void vl_api_get_node_graph_reply_t_handler
2451 (vl_api_get_node_graph_reply_t * mp)
2453 vat_main_t *vam = &vat_main;
2454 api_main_t *am = &api_main;
2455 i32 retval = ntohl (mp->retval);
2456 u8 *pvt_copy, *reply;
2461 if (vam->async_mode)
2463 vam->async_errors += (retval < 0);
2467 vam->retval = retval;
2468 vam->result_ready = 1;
2471 /* "Should never happen..." */
2475 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2476 pvt_copy = vec_dup (reply);
2478 /* Toss the shared-memory original... */
2479 pthread_mutex_lock (&am->vlib_rp->mutex);
2480 oldheap = svm_push_data_heap (am->vlib_rp);
2484 svm_pop_heap (oldheap);
2485 pthread_mutex_unlock (&am->vlib_rp->mutex);
2487 if (vam->graph_nodes)
2489 hash_free (vam->graph_node_index_by_name);
2491 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2493 node = vam->graph_nodes[i];
2494 vec_free (node->name);
2495 vec_free (node->next_nodes);
2498 vec_free (vam->graph_nodes);
2501 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2502 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2503 vec_free (pvt_copy);
2505 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2507 node = vam->graph_nodes[i];
2508 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2512 static void vl_api_get_node_graph_reply_t_handler_json
2513 (vl_api_get_node_graph_reply_t * mp)
2515 vat_main_t *vam = &vat_main;
2516 api_main_t *am = &api_main;
2518 vat_json_node_t node;
2521 /* $$$$ make this real? */
2522 vat_json_init_object (&node);
2523 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2524 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2526 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2528 /* Toss the shared-memory original... */
2529 pthread_mutex_lock (&am->vlib_rp->mutex);
2530 oldheap = svm_push_data_heap (am->vlib_rp);
2534 svm_pop_heap (oldheap);
2535 pthread_mutex_unlock (&am->vlib_rp->mutex);
2537 vat_json_print (vam->ofp, &node);
2538 vat_json_free (&node);
2540 vam->retval = ntohl (mp->retval);
2541 vam->result_ready = 1;
2545 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2547 vat_main_t *vam = &vat_main;
2552 s = format (s, "%=16d%=16d%=16d",
2553 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2557 s = format (s, "%=16U%=16d%=16d",
2558 mp->is_ipv6 ? format_ip6_address :
2560 mp->ip_address, mp->priority, mp->weight);
2563 print (vam->ofp, "%v", s);
2568 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2570 vat_main_t *vam = &vat_main;
2571 vat_json_node_t *node = NULL;
2572 struct in6_addr ip6;
2575 if (VAT_JSON_ARRAY != vam->json_tree.type)
2577 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2578 vat_json_init_array (&vam->json_tree);
2580 node = vat_json_array_add (&vam->json_tree);
2581 vat_json_init_object (node);
2583 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2584 vat_json_object_add_uint (node, "priority", mp->priority);
2585 vat_json_object_add_uint (node, "weight", mp->weight);
2588 vat_json_object_add_uint (node, "sw_if_index",
2589 clib_net_to_host_u32 (mp->sw_if_index));
2594 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2595 vat_json_object_add_ip6 (node, "address", ip6);
2599 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2600 vat_json_object_add_ip4 (node, "address", ip4);
2606 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2609 vat_main_t *vam = &vat_main;
2612 ls_name = format (0, "%s", mp->ls_name);
2614 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2620 vl_api_one_locator_set_details_t_handler_json
2621 (vl_api_one_locator_set_details_t * mp)
2623 vat_main_t *vam = &vat_main;
2624 vat_json_node_t *node = 0;
2627 ls_name = format (0, "%s", mp->ls_name);
2628 vec_add1 (ls_name, 0);
2630 if (VAT_JSON_ARRAY != vam->json_tree.type)
2632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2633 vat_json_init_array (&vam->json_tree);
2635 node = vat_json_array_add (&vam->json_tree);
2637 vat_json_init_object (node);
2638 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2639 vat_json_object_add_uint (node, "ls_index",
2640 clib_net_to_host_u32 (mp->ls_index));
2648 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2651 unformat_nsh_address (unformat_input_t * input, va_list * args)
2653 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2654 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2658 format_nsh_address_vat (u8 * s, va_list * args)
2660 nsh_t *a = va_arg (*args, nsh_t *);
2661 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2665 format_lisp_flat_eid (u8 * s, va_list * args)
2667 u32 type = va_arg (*args, u32);
2668 u8 *eid = va_arg (*args, u8 *);
2669 u32 eid_len = va_arg (*args, u32);
2674 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2676 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2678 return format (s, "%U", format_ethernet_address, eid);
2680 return format (s, "%U", format_nsh_address_vat, eid);
2686 format_lisp_eid_vat (u8 * s, va_list * args)
2688 u32 type = va_arg (*args, u32);
2689 u8 *eid = va_arg (*args, u8 *);
2690 u32 eid_len = va_arg (*args, u32);
2691 u8 *seid = va_arg (*args, u8 *);
2692 u32 seid_len = va_arg (*args, u32);
2693 u32 is_src_dst = va_arg (*args, u32);
2696 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2698 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2704 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2706 vat_main_t *vam = &vat_main;
2707 u8 *s = 0, *eid = 0;
2709 if (~0 == mp->locator_set_index)
2710 s = format (0, "action: %d", mp->action);
2712 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2714 eid = format (0, "%U", format_lisp_eid_vat,
2718 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2721 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2722 clib_net_to_host_u32 (mp->vni),
2724 mp->is_local ? "local" : "remote",
2725 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2726 clib_net_to_host_u16 (mp->key_id), mp->key);
2733 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2736 vat_main_t *vam = &vat_main;
2737 vat_json_node_t *node = 0;
2740 if (VAT_JSON_ARRAY != vam->json_tree.type)
2742 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2743 vat_json_init_array (&vam->json_tree);
2745 node = vat_json_array_add (&vam->json_tree);
2747 vat_json_init_object (node);
2748 if (~0 == mp->locator_set_index)
2749 vat_json_object_add_uint (node, "action", mp->action);
2751 vat_json_object_add_uint (node, "locator_set_index",
2752 clib_net_to_host_u32 (mp->locator_set_index));
2754 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2755 if (mp->eid_type == 3)
2757 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
2758 vat_json_init_object (nsh_json);
2759 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
2760 vat_json_object_add_uint (nsh_json, "spi",
2761 clib_net_to_host_u32 (nsh->spi));
2762 vat_json_object_add_uint (nsh_json, "si", nsh->si);
2766 eid = format (0, "%U", format_lisp_eid_vat,
2770 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2772 vat_json_object_add_string_copy (node, "eid", eid);
2775 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2776 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2777 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2781 vat_json_object_add_uint (node, "key_id",
2782 clib_net_to_host_u16 (mp->key_id));
2783 vat_json_object_add_string_copy (node, "key", mp->key);
2788 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
2790 vat_main_t *vam = &vat_main;
2791 u8 *seid = 0, *deid = 0;
2792 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2794 deid = format (0, "%U", format_lisp_eid_vat,
2795 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
2797 seid = format (0, "%U", format_lisp_eid_vat,
2798 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
2804 format_ip_address_fcn = format_ip4_address;
2806 format_ip_address_fcn = format_ip6_address;
2809 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
2810 clib_net_to_host_u32 (mp->vni),
2812 format_ip_address_fcn, mp->lloc,
2813 format_ip_address_fcn, mp->rloc,
2814 clib_net_to_host_u32 (mp->pkt_count),
2815 clib_net_to_host_u32 (mp->bytes));
2822 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
2824 struct in6_addr ip6;
2826 vat_main_t *vam = &vat_main;
2827 vat_json_node_t *node = 0;
2828 u8 *deid = 0, *seid = 0;
2830 if (VAT_JSON_ARRAY != vam->json_tree.type)
2832 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2833 vat_json_init_array (&vam->json_tree);
2835 node = vat_json_array_add (&vam->json_tree);
2837 vat_json_init_object (node);
2838 deid = format (0, "%U", format_lisp_eid_vat,
2839 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
2841 seid = format (0, "%U", format_lisp_eid_vat,
2842 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
2847 vat_json_object_add_string_copy (node, "seid", seid);
2848 vat_json_object_add_string_copy (node, "deid", deid);
2849 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2853 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
2854 vat_json_object_add_ip4 (node, "lloc", ip4);
2855 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
2856 vat_json_object_add_ip4 (node, "rloc", ip4);
2860 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
2861 vat_json_object_add_ip6 (node, "lloc", ip6);
2862 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
2863 vat_json_object_add_ip6 (node, "rloc", ip6);
2865 vat_json_object_add_uint (node, "pkt_count",
2866 clib_net_to_host_u32 (mp->pkt_count));
2867 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
2874 vl_api_one_eid_table_map_details_t_handler
2875 (vl_api_one_eid_table_map_details_t * mp)
2877 vat_main_t *vam = &vat_main;
2879 u8 *line = format (0, "%=10d%=10d",
2880 clib_net_to_host_u32 (mp->vni),
2881 clib_net_to_host_u32 (mp->dp_table));
2882 print (vam->ofp, "%v", line);
2887 vl_api_one_eid_table_map_details_t_handler_json
2888 (vl_api_one_eid_table_map_details_t * mp)
2890 vat_main_t *vam = &vat_main;
2891 vat_json_node_t *node = NULL;
2893 if (VAT_JSON_ARRAY != vam->json_tree.type)
2895 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2896 vat_json_init_array (&vam->json_tree);
2898 node = vat_json_array_add (&vam->json_tree);
2899 vat_json_init_object (node);
2900 vat_json_object_add_uint (node, "dp_table",
2901 clib_net_to_host_u32 (mp->dp_table));
2902 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2906 vl_api_one_eid_table_vni_details_t_handler
2907 (vl_api_one_eid_table_vni_details_t * mp)
2909 vat_main_t *vam = &vat_main;
2911 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2912 print (vam->ofp, "%v", line);
2917 vl_api_one_eid_table_vni_details_t_handler_json
2918 (vl_api_one_eid_table_vni_details_t * mp)
2920 vat_main_t *vam = &vat_main;
2921 vat_json_node_t *node = NULL;
2923 if (VAT_JSON_ARRAY != vam->json_tree.type)
2925 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2926 vat_json_init_array (&vam->json_tree);
2928 node = vat_json_array_add (&vam->json_tree);
2929 vat_json_init_object (node);
2930 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2934 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
2935 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
2937 vat_main_t *vam = &vat_main;
2938 int retval = clib_net_to_host_u32 (mp->retval);
2940 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
2941 print (vam->ofp, "fallback threshold value: %d", mp->value);
2943 vam->retval = retval;
2944 vam->result_ready = 1;
2948 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
2949 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
2951 vat_main_t *vam = &vat_main;
2952 vat_json_node_t _node, *node = &_node;
2953 int retval = clib_net_to_host_u32 (mp->retval);
2955 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
2956 vat_json_init_object (node);
2957 vat_json_object_add_uint (node, "value", mp->value);
2959 vat_json_print (vam->ofp, node);
2960 vat_json_free (node);
2962 vam->retval = retval;
2963 vam->result_ready = 1;
2967 vl_api_show_one_map_register_state_reply_t_handler
2968 (vl_api_show_one_map_register_state_reply_t * mp)
2970 vat_main_t *vam = &vat_main;
2971 int retval = clib_net_to_host_u32 (mp->retval);
2973 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2975 vam->retval = retval;
2976 vam->result_ready = 1;
2980 vl_api_show_one_map_register_state_reply_t_handler_json
2981 (vl_api_show_one_map_register_state_reply_t * mp)
2983 vat_main_t *vam = &vat_main;
2984 vat_json_node_t _node, *node = &_node;
2985 int retval = clib_net_to_host_u32 (mp->retval);
2987 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2989 vat_json_init_object (node);
2990 vat_json_object_add_string_copy (node, "state", s);
2992 vat_json_print (vam->ofp, node);
2993 vat_json_free (node);
2995 vam->retval = retval;
2996 vam->result_ready = 1;
3001 vl_api_show_one_rloc_probe_state_reply_t_handler
3002 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3004 vat_main_t *vam = &vat_main;
3005 int retval = clib_net_to_host_u32 (mp->retval);
3010 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3012 vam->retval = retval;
3013 vam->result_ready = 1;
3017 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3018 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3020 vat_main_t *vam = &vat_main;
3021 vat_json_node_t _node, *node = &_node;
3022 int retval = clib_net_to_host_u32 (mp->retval);
3024 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3025 vat_json_init_object (node);
3026 vat_json_object_add_string_copy (node, "state", s);
3028 vat_json_print (vam->ofp, node);
3029 vat_json_free (node);
3031 vam->retval = retval;
3032 vam->result_ready = 1;
3037 vl_api_show_one_stats_enable_disable_reply_t_handler
3038 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3040 vat_main_t *vam = &vat_main;
3041 int retval = clib_net_to_host_u32 (mp->retval);
3046 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3048 vam->retval = retval;
3049 vam->result_ready = 1;
3053 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3054 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3056 vat_main_t *vam = &vat_main;
3057 vat_json_node_t _node, *node = &_node;
3058 int retval = clib_net_to_host_u32 (mp->retval);
3060 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3061 vat_json_init_object (node);
3062 vat_json_object_add_string_copy (node, "state", s);
3064 vat_json_print (vam->ofp, node);
3065 vat_json_free (node);
3067 vam->retval = retval;
3068 vam->result_ready = 1;
3073 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3075 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3076 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3077 e->vni = clib_net_to_host_u32 (e->vni);
3081 gpe_fwd_entries_get_reply_t_net_to_host
3082 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3086 mp->count = clib_net_to_host_u32 (mp->count);
3087 for (i = 0; i < mp->count; i++)
3089 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3094 format_gpe_encap_mode (u8 * s, va_list * args)
3096 u32 mode = va_arg (*args, u32);
3101 return format (s, "lisp");
3103 return format (s, "vxlan");
3109 vl_api_gpe_get_encap_mode_reply_t_handler
3110 (vl_api_gpe_get_encap_mode_reply_t * mp)
3112 vat_main_t *vam = &vat_main;
3114 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3115 vam->retval = ntohl (mp->retval);
3116 vam->result_ready = 1;
3120 vl_api_gpe_get_encap_mode_reply_t_handler_json
3121 (vl_api_gpe_get_encap_mode_reply_t * mp)
3123 vat_main_t *vam = &vat_main;
3124 vat_json_node_t node;
3126 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3127 vec_add1 (encap_mode, 0);
3129 vat_json_init_object (&node);
3130 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3132 vec_free (encap_mode);
3133 vat_json_print (vam->ofp, &node);
3134 vat_json_free (&node);
3136 vam->retval = ntohl (mp->retval);
3137 vam->result_ready = 1;
3141 vl_api_gpe_fwd_entry_path_details_t_handler
3142 (vl_api_gpe_fwd_entry_path_details_t * mp)
3144 vat_main_t *vam = &vat_main;
3145 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3147 if (mp->lcl_loc.is_ip4)
3148 format_ip_address_fcn = format_ip4_address;
3150 format_ip_address_fcn = format_ip6_address;
3152 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3153 format_ip_address_fcn, &mp->lcl_loc,
3154 format_ip_address_fcn, &mp->rmt_loc);
3158 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3160 struct in6_addr ip6;
3165 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3166 vat_json_object_add_ip4 (n, "address", ip4);
3170 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3171 vat_json_object_add_ip6 (n, "address", ip6);
3173 vat_json_object_add_uint (n, "weight", loc->weight);
3177 vl_api_gpe_fwd_entry_path_details_t_handler_json
3178 (vl_api_gpe_fwd_entry_path_details_t * mp)
3180 vat_main_t *vam = &vat_main;
3181 vat_json_node_t *node = NULL;
3182 vat_json_node_t *loc_node;
3184 if (VAT_JSON_ARRAY != vam->json_tree.type)
3186 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3187 vat_json_init_array (&vam->json_tree);
3189 node = vat_json_array_add (&vam->json_tree);
3190 vat_json_init_object (node);
3192 loc_node = vat_json_object_add (node, "local_locator");
3193 vat_json_init_object (loc_node);
3194 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3196 loc_node = vat_json_object_add (node, "remote_locator");
3197 vat_json_init_object (loc_node);
3198 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3202 vl_api_gpe_fwd_entries_get_reply_t_handler
3203 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3205 vat_main_t *vam = &vat_main;
3207 int retval = clib_net_to_host_u32 (mp->retval);
3208 vl_api_gpe_fwd_entry_t *e;
3213 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3215 for (i = 0; i < mp->count; i++)
3217 e = &mp->entries[i];
3218 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3219 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3220 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3224 vam->retval = retval;
3225 vam->result_ready = 1;
3229 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3230 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3233 vat_main_t *vam = &vat_main;
3234 vat_json_node_t *e = 0, root;
3236 int retval = clib_net_to_host_u32 (mp->retval);
3237 vl_api_gpe_fwd_entry_t *fwd;
3242 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3243 vat_json_init_array (&root);
3245 for (i = 0; i < mp->count; i++)
3247 e = vat_json_array_add (&root);
3248 fwd = &mp->entries[i];
3250 vat_json_init_object (e);
3251 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3252 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3253 vat_json_object_add_int (e, "vni", fwd->vni);
3254 vat_json_object_add_int (e, "action", fwd->action);
3256 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3257 fwd->leid_prefix_len);
3259 vat_json_object_add_string_copy (e, "leid", s);
3262 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3263 fwd->reid_prefix_len);
3265 vat_json_object_add_string_copy (e, "reid", s);
3269 vat_json_print (vam->ofp, &root);
3270 vat_json_free (&root);
3273 vam->retval = retval;
3274 vam->result_ready = 1;
3278 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3279 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3281 vat_main_t *vam = &vat_main;
3283 int retval = clib_net_to_host_u32 (mp->retval);
3284 vl_api_gpe_native_fwd_rpath_t *r;
3289 n = clib_net_to_host_u32 (mp->count);
3291 for (i = 0; i < n; i++)
3293 r = &mp->entries[i];
3294 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3295 clib_net_to_host_u32 (r->fib_index),
3296 clib_net_to_host_u32 (r->nh_sw_if_index),
3297 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3301 vam->retval = retval;
3302 vam->result_ready = 1;
3306 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3307 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3309 vat_main_t *vam = &vat_main;
3310 vat_json_node_t root, *e;
3312 int retval = clib_net_to_host_u32 (mp->retval);
3313 vl_api_gpe_native_fwd_rpath_t *r;
3319 n = clib_net_to_host_u32 (mp->count);
3320 vat_json_init_array (&root);
3322 for (i = 0; i < n; i++)
3324 e = vat_json_array_add (&root);
3325 vat_json_init_object (e);
3326 r = &mp->entries[i];
3328 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3331 vat_json_object_add_string_copy (e, "ip4", s);
3334 vat_json_object_add_uint (e, "fib_index",
3335 clib_net_to_host_u32 (r->fib_index));
3336 vat_json_object_add_uint (e, "nh_sw_if_index",
3337 clib_net_to_host_u32 (r->nh_sw_if_index));
3340 vat_json_print (vam->ofp, &root);
3341 vat_json_free (&root);
3344 vam->retval = retval;
3345 vam->result_ready = 1;
3349 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3350 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3352 vat_main_t *vam = &vat_main;
3354 int retval = clib_net_to_host_u32 (mp->retval);
3359 n = clib_net_to_host_u32 (mp->count);
3361 for (i = 0; i < n; i++)
3362 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3365 vam->retval = retval;
3366 vam->result_ready = 1;
3370 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3371 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3373 vat_main_t *vam = &vat_main;
3374 vat_json_node_t root;
3376 int retval = clib_net_to_host_u32 (mp->retval);
3381 n = clib_net_to_host_u32 (mp->count);
3382 vat_json_init_array (&root);
3384 for (i = 0; i < n; i++)
3385 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3387 vat_json_print (vam->ofp, &root);
3388 vat_json_free (&root);
3391 vam->retval = retval;
3392 vam->result_ready = 1;
3396 vl_api_one_l2_arp_entries_get_reply_t_handler
3397 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3399 vat_main_t *vam = &vat_main;
3401 int retval = clib_net_to_host_u32 (mp->retval);
3406 n = clib_net_to_host_u32 (mp->count);
3408 for (i = 0; i < n; i++)
3409 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3410 format_ethernet_address, mp->entries[i].mac);
3413 vam->retval = retval;
3414 vam->result_ready = 1;
3418 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3419 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3422 vat_main_t *vam = &vat_main;
3423 vat_json_node_t *e = 0, root;
3425 int retval = clib_net_to_host_u32 (mp->retval);
3426 vl_api_one_l2_arp_entry_t *arp_entry;
3431 n = clib_net_to_host_u32 (mp->count);
3432 vat_json_init_array (&root);
3434 for (i = 0; i < n; i++)
3436 e = vat_json_array_add (&root);
3437 arp_entry = &mp->entries[i];
3439 vat_json_init_object (e);
3440 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3443 vat_json_object_add_string_copy (e, "mac", s);
3446 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3448 vat_json_object_add_string_copy (e, "ip4", s);
3452 vat_json_print (vam->ofp, &root);
3453 vat_json_free (&root);
3456 vam->retval = retval;
3457 vam->result_ready = 1;
3461 vl_api_one_l2_arp_bd_get_reply_t_handler
3462 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3464 vat_main_t *vam = &vat_main;
3466 int retval = clib_net_to_host_u32 (mp->retval);
3471 n = clib_net_to_host_u32 (mp->count);
3473 for (i = 0; i < n; i++)
3475 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3479 vam->retval = retval;
3480 vam->result_ready = 1;
3484 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3485 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3487 vat_main_t *vam = &vat_main;
3488 vat_json_node_t root;
3490 int retval = clib_net_to_host_u32 (mp->retval);
3495 n = clib_net_to_host_u32 (mp->count);
3496 vat_json_init_array (&root);
3498 for (i = 0; i < n; i++)
3500 vat_json_array_add_uint (&root,
3501 clib_net_to_host_u32 (mp->bridge_domains[i]));
3504 vat_json_print (vam->ofp, &root);
3505 vat_json_free (&root);
3508 vam->retval = retval;
3509 vam->result_ready = 1;
3513 vl_api_one_adjacencies_get_reply_t_handler
3514 (vl_api_one_adjacencies_get_reply_t * mp)
3516 vat_main_t *vam = &vat_main;
3518 int retval = clib_net_to_host_u32 (mp->retval);
3519 vl_api_one_adjacency_t *a;
3524 n = clib_net_to_host_u32 (mp->count);
3526 for (i = 0; i < n; i++)
3528 a = &mp->adjacencies[i];
3529 print (vam->ofp, "%U %40U",
3530 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3531 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3535 vam->retval = retval;
3536 vam->result_ready = 1;
3540 vl_api_one_adjacencies_get_reply_t_handler_json
3541 (vl_api_one_adjacencies_get_reply_t * mp)
3544 vat_main_t *vam = &vat_main;
3545 vat_json_node_t *e = 0, root;
3547 int retval = clib_net_to_host_u32 (mp->retval);
3548 vl_api_one_adjacency_t *a;
3553 n = clib_net_to_host_u32 (mp->count);
3554 vat_json_init_array (&root);
3556 for (i = 0; i < n; i++)
3558 e = vat_json_array_add (&root);
3559 a = &mp->adjacencies[i];
3561 vat_json_init_object (e);
3562 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3563 a->leid_prefix_len);
3565 vat_json_object_add_string_copy (e, "leid", s);
3568 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3569 a->reid_prefix_len);
3571 vat_json_object_add_string_copy (e, "reid", s);
3575 vat_json_print (vam->ofp, &root);
3576 vat_json_free (&root);
3579 vam->retval = retval;
3580 vam->result_ready = 1;
3584 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3586 vat_main_t *vam = &vat_main;
3588 print (vam->ofp, "%=20U",
3589 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3594 vl_api_one_map_server_details_t_handler_json
3595 (vl_api_one_map_server_details_t * mp)
3597 vat_main_t *vam = &vat_main;
3598 vat_json_node_t *node = NULL;
3599 struct in6_addr ip6;
3602 if (VAT_JSON_ARRAY != vam->json_tree.type)
3604 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3605 vat_json_init_array (&vam->json_tree);
3607 node = vat_json_array_add (&vam->json_tree);
3609 vat_json_init_object (node);
3612 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3613 vat_json_object_add_ip6 (node, "map-server", ip6);
3617 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3618 vat_json_object_add_ip4 (node, "map-server", ip4);
3623 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3626 vat_main_t *vam = &vat_main;
3628 print (vam->ofp, "%=20U",
3629 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3634 vl_api_one_map_resolver_details_t_handler_json
3635 (vl_api_one_map_resolver_details_t * mp)
3637 vat_main_t *vam = &vat_main;
3638 vat_json_node_t *node = NULL;
3639 struct in6_addr ip6;
3642 if (VAT_JSON_ARRAY != vam->json_tree.type)
3644 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3645 vat_json_init_array (&vam->json_tree);
3647 node = vat_json_array_add (&vam->json_tree);
3649 vat_json_init_object (node);
3652 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3653 vat_json_object_add_ip6 (node, "map resolver", ip6);
3657 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3658 vat_json_object_add_ip4 (node, "map resolver", ip4);
3663 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
3665 vat_main_t *vam = &vat_main;
3666 i32 retval = ntohl (mp->retval);
3670 print (vam->ofp, "feature: %s\ngpe: %s",
3671 mp->feature_status ? "enabled" : "disabled",
3672 mp->gpe_status ? "enabled" : "disabled");
3675 vam->retval = retval;
3676 vam->result_ready = 1;
3680 vl_api_show_one_status_reply_t_handler_json
3681 (vl_api_show_one_status_reply_t * mp)
3683 vat_main_t *vam = &vat_main;
3684 vat_json_node_t node;
3685 u8 *gpe_status = NULL;
3686 u8 *feature_status = NULL;
3688 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3689 feature_status = format (0, "%s",
3690 mp->feature_status ? "enabled" : "disabled");
3691 vec_add1 (gpe_status, 0);
3692 vec_add1 (feature_status, 0);
3694 vat_json_init_object (&node);
3695 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3696 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3698 vec_free (gpe_status);
3699 vec_free (feature_status);
3701 vat_json_print (vam->ofp, &node);
3702 vat_json_free (&node);
3704 vam->retval = ntohl (mp->retval);
3705 vam->result_ready = 1;
3709 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
3710 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3712 vat_main_t *vam = &vat_main;
3713 i32 retval = ntohl (mp->retval);
3717 print (vam->ofp, "%=20s", mp->locator_set_name);
3720 vam->retval = retval;
3721 vam->result_ready = 1;
3725 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
3726 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3728 vat_main_t *vam = &vat_main;
3729 vat_json_node_t *node = NULL;
3731 if (VAT_JSON_ARRAY != vam->json_tree.type)
3733 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3734 vat_json_init_array (&vam->json_tree);
3736 node = vat_json_array_add (&vam->json_tree);
3738 vat_json_init_object (node);
3739 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3741 vat_json_print (vam->ofp, node);
3742 vat_json_free (node);
3744 vam->retval = ntohl (mp->retval);
3745 vam->result_ready = 1;
3749 format_lisp_map_request_mode (u8 * s, va_list * args)
3751 u32 mode = va_arg (*args, u32);
3756 return format (0, "dst-only");
3758 return format (0, "src-dst");
3764 vl_api_show_one_map_request_mode_reply_t_handler
3765 (vl_api_show_one_map_request_mode_reply_t * mp)
3767 vat_main_t *vam = &vat_main;
3768 i32 retval = ntohl (mp->retval);
3772 u32 mode = mp->mode;
3773 print (vam->ofp, "map_request_mode: %U",
3774 format_lisp_map_request_mode, mode);
3777 vam->retval = retval;
3778 vam->result_ready = 1;
3782 vl_api_show_one_map_request_mode_reply_t_handler_json
3783 (vl_api_show_one_map_request_mode_reply_t * mp)
3785 vat_main_t *vam = &vat_main;
3786 vat_json_node_t node;
3791 s = format (0, "%U", format_lisp_map_request_mode, mode);
3794 vat_json_init_object (&node);
3795 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3796 vat_json_print (vam->ofp, &node);
3797 vat_json_free (&node);
3800 vam->retval = ntohl (mp->retval);
3801 vam->result_ready = 1;
3805 vl_api_show_one_use_petr_reply_t_handler
3806 (vl_api_show_one_use_petr_reply_t * mp)
3808 vat_main_t *vam = &vat_main;
3809 i32 retval = ntohl (mp->retval);
3813 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
3816 print (vam->ofp, "Proxy-ETR address; %U",
3817 mp->is_ip4 ? format_ip4_address : format_ip6_address,
3822 vam->retval = retval;
3823 vam->result_ready = 1;
3827 vl_api_show_one_use_petr_reply_t_handler_json
3828 (vl_api_show_one_use_petr_reply_t * mp)
3830 vat_main_t *vam = &vat_main;
3831 vat_json_node_t node;
3834 struct in6_addr ip6;
3836 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3837 vec_add1 (status, 0);
3839 vat_json_init_object (&node);
3840 vat_json_object_add_string_copy (&node, "status", status);
3845 clib_memcpy (&ip6, mp->address, sizeof (ip6));
3846 vat_json_object_add_ip6 (&node, "address", ip6);
3850 clib_memcpy (&ip4, mp->address, sizeof (ip4));
3851 vat_json_object_add_ip4 (&node, "address", ip4);
3857 vat_json_print (vam->ofp, &node);
3858 vat_json_free (&node);
3860 vam->retval = ntohl (mp->retval);
3861 vam->result_ready = 1;
3865 vl_api_show_one_nsh_mapping_reply_t_handler
3866 (vl_api_show_one_nsh_mapping_reply_t * mp)
3868 vat_main_t *vam = &vat_main;
3869 i32 retval = ntohl (mp->retval);
3873 print (vam->ofp, "%-20s%-16s",
3874 mp->is_set ? "set" : "not-set",
3875 mp->is_set ? (char *) mp->locator_set_name : "");
3878 vam->retval = retval;
3879 vam->result_ready = 1;
3883 vl_api_show_one_nsh_mapping_reply_t_handler_json
3884 (vl_api_show_one_nsh_mapping_reply_t * mp)
3886 vat_main_t *vam = &vat_main;
3887 vat_json_node_t node;
3890 status = format (0, "%s", mp->is_set ? "yes" : "no");
3891 vec_add1 (status, 0);
3893 vat_json_init_object (&node);
3894 vat_json_object_add_string_copy (&node, "is_set", status);
3897 vat_json_object_add_string_copy (&node, "locator_set",
3898 mp->locator_set_name);
3903 vat_json_print (vam->ofp, &node);
3904 vat_json_free (&node);
3906 vam->retval = ntohl (mp->retval);
3907 vam->result_ready = 1;
3911 vl_api_show_one_map_register_ttl_reply_t_handler
3912 (vl_api_show_one_map_register_ttl_reply_t * mp)
3914 vat_main_t *vam = &vat_main;
3915 i32 retval = ntohl (mp->retval);
3917 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
3921 print (vam->ofp, "ttl: %u", mp->ttl);
3924 vam->retval = retval;
3925 vam->result_ready = 1;
3929 vl_api_show_one_map_register_ttl_reply_t_handler_json
3930 (vl_api_show_one_map_register_ttl_reply_t * mp)
3932 vat_main_t *vam = &vat_main;
3933 vat_json_node_t node;
3935 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
3936 vat_json_init_object (&node);
3937 vat_json_object_add_uint (&node, "ttl", mp->ttl);
3939 vat_json_print (vam->ofp, &node);
3940 vat_json_free (&node);
3942 vam->retval = ntohl (mp->retval);
3943 vam->result_ready = 1;
3947 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
3949 vat_main_t *vam = &vat_main;
3950 i32 retval = ntohl (mp->retval);
3954 print (vam->ofp, "%-20s%-16s",
3955 mp->status ? "enabled" : "disabled",
3956 mp->status ? (char *) mp->locator_set_name : "");
3959 vam->retval = retval;
3960 vam->result_ready = 1;
3964 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
3966 vat_main_t *vam = &vat_main;
3967 vat_json_node_t node;
3970 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3971 vec_add1 (status, 0);
3973 vat_json_init_object (&node);
3974 vat_json_object_add_string_copy (&node, "status", status);
3977 vat_json_object_add_string_copy (&node, "locator_set",
3978 mp->locator_set_name);
3983 vat_json_print (vam->ofp, &node);
3984 vat_json_free (&node);
3986 vam->retval = ntohl (mp->retval);
3987 vam->result_ready = 1;
3991 format_policer_type (u8 * s, va_list * va)
3993 u32 i = va_arg (*va, u32);
3995 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3996 s = format (s, "1r2c");
3997 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3998 s = format (s, "1r3c");
3999 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4000 s = format (s, "2r3c-2698");
4001 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4002 s = format (s, "2r3c-4115");
4003 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4004 s = format (s, "2r3c-mef5cf1");
4006 s = format (s, "ILLEGAL");
4011 format_policer_rate_type (u8 * s, va_list * va)
4013 u32 i = va_arg (*va, u32);
4015 if (i == SSE2_QOS_RATE_KBPS)
4016 s = format (s, "kbps");
4017 else if (i == SSE2_QOS_RATE_PPS)
4018 s = format (s, "pps");
4020 s = format (s, "ILLEGAL");
4025 format_policer_round_type (u8 * s, va_list * va)
4027 u32 i = va_arg (*va, u32);
4029 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4030 s = format (s, "closest");
4031 else if (i == SSE2_QOS_ROUND_TO_UP)
4032 s = format (s, "up");
4033 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4034 s = format (s, "down");
4036 s = format (s, "ILLEGAL");
4041 format_policer_action_type (u8 * s, va_list * va)
4043 u32 i = va_arg (*va, u32);
4045 if (i == SSE2_QOS_ACTION_DROP)
4046 s = format (s, "drop");
4047 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4048 s = format (s, "transmit");
4049 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4050 s = format (s, "mark-and-transmit");
4052 s = format (s, "ILLEGAL");
4057 format_dscp (u8 * s, va_list * va)
4059 u32 i = va_arg (*va, u32);
4064 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4068 return format (s, "ILLEGAL");
4070 s = format (s, "%s", t);
4075 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4077 vat_main_t *vam = &vat_main;
4078 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4080 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4081 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4083 conform_dscp_str = format (0, "");
4085 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4086 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4088 exceed_dscp_str = format (0, "");
4090 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4091 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4093 violate_dscp_str = format (0, "");
4095 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4096 "rate type %U, round type %U, %s rate, %s color-aware, "
4097 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4098 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4099 "conform action %U%s, exceed action %U%s, violate action %U%s",
4101 format_policer_type, mp->type,
4104 clib_net_to_host_u64 (mp->cb),
4105 clib_net_to_host_u64 (mp->eb),
4106 format_policer_rate_type, mp->rate_type,
4107 format_policer_round_type, mp->round_type,
4108 mp->single_rate ? "single" : "dual",
4109 mp->color_aware ? "is" : "not",
4110 ntohl (mp->cir_tokens_per_period),
4111 ntohl (mp->pir_tokens_per_period),
4113 ntohl (mp->current_limit),
4114 ntohl (mp->current_bucket),
4115 ntohl (mp->extended_limit),
4116 ntohl (mp->extended_bucket),
4117 clib_net_to_host_u64 (mp->last_update_time),
4118 format_policer_action_type, mp->conform_action_type,
4120 format_policer_action_type, mp->exceed_action_type,
4122 format_policer_action_type, mp->violate_action_type,
4125 vec_free (conform_dscp_str);
4126 vec_free (exceed_dscp_str);
4127 vec_free (violate_dscp_str);
4130 static void vl_api_policer_details_t_handler_json
4131 (vl_api_policer_details_t * mp)
4133 vat_main_t *vam = &vat_main;
4134 vat_json_node_t *node;
4135 u8 *rate_type_str, *round_type_str, *type_str;
4136 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4138 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4140 format (0, "%U", format_policer_round_type, mp->round_type);
4141 type_str = format (0, "%U", format_policer_type, mp->type);
4142 conform_action_str = format (0, "%U", format_policer_action_type,
4143 mp->conform_action_type);
4144 exceed_action_str = format (0, "%U", format_policer_action_type,
4145 mp->exceed_action_type);
4146 violate_action_str = format (0, "%U", format_policer_action_type,
4147 mp->violate_action_type);
4149 if (VAT_JSON_ARRAY != vam->json_tree.type)
4151 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4152 vat_json_init_array (&vam->json_tree);
4154 node = vat_json_array_add (&vam->json_tree);
4156 vat_json_init_object (node);
4157 vat_json_object_add_string_copy (node, "name", mp->name);
4158 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4159 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4160 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4161 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4162 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4163 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4164 vat_json_object_add_string_copy (node, "type", type_str);
4165 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4166 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4167 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4168 vat_json_object_add_uint (node, "cir_tokens_per_period",
4169 ntohl (mp->cir_tokens_per_period));
4170 vat_json_object_add_uint (node, "eir_tokens_per_period",
4171 ntohl (mp->pir_tokens_per_period));
4172 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4173 vat_json_object_add_uint (node, "current_bucket",
4174 ntohl (mp->current_bucket));
4175 vat_json_object_add_uint (node, "extended_limit",
4176 ntohl (mp->extended_limit));
4177 vat_json_object_add_uint (node, "extended_bucket",
4178 ntohl (mp->extended_bucket));
4179 vat_json_object_add_uint (node, "last_update_time",
4180 ntohl (mp->last_update_time));
4181 vat_json_object_add_string_copy (node, "conform_action",
4182 conform_action_str);
4183 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4185 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4186 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4187 vec_free (dscp_str);
4189 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4190 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4192 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4193 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4194 vec_free (dscp_str);
4196 vat_json_object_add_string_copy (node, "violate_action",
4197 violate_action_str);
4198 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4200 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4201 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4202 vec_free (dscp_str);
4205 vec_free (rate_type_str);
4206 vec_free (round_type_str);
4207 vec_free (type_str);
4208 vec_free (conform_action_str);
4209 vec_free (exceed_action_str);
4210 vec_free (violate_action_str);
4214 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4217 vat_main_t *vam = &vat_main;
4218 int i, count = ntohl (mp->count);
4221 print (vam->ofp, "classify table ids (%d) : ", count);
4222 for (i = 0; i < count; i++)
4224 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4225 print (vam->ofp, (i < count - 1) ? "," : "");
4227 vam->retval = ntohl (mp->retval);
4228 vam->result_ready = 1;
4232 vl_api_classify_table_ids_reply_t_handler_json
4233 (vl_api_classify_table_ids_reply_t * mp)
4235 vat_main_t *vam = &vat_main;
4236 int i, count = ntohl (mp->count);
4240 vat_json_node_t node;
4242 vat_json_init_object (&node);
4243 for (i = 0; i < count; i++)
4245 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4247 vat_json_print (vam->ofp, &node);
4248 vat_json_free (&node);
4250 vam->retval = ntohl (mp->retval);
4251 vam->result_ready = 1;
4255 vl_api_classify_table_by_interface_reply_t_handler
4256 (vl_api_classify_table_by_interface_reply_t * mp)
4258 vat_main_t *vam = &vat_main;
4261 table_id = ntohl (mp->l2_table_id);
4263 print (vam->ofp, "l2 table id : %d", table_id);
4265 print (vam->ofp, "l2 table id : No input ACL tables configured");
4266 table_id = ntohl (mp->ip4_table_id);
4268 print (vam->ofp, "ip4 table id : %d", table_id);
4270 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4271 table_id = ntohl (mp->ip6_table_id);
4273 print (vam->ofp, "ip6 table id : %d", table_id);
4275 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4276 vam->retval = ntohl (mp->retval);
4277 vam->result_ready = 1;
4281 vl_api_classify_table_by_interface_reply_t_handler_json
4282 (vl_api_classify_table_by_interface_reply_t * mp)
4284 vat_main_t *vam = &vat_main;
4285 vat_json_node_t node;
4287 vat_json_init_object (&node);
4289 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4290 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4291 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4293 vat_json_print (vam->ofp, &node);
4294 vat_json_free (&node);
4296 vam->retval = ntohl (mp->retval);
4297 vam->result_ready = 1;
4300 static void vl_api_policer_add_del_reply_t_handler
4301 (vl_api_policer_add_del_reply_t * mp)
4303 vat_main_t *vam = &vat_main;
4304 i32 retval = ntohl (mp->retval);
4305 if (vam->async_mode)
4307 vam->async_errors += (retval < 0);
4311 vam->retval = retval;
4312 vam->result_ready = 1;
4313 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4315 * Note: this is just barely thread-safe, depends on
4316 * the main thread spinning waiting for an answer...
4318 errmsg ("policer index %d", ntohl (mp->policer_index));
4322 static void vl_api_policer_add_del_reply_t_handler_json
4323 (vl_api_policer_add_del_reply_t * mp)
4325 vat_main_t *vam = &vat_main;
4326 vat_json_node_t node;
4328 vat_json_init_object (&node);
4329 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4330 vat_json_object_add_uint (&node, "policer_index",
4331 ntohl (mp->policer_index));
4333 vat_json_print (vam->ofp, &node);
4334 vat_json_free (&node);
4336 vam->retval = ntohl (mp->retval);
4337 vam->result_ready = 1;
4340 /* Format hex dump. */
4342 format_hex_bytes (u8 * s, va_list * va)
4344 u8 *bytes = va_arg (*va, u8 *);
4345 int n_bytes = va_arg (*va, int);
4348 /* Print short or long form depending on byte count. */
4349 uword short_form = n_bytes <= 32;
4350 uword indent = format_get_indent (s);
4355 for (i = 0; i < n_bytes; i++)
4357 if (!short_form && (i % 32) == 0)
4358 s = format (s, "%08x: ", i);
4359 s = format (s, "%02x", bytes[i]);
4360 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4361 s = format (s, "\n%U", format_white_space, indent);
4368 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4371 vat_main_t *vam = &vat_main;
4372 i32 retval = ntohl (mp->retval);
4375 print (vam->ofp, "classify table info :");
4376 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4377 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4378 ntohl (mp->miss_next_index));
4379 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4380 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4381 ntohl (mp->match_n_vectors));
4382 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4383 ntohl (mp->mask_length));
4385 vam->retval = retval;
4386 vam->result_ready = 1;
4390 vl_api_classify_table_info_reply_t_handler_json
4391 (vl_api_classify_table_info_reply_t * mp)
4393 vat_main_t *vam = &vat_main;
4394 vat_json_node_t node;
4396 i32 retval = ntohl (mp->retval);
4399 vat_json_init_object (&node);
4401 vat_json_object_add_int (&node, "sessions",
4402 ntohl (mp->active_sessions));
4403 vat_json_object_add_int (&node, "nexttbl",
4404 ntohl (mp->next_table_index));
4405 vat_json_object_add_int (&node, "nextnode",
4406 ntohl (mp->miss_next_index));
4407 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4408 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4409 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4410 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4411 ntohl (mp->mask_length), 0);
4412 vat_json_object_add_string_copy (&node, "mask", s);
4414 vat_json_print (vam->ofp, &node);
4415 vat_json_free (&node);
4417 vam->retval = ntohl (mp->retval);
4418 vam->result_ready = 1;
4422 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4425 vat_main_t *vam = &vat_main;
4427 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4428 ntohl (mp->hit_next_index), ntohl (mp->advance),
4429 ntohl (mp->opaque_index));
4430 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4431 ntohl (mp->match_length));
4435 vl_api_classify_session_details_t_handler_json
4436 (vl_api_classify_session_details_t * mp)
4438 vat_main_t *vam = &vat_main;
4439 vat_json_node_t *node = NULL;
4441 if (VAT_JSON_ARRAY != vam->json_tree.type)
4443 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4444 vat_json_init_array (&vam->json_tree);
4446 node = vat_json_array_add (&vam->json_tree);
4448 vat_json_init_object (node);
4449 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4450 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4451 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4453 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4455 vat_json_object_add_string_copy (node, "match", s);
4458 static void vl_api_pg_create_interface_reply_t_handler
4459 (vl_api_pg_create_interface_reply_t * mp)
4461 vat_main_t *vam = &vat_main;
4463 vam->retval = ntohl (mp->retval);
4464 vam->result_ready = 1;
4467 static void vl_api_pg_create_interface_reply_t_handler_json
4468 (vl_api_pg_create_interface_reply_t * mp)
4470 vat_main_t *vam = &vat_main;
4471 vat_json_node_t node;
4473 i32 retval = ntohl (mp->retval);
4476 vat_json_init_object (&node);
4478 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4480 vat_json_print (vam->ofp, &node);
4481 vat_json_free (&node);
4483 vam->retval = ntohl (mp->retval);
4484 vam->result_ready = 1;
4487 static void vl_api_policer_classify_details_t_handler
4488 (vl_api_policer_classify_details_t * mp)
4490 vat_main_t *vam = &vat_main;
4492 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4493 ntohl (mp->table_index));
4496 static void vl_api_policer_classify_details_t_handler_json
4497 (vl_api_policer_classify_details_t * mp)
4499 vat_main_t *vam = &vat_main;
4500 vat_json_node_t *node;
4502 if (VAT_JSON_ARRAY != vam->json_tree.type)
4504 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4505 vat_json_init_array (&vam->json_tree);
4507 node = vat_json_array_add (&vam->json_tree);
4509 vat_json_init_object (node);
4510 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4511 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4514 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
4515 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4517 vat_main_t *vam = &vat_main;
4518 i32 retval = ntohl (mp->retval);
4519 if (vam->async_mode)
4521 vam->async_errors += (retval < 0);
4525 vam->retval = retval;
4526 vam->sw_if_index = ntohl (mp->sw_if_index);
4527 vam->result_ready = 1;
4531 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
4532 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4534 vat_main_t *vam = &vat_main;
4535 vat_json_node_t node;
4537 vat_json_init_object (&node);
4538 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4539 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
4541 vat_json_print (vam->ofp, &node);
4542 vat_json_free (&node);
4544 vam->retval = ntohl (mp->retval);
4545 vam->result_ready = 1;
4548 static void vl_api_flow_classify_details_t_handler
4549 (vl_api_flow_classify_details_t * mp)
4551 vat_main_t *vam = &vat_main;
4553 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4554 ntohl (mp->table_index));
4557 static void vl_api_flow_classify_details_t_handler_json
4558 (vl_api_flow_classify_details_t * mp)
4560 vat_main_t *vam = &vat_main;
4561 vat_json_node_t *node;
4563 if (VAT_JSON_ARRAY != vam->json_tree.type)
4565 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4566 vat_json_init_array (&vam->json_tree);
4568 node = vat_json_array_add (&vam->json_tree);
4570 vat_json_init_object (node);
4571 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4572 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4575 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
4576 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
4577 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
4578 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
4579 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
4580 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
4581 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
4582 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
4583 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
4584 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
4585 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
4586 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
4587 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
4588 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
4589 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
4590 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
4591 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
4592 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
4595 * Generate boilerplate reply handlers, which
4596 * dig the return value out of the xxx_reply_t API message,
4597 * stick it into vam->retval, and set vam->result_ready
4599 * Could also do this by pointing N message decode slots at
4600 * a single function, but that could break in subtle ways.
4603 #define foreach_standard_reply_retval_handler \
4604 _(sw_interface_set_flags_reply) \
4605 _(sw_interface_add_del_address_reply) \
4606 _(sw_interface_set_table_reply) \
4607 _(sw_interface_set_mpls_enable_reply) \
4608 _(sw_interface_set_vpath_reply) \
4609 _(sw_interface_set_vxlan_bypass_reply) \
4610 _(sw_interface_set_vxlan_gpe_bypass_reply) \
4611 _(sw_interface_set_l2_bridge_reply) \
4612 _(bridge_domain_add_del_reply) \
4613 _(sw_interface_set_l2_xconnect_reply) \
4614 _(l2fib_add_del_reply) \
4615 _(l2fib_flush_int_reply) \
4616 _(l2fib_flush_bd_reply) \
4617 _(ip_add_del_route_reply) \
4618 _(ip_table_add_del_reply) \
4619 _(ip_mroute_add_del_reply) \
4620 _(mpls_route_add_del_reply) \
4621 _(mpls_table_add_del_reply) \
4622 _(mpls_ip_bind_unbind_reply) \
4623 _(proxy_arp_add_del_reply) \
4624 _(proxy_arp_intfc_enable_disable_reply) \
4625 _(sw_interface_set_unnumbered_reply) \
4626 _(ip_neighbor_add_del_reply) \
4627 _(reset_vrf_reply) \
4628 _(oam_add_del_reply) \
4629 _(reset_fib_reply) \
4630 _(dhcp_proxy_config_reply) \
4631 _(dhcp_proxy_set_vss_reply) \
4632 _(dhcp_client_config_reply) \
4633 _(set_ip_flow_hash_reply) \
4634 _(sw_interface_ip6_enable_disable_reply) \
4635 _(sw_interface_ip6_set_link_local_address_reply) \
4636 _(ip6nd_proxy_add_del_reply) \
4637 _(sw_interface_ip6nd_ra_prefix_reply) \
4638 _(sw_interface_ip6nd_ra_config_reply) \
4639 _(set_arp_neighbor_limit_reply) \
4640 _(l2_patch_add_del_reply) \
4641 _(sr_policy_add_reply) \
4642 _(sr_policy_mod_reply) \
4643 _(sr_policy_del_reply) \
4644 _(sr_localsid_add_del_reply) \
4645 _(sr_steering_add_del_reply) \
4646 _(classify_add_del_session_reply) \
4647 _(classify_set_interface_ip_table_reply) \
4648 _(classify_set_interface_l2_tables_reply) \
4649 _(l2tpv3_set_tunnel_cookies_reply) \
4650 _(l2tpv3_interface_enable_disable_reply) \
4651 _(l2tpv3_set_lookup_key_reply) \
4652 _(l2_fib_clear_table_reply) \
4653 _(l2_interface_efp_filter_reply) \
4654 _(l2_interface_vlan_tag_rewrite_reply) \
4655 _(modify_vhost_user_if_reply) \
4656 _(delete_vhost_user_if_reply) \
4657 _(want_ip4_arp_events_reply) \
4658 _(want_ip6_nd_events_reply) \
4659 _(want_l2_macs_events_reply) \
4660 _(input_acl_set_interface_reply) \
4661 _(ipsec_spd_add_del_reply) \
4662 _(ipsec_interface_add_del_spd_reply) \
4663 _(ipsec_spd_add_del_entry_reply) \
4664 _(ipsec_sad_add_del_entry_reply) \
4665 _(ipsec_sa_set_key_reply) \
4666 _(ipsec_tunnel_if_add_del_reply) \
4667 _(ikev2_profile_add_del_reply) \
4668 _(ikev2_profile_set_auth_reply) \
4669 _(ikev2_profile_set_id_reply) \
4670 _(ikev2_profile_set_ts_reply) \
4671 _(ikev2_set_local_key_reply) \
4672 _(ikev2_set_responder_reply) \
4673 _(ikev2_set_ike_transforms_reply) \
4674 _(ikev2_set_esp_transforms_reply) \
4675 _(ikev2_set_sa_lifetime_reply) \
4676 _(ikev2_initiate_sa_init_reply) \
4677 _(ikev2_initiate_del_ike_sa_reply) \
4678 _(ikev2_initiate_del_child_sa_reply) \
4679 _(ikev2_initiate_rekey_child_sa_reply) \
4680 _(delete_loopback_reply) \
4681 _(bd_ip_mac_add_del_reply) \
4682 _(map_del_domain_reply) \
4683 _(map_add_del_rule_reply) \
4684 _(want_interface_events_reply) \
4685 _(want_stats_reply) \
4686 _(cop_interface_enable_disable_reply) \
4687 _(cop_whitelist_enable_disable_reply) \
4688 _(sw_interface_clear_stats_reply) \
4689 _(ioam_enable_reply) \
4690 _(ioam_disable_reply) \
4691 _(one_add_del_locator_reply) \
4692 _(one_add_del_local_eid_reply) \
4693 _(one_add_del_remote_mapping_reply) \
4694 _(one_add_del_adjacency_reply) \
4695 _(one_add_del_map_resolver_reply) \
4696 _(one_add_del_map_server_reply) \
4697 _(one_enable_disable_reply) \
4698 _(one_rloc_probe_enable_disable_reply) \
4699 _(one_map_register_enable_disable_reply) \
4700 _(one_map_register_set_ttl_reply) \
4701 _(one_map_register_fallback_threshold_reply) \
4702 _(one_pitr_set_locator_set_reply) \
4703 _(one_map_request_mode_reply) \
4704 _(one_add_del_map_request_itr_rlocs_reply) \
4705 _(one_eid_table_add_del_map_reply) \
4706 _(one_use_petr_reply) \
4707 _(one_stats_enable_disable_reply) \
4708 _(one_add_del_l2_arp_entry_reply) \
4709 _(one_stats_flush_reply) \
4710 _(gpe_enable_disable_reply) \
4711 _(gpe_set_encap_mode_reply) \
4712 _(gpe_add_del_iface_reply) \
4713 _(gpe_add_del_native_fwd_rpath_reply) \
4714 _(af_packet_delete_reply) \
4715 _(policer_classify_set_interface_reply) \
4716 _(netmap_create_reply) \
4717 _(netmap_delete_reply) \
4718 _(set_ipfix_exporter_reply) \
4719 _(set_ipfix_classify_stream_reply) \
4720 _(ipfix_classify_table_add_del_reply) \
4721 _(flow_classify_set_interface_reply) \
4722 _(sw_interface_span_enable_disable_reply) \
4723 _(pg_capture_reply) \
4724 _(pg_enable_disable_reply) \
4725 _(ip_source_and_port_range_check_add_del_reply) \
4726 _(ip_source_and_port_range_check_interface_add_del_reply)\
4727 _(delete_subif_reply) \
4728 _(l2_interface_pbb_tag_rewrite_reply) \
4730 _(feature_enable_disable_reply) \
4731 _(sw_interface_tag_add_del_reply) \
4732 _(sw_interface_set_mtu_reply) \
4733 _(p2p_ethernet_add_reply) \
4734 _(p2p_ethernet_del_reply) \
4735 _(lldp_config_reply) \
4736 _(sw_interface_set_lldp_reply)
4739 static void vl_api_##n##_t_handler \
4740 (vl_api_##n##_t * mp) \
4742 vat_main_t * vam = &vat_main; \
4743 i32 retval = ntohl(mp->retval); \
4744 if (vam->async_mode) { \
4745 vam->async_errors += (retval < 0); \
4747 vam->retval = retval; \
4748 vam->result_ready = 1; \
4751 foreach_standard_reply_retval_handler;
4755 static void vl_api_##n##_t_handler_json \
4756 (vl_api_##n##_t * mp) \
4758 vat_main_t * vam = &vat_main; \
4759 vat_json_node_t node; \
4760 vat_json_init_object(&node); \
4761 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
4762 vat_json_print(vam->ofp, &node); \
4763 vam->retval = ntohl(mp->retval); \
4764 vam->result_ready = 1; \
4766 foreach_standard_reply_retval_handler;
4770 * Table of message reply handlers, must include boilerplate handlers
4774 #define foreach_vpe_api_reply_msg \
4775 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4776 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
4777 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4778 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4779 _(CONTROL_PING_REPLY, control_ping_reply) \
4780 _(CLI_REPLY, cli_reply) \
4781 _(CLI_INBAND_REPLY, cli_inband_reply) \
4782 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4783 sw_interface_add_del_address_reply) \
4784 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4785 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4786 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4787 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4788 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
4789 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4790 sw_interface_set_l2_xconnect_reply) \
4791 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4792 sw_interface_set_l2_bridge_reply) \
4793 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4794 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4795 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
4796 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4797 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
4798 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
4799 _(L2_FLAGS_REPLY, l2_flags_reply) \
4800 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4801 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4802 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4803 _(TAP_DELETE_REPLY, tap_delete_reply) \
4804 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4805 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4806 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
4807 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4808 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
4809 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4810 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4811 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4812 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4813 proxy_arp_intfc_enable_disable_reply) \
4814 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4815 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4816 sw_interface_set_unnumbered_reply) \
4817 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4818 _(RESET_VRF_REPLY, reset_vrf_reply) \
4819 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4820 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4821 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4822 _(RESET_FIB_REPLY, reset_fib_reply) \
4823 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4824 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4825 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4826 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4827 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4828 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4829 sw_interface_ip6_enable_disable_reply) \
4830 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4831 sw_interface_ip6_set_link_local_address_reply) \
4832 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
4833 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
4834 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4835 sw_interface_ip6nd_ra_prefix_reply) \
4836 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4837 sw_interface_ip6nd_ra_config_reply) \
4838 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4839 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4840 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
4841 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
4842 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
4843 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
4844 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
4845 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4846 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4847 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4848 classify_set_interface_ip_table_reply) \
4849 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4850 classify_set_interface_l2_tables_reply) \
4851 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4852 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4853 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4854 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4855 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4856 l2tpv3_interface_enable_disable_reply) \
4857 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4858 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4859 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4860 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4861 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4862 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4863 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4864 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4865 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4866 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4867 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4868 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4869 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4870 _(SHOW_VERSION_REPLY, show_version_reply) \
4871 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
4872 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4873 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4874 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4875 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4876 _(IP4_ARP_EVENT, ip4_arp_event) \
4877 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4878 _(IP6_ND_EVENT, ip6_nd_event) \
4879 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
4880 _(L2_MACS_EVENT, l2_macs_event) \
4881 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4882 _(IP_ADDRESS_DETAILS, ip_address_details) \
4883 _(IP_DETAILS, ip_details) \
4884 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4885 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4886 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4887 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4888 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4889 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
4890 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4891 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4892 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4893 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4894 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4895 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4896 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4897 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4898 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4899 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4900 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4901 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4902 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4903 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4904 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4905 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4906 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4907 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4908 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4909 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4910 _(MAP_RULE_DETAILS, map_rule_details) \
4911 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4912 _(WANT_STATS_REPLY, want_stats_reply) \
4913 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4914 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4915 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4916 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4917 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4918 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4919 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4920 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4921 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4922 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4923 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4924 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4925 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4926 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4927 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4928 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4929 one_map_register_enable_disable_reply) \
4930 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
4931 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
4932 one_map_register_fallback_threshold_reply) \
4933 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4934 one_rloc_probe_enable_disable_reply) \
4935 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4936 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
4937 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4938 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4939 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4940 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4941 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4942 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4943 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4944 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4945 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4946 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4947 _(ONE_STATS_DETAILS, one_stats_details) \
4948 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
4949 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
4950 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
4951 show_one_stats_enable_disable_reply) \
4952 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
4953 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
4954 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
4955 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4956 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4957 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4958 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4959 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4960 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
4961 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4962 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
4963 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
4964 gpe_add_del_native_fwd_rpath_reply) \
4965 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4966 gpe_fwd_entry_path_details) \
4967 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4968 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4969 one_add_del_map_request_itr_rlocs_reply) \
4970 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4971 one_get_map_request_itr_rlocs_reply) \
4972 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
4973 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4974 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
4975 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4976 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4977 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4978 show_one_map_register_state_reply) \
4979 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
4980 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
4981 show_one_map_register_fallback_threshold_reply) \
4982 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4983 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4984 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4985 _(POLICER_DETAILS, policer_details) \
4986 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4987 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4988 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4989 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4990 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4991 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4992 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4993 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4994 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4995 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4996 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4997 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4998 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4999 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5000 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5001 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5002 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5003 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5004 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5005 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5006 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5007 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5008 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5009 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5010 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5011 ip_source_and_port_range_check_add_del_reply) \
5012 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5013 ip_source_and_port_range_check_interface_add_del_reply) \
5014 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5015 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5016 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5017 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5018 _(PUNT_REPLY, punt_reply) \
5019 _(IP_FIB_DETAILS, ip_fib_details) \
5020 _(IP6_FIB_DETAILS, ip6_fib_details) \
5021 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5022 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5023 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5024 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5025 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5026 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5027 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5028 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5029 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5030 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply)
5032 #define foreach_standalone_reply_msg \
5033 _(SW_INTERFACE_EVENT, sw_interface_event) \
5034 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5035 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5036 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5037 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5038 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5039 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
5048 #define STR_VTR_OP_CASE(op) \
5049 case L2_VTR_ ## op: \
5053 str_vtr_op (u32 vtr_op)
5057 STR_VTR_OP_CASE (DISABLED);
5058 STR_VTR_OP_CASE (PUSH_1);
5059 STR_VTR_OP_CASE (PUSH_2);
5060 STR_VTR_OP_CASE (POP_1);
5061 STR_VTR_OP_CASE (POP_2);
5062 STR_VTR_OP_CASE (TRANSLATE_1_1);
5063 STR_VTR_OP_CASE (TRANSLATE_1_2);
5064 STR_VTR_OP_CASE (TRANSLATE_2_1);
5065 STR_VTR_OP_CASE (TRANSLATE_2_2);
5072 dump_sub_interface_table (vat_main_t * vam)
5074 const sw_interface_subif_t *sub = NULL;
5076 if (vam->json_output)
5079 ("JSON output supported only for VPE API calls and dump_stats_table");
5084 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5085 "Interface", "sw_if_index",
5086 "sub id", "dot1ad", "tags", "outer id",
5087 "inner id", "exact", "default", "outer any", "inner any");
5089 vec_foreach (sub, vam->sw_if_subif_table)
5092 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5093 sub->interface_name,
5095 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5096 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5097 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5098 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5099 if (sub->vtr_op != L2_VTR_DISABLED)
5102 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5103 "tag1: %d tag2: %d ]",
5104 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5105 sub->vtr_tag1, sub->vtr_tag2);
5113 name_sort_cmp (void *a1, void *a2)
5115 name_sort_t *n1 = a1;
5116 name_sort_t *n2 = a2;
5118 return strcmp ((char *) n1->name, (char *) n2->name);
5122 dump_interface_table (vat_main_t * vam)
5125 name_sort_t *nses = 0, *ns;
5127 if (vam->json_output)
5130 ("JSON output supported only for VPE API calls and dump_stats_table");
5135 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5137 vec_add2 (nses, ns, 1);
5138 ns->name = (u8 *)(p->key);
5139 ns->value = (u32) p->value[0];
5143 vec_sort_with_function (nses, name_sort_cmp);
5145 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5146 vec_foreach (ns, nses)
5148 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5155 dump_ip_table (vat_main_t * vam, int is_ipv6)
5157 const ip_details_t *det = NULL;
5158 const ip_address_details_t *address = NULL;
5161 print (vam->ofp, "%-12s", "sw_if_index");
5163 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5170 print (vam->ofp, "%-12d", i);
5171 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5176 vec_foreach (address, det->addr)
5180 is_ipv6 ? format_ip6_address : format_ip4_address,
5181 address->ip, address->prefix_length);
5189 dump_ipv4_table (vat_main_t * vam)
5191 if (vam->json_output)
5194 ("JSON output supported only for VPE API calls and dump_stats_table");
5198 return dump_ip_table (vam, 0);
5202 dump_ipv6_table (vat_main_t * vam)
5204 if (vam->json_output)
5207 ("JSON output supported only for VPE API calls and dump_stats_table");
5211 return dump_ip_table (vam, 1);
5215 counter_type_to_str (u8 counter_type, u8 is_combined)
5219 switch (counter_type)
5221 case VNET_INTERFACE_COUNTER_DROP:
5223 case VNET_INTERFACE_COUNTER_PUNT:
5225 case VNET_INTERFACE_COUNTER_IP4:
5227 case VNET_INTERFACE_COUNTER_IP6:
5229 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5231 case VNET_INTERFACE_COUNTER_RX_MISS:
5233 case VNET_INTERFACE_COUNTER_RX_ERROR:
5235 case VNET_INTERFACE_COUNTER_TX_ERROR:
5238 return "INVALID-COUNTER-TYPE";
5243 switch (counter_type)
5245 case VNET_INTERFACE_COUNTER_RX:
5247 case VNET_INTERFACE_COUNTER_TX:
5250 return "INVALID-COUNTER-TYPE";
5256 dump_stats_table (vat_main_t * vam)
5258 vat_json_node_t node;
5259 vat_json_node_t *msg_array;
5260 vat_json_node_t *msg;
5261 vat_json_node_t *counter_array;
5262 vat_json_node_t *counter;
5263 interface_counter_t c;
5265 ip4_fib_counter_t *c4;
5266 ip6_fib_counter_t *c6;
5267 ip4_nbr_counter_t *n4;
5268 ip6_nbr_counter_t *n6;
5271 if (!vam->json_output)
5273 clib_warning ("dump_stats_table supported only in JSON format");
5277 vat_json_init_object (&node);
5279 /* interface counters */
5280 msg_array = vat_json_object_add (&node, "interface_counters");
5281 vat_json_init_array (msg_array);
5282 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5284 msg = vat_json_array_add (msg_array);
5285 vat_json_init_object (msg);
5286 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5287 (u8 *) counter_type_to_str (i, 0));
5288 vat_json_object_add_int (msg, "is_combined", 0);
5289 counter_array = vat_json_object_add (msg, "data");
5290 vat_json_init_array (counter_array);
5291 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5293 packets = vam->simple_interface_counters[i][j];
5294 vat_json_array_add_uint (counter_array, packets);
5297 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5299 msg = vat_json_array_add (msg_array);
5300 vat_json_init_object (msg);
5301 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5302 (u8 *) counter_type_to_str (i, 1));
5303 vat_json_object_add_int (msg, "is_combined", 1);
5304 counter_array = vat_json_object_add (msg, "data");
5305 vat_json_init_array (counter_array);
5306 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5308 c = vam->combined_interface_counters[i][j];
5309 counter = vat_json_array_add (counter_array);
5310 vat_json_init_object (counter);
5311 vat_json_object_add_uint (counter, "packets", c.packets);
5312 vat_json_object_add_uint (counter, "bytes", c.bytes);
5316 /* ip4 fib counters */
5317 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5318 vat_json_init_array (msg_array);
5319 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5321 msg = vat_json_array_add (msg_array);
5322 vat_json_init_object (msg);
5323 vat_json_object_add_uint (msg, "vrf_id",
5324 vam->ip4_fib_counters_vrf_id_by_index[i]);
5325 counter_array = vat_json_object_add (msg, "c");
5326 vat_json_init_array (counter_array);
5327 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
5329 counter = vat_json_array_add (counter_array);
5330 vat_json_init_object (counter);
5331 c4 = &vam->ip4_fib_counters[i][j];
5332 vat_json_object_add_ip4 (counter, "address", c4->address);
5333 vat_json_object_add_uint (counter, "address_length",
5334 c4->address_length);
5335 vat_json_object_add_uint (counter, "packets", c4->packets);
5336 vat_json_object_add_uint (counter, "bytes", c4->bytes);
5340 /* ip6 fib counters */
5341 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
5342 vat_json_init_array (msg_array);
5343 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
5345 msg = vat_json_array_add (msg_array);
5346 vat_json_init_object (msg);
5347 vat_json_object_add_uint (msg, "vrf_id",
5348 vam->ip6_fib_counters_vrf_id_by_index[i]);
5349 counter_array = vat_json_object_add (msg, "c");
5350 vat_json_init_array (counter_array);
5351 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
5353 counter = vat_json_array_add (counter_array);
5354 vat_json_init_object (counter);
5355 c6 = &vam->ip6_fib_counters[i][j];
5356 vat_json_object_add_ip6 (counter, "address", c6->address);
5357 vat_json_object_add_uint (counter, "address_length",
5358 c6->address_length);
5359 vat_json_object_add_uint (counter, "packets", c6->packets);
5360 vat_json_object_add_uint (counter, "bytes", c6->bytes);
5364 /* ip4 nbr counters */
5365 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
5366 vat_json_init_array (msg_array);
5367 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
5369 msg = vat_json_array_add (msg_array);
5370 vat_json_init_object (msg);
5371 vat_json_object_add_uint (msg, "sw_if_index", i);
5372 counter_array = vat_json_object_add (msg, "c");
5373 vat_json_init_array (counter_array);
5374 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
5376 counter = vat_json_array_add (counter_array);
5377 vat_json_init_object (counter);
5378 n4 = &vam->ip4_nbr_counters[i][j];
5379 vat_json_object_add_ip4 (counter, "address", n4->address);
5380 vat_json_object_add_uint (counter, "link-type", n4->linkt);
5381 vat_json_object_add_uint (counter, "packets", n4->packets);
5382 vat_json_object_add_uint (counter, "bytes", n4->bytes);
5386 /* ip6 nbr counters */
5387 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
5388 vat_json_init_array (msg_array);
5389 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
5391 msg = vat_json_array_add (msg_array);
5392 vat_json_init_object (msg);
5393 vat_json_object_add_uint (msg, "sw_if_index", i);
5394 counter_array = vat_json_object_add (msg, "c");
5395 vat_json_init_array (counter_array);
5396 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
5398 counter = vat_json_array_add (counter_array);
5399 vat_json_init_object (counter);
5400 n6 = &vam->ip6_nbr_counters[i][j];
5401 vat_json_object_add_ip6 (counter, "address", n6->address);
5402 vat_json_object_add_uint (counter, "packets", n6->packets);
5403 vat_json_object_add_uint (counter, "bytes", n6->bytes);
5407 vat_json_print (vam->ofp, &node);
5408 vat_json_free (&node);
5414 exec (vat_main_t * vam)
5416 api_main_t *am = &api_main;
5421 unformat_input_t *i = vam->input;
5423 if (vec_len (i->buffer) == 0)
5426 if (vam->exec_mode == 0 && unformat (i, "mode"))
5431 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5441 * Copy cmd into shared memory.
5442 * In order for the CLI command to work, it
5443 * must be a vector ending in \n, not a C-string ending
5446 pthread_mutex_lock (&am->vlib_rp->mutex);
5447 oldheap = svm_push_data_heap (am->vlib_rp);
5449 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
5450 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
5452 svm_pop_heap (oldheap);
5453 pthread_mutex_unlock (&am->vlib_rp->mutex);
5455 mp->cmd_in_shmem = pointer_to_uword (cmd);
5457 timeout = vat_time_now (vam) + 10.0;
5459 while (vat_time_now (vam) < timeout)
5461 if (vam->result_ready == 1)
5464 if (vam->shmem_result != NULL)
5465 print (vam->ofp, "%s", vam->shmem_result);
5466 pthread_mutex_lock (&am->vlib_rp->mutex);
5467 oldheap = svm_push_data_heap (am->vlib_rp);
5469 free_me = (u8 *) vam->shmem_result;
5472 svm_pop_heap (oldheap);
5473 pthread_mutex_unlock (&am->vlib_rp->mutex);
5481 * Future replacement of exec() that passes CLI buffers directly in
5482 * the API messages instead of an additional shared memory area.
5485 exec_inband (vat_main_t * vam)
5487 vl_api_cli_inband_t *mp;
5488 unformat_input_t *i = vam->input;
5491 if (vec_len (i->buffer) == 0)
5494 if (vam->exec_mode == 0 && unformat (i, "mode"))
5499 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5506 * In order for the CLI command to work, it
5507 * must be a vector ending in \n, not a C-string ending
5510 u32 len = vec_len (vam->input->buffer);
5511 M2 (CLI_INBAND, mp, len);
5512 clib_memcpy (mp->cmd, vam->input->buffer, len);
5513 mp->length = htonl (len);
5516 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
5521 api_create_loopback (vat_main_t * vam)
5523 unformat_input_t *i = vam->input;
5524 vl_api_create_loopback_t *mp;
5525 vl_api_create_loopback_instance_t *mp_lbi;
5528 u8 is_specified = 0;
5529 u32 user_instance = 0;
5532 memset (mac_address, 0, sizeof (mac_address));
5534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5536 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5538 if (unformat (i, "instance %d", &user_instance))
5546 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5547 mp_lbi->is_specified = is_specified;
5549 mp_lbi->user_instance = htonl (user_instance);
5551 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5556 /* Construct the API message */
5557 M (CREATE_LOOPBACK, mp);
5559 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5568 api_delete_loopback (vat_main_t * vam)
5570 unformat_input_t *i = vam->input;
5571 vl_api_delete_loopback_t *mp;
5572 u32 sw_if_index = ~0;
5575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5577 if (unformat (i, "sw_if_index %d", &sw_if_index))
5583 if (sw_if_index == ~0)
5585 errmsg ("missing sw_if_index");
5589 /* Construct the API message */
5590 M (DELETE_LOOPBACK, mp);
5591 mp->sw_if_index = ntohl (sw_if_index);
5599 api_want_stats (vat_main_t * vam)
5601 unformat_input_t *i = vam->input;
5602 vl_api_want_stats_t *mp;
5606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5608 if (unformat (i, "enable"))
5610 else if (unformat (i, "disable"))
5618 errmsg ("missing enable|disable");
5623 mp->enable_disable = enable;
5631 api_want_interface_events (vat_main_t * vam)
5633 unformat_input_t *i = vam->input;
5634 vl_api_want_interface_events_t *mp;
5638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5640 if (unformat (i, "enable"))
5642 else if (unformat (i, "disable"))
5650 errmsg ("missing enable|disable");
5654 M (WANT_INTERFACE_EVENTS, mp);
5655 mp->enable_disable = enable;
5657 vam->interface_event_display = enable;
5665 /* Note: non-static, called once to set up the initial intfc table */
5667 api_sw_interface_dump (vat_main_t * vam)
5669 vl_api_sw_interface_dump_t *mp;
5670 vl_api_control_ping_t *mp_ping;
5672 name_sort_t *nses = 0, *ns;
5673 sw_interface_subif_t *sub = NULL;
5676 /* Toss the old name table */
5678 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5680 vec_add2 (nses, ns, 1);
5681 ns->name = (u8 *)(p->key);
5682 ns->value = (u32) p->value[0];
5686 hash_free (vam->sw_if_index_by_interface_name);
5688 vec_foreach (ns, nses) vec_free (ns->name);
5692 vec_foreach (sub, vam->sw_if_subif_table)
5694 vec_free (sub->interface_name);
5696 vec_free (vam->sw_if_subif_table);
5698 /* recreate the interface name hash table */
5699 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5701 /* Get list of ethernets */
5702 M (SW_INTERFACE_DUMP, mp);
5703 mp->name_filter_valid = 1;
5704 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
5707 /* and local / loopback interfaces */
5708 M (SW_INTERFACE_DUMP, mp);
5709 mp->name_filter_valid = 1;
5710 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
5713 /* and packet-generator interfaces */
5714 M (SW_INTERFACE_DUMP, mp);
5715 mp->name_filter_valid = 1;
5716 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
5719 /* and vxlan-gpe tunnel interfaces */
5720 M (SW_INTERFACE_DUMP, mp);
5721 mp->name_filter_valid = 1;
5722 strncpy ((char *) mp->name_filter, "vxlan_gpe",
5723 sizeof (mp->name_filter) - 1);
5726 /* and vxlan tunnel interfaces */
5727 M (SW_INTERFACE_DUMP, mp);
5728 mp->name_filter_valid = 1;
5729 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
5732 /* and host (af_packet) interfaces */
5733 M (SW_INTERFACE_DUMP, mp);
5734 mp->name_filter_valid = 1;
5735 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
5738 /* and l2tpv3 tunnel interfaces */
5739 M (SW_INTERFACE_DUMP, mp);
5740 mp->name_filter_valid = 1;
5741 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
5742 sizeof (mp->name_filter) - 1);
5745 /* and GRE tunnel interfaces */
5746 M (SW_INTERFACE_DUMP, mp);
5747 mp->name_filter_valid = 1;
5748 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
5751 /* and LISP-GPE interfaces */
5752 M (SW_INTERFACE_DUMP, mp);
5753 mp->name_filter_valid = 1;
5754 strncpy ((char *) mp->name_filter, "lisp_gpe",
5755 sizeof (mp->name_filter) - 1);
5758 /* and IPSEC tunnel interfaces */
5759 M (SW_INTERFACE_DUMP, mp);
5760 mp->name_filter_valid = 1;
5761 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
5764 /* Use a control ping for synchronization */
5765 M (CONTROL_PING, mp_ping);
5773 api_sw_interface_set_flags (vat_main_t * vam)
5775 unformat_input_t *i = vam->input;
5776 vl_api_sw_interface_set_flags_t *mp;
5778 u8 sw_if_index_set = 0;
5782 /* Parse args required to build the message */
5783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5785 if (unformat (i, "admin-up"))
5787 else if (unformat (i, "admin-down"))
5790 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5791 sw_if_index_set = 1;
5792 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5793 sw_if_index_set = 1;
5798 if (sw_if_index_set == 0)
5800 errmsg ("missing interface name or sw_if_index");
5804 /* Construct the API message */
5805 M (SW_INTERFACE_SET_FLAGS, mp);
5806 mp->sw_if_index = ntohl (sw_if_index);
5807 mp->admin_up_down = admin_up;
5812 /* Wait for a reply, return the good/bad news... */
5818 api_sw_interface_clear_stats (vat_main_t * vam)
5820 unformat_input_t *i = vam->input;
5821 vl_api_sw_interface_clear_stats_t *mp;
5823 u8 sw_if_index_set = 0;
5826 /* Parse args required to build the message */
5827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5829 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5830 sw_if_index_set = 1;
5831 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5832 sw_if_index_set = 1;
5837 /* Construct the API message */
5838 M (SW_INTERFACE_CLEAR_STATS, mp);
5840 if (sw_if_index_set == 1)
5841 mp->sw_if_index = ntohl (sw_if_index);
5843 mp->sw_if_index = ~0;
5848 /* Wait for a reply, return the good/bad news... */
5854 api_sw_interface_add_del_address (vat_main_t * vam)
5856 unformat_input_t *i = vam->input;
5857 vl_api_sw_interface_add_del_address_t *mp;
5859 u8 sw_if_index_set = 0;
5860 u8 is_add = 1, del_all = 0;
5861 u32 address_length = 0;
5862 u8 v4_address_set = 0;
5863 u8 v6_address_set = 0;
5864 ip4_address_t v4address;
5865 ip6_address_t v6address;
5868 /* Parse args required to build the message */
5869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5871 if (unformat (i, "del-all"))
5873 else if (unformat (i, "del"))
5876 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5877 sw_if_index_set = 1;
5878 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5879 sw_if_index_set = 1;
5880 else if (unformat (i, "%U/%d",
5881 unformat_ip4_address, &v4address, &address_length))
5883 else if (unformat (i, "%U/%d",
5884 unformat_ip6_address, &v6address, &address_length))
5890 if (sw_if_index_set == 0)
5892 errmsg ("missing interface name or sw_if_index");
5895 if (v4_address_set && v6_address_set)
5897 errmsg ("both v4 and v6 addresses set");
5900 if (!v4_address_set && !v6_address_set && !del_all)
5902 errmsg ("no addresses set");
5906 /* Construct the API message */
5907 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5909 mp->sw_if_index = ntohl (sw_if_index);
5910 mp->is_add = is_add;
5911 mp->del_all = del_all;
5915 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5919 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5921 mp->address_length = address_length;
5926 /* Wait for a reply, return good/bad news */
5932 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5934 unformat_input_t *i = vam->input;
5935 vl_api_sw_interface_set_mpls_enable_t *mp;
5937 u8 sw_if_index_set = 0;
5941 /* Parse args required to build the message */
5942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5944 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5945 sw_if_index_set = 1;
5946 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5947 sw_if_index_set = 1;
5948 else if (unformat (i, "disable"))
5950 else if (unformat (i, "dis"))
5956 if (sw_if_index_set == 0)
5958 errmsg ("missing interface name or sw_if_index");
5962 /* Construct the API message */
5963 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5965 mp->sw_if_index = ntohl (sw_if_index);
5966 mp->enable = enable;
5971 /* Wait for a reply... */
5977 api_sw_interface_set_table (vat_main_t * vam)
5979 unformat_input_t *i = vam->input;
5980 vl_api_sw_interface_set_table_t *mp;
5981 u32 sw_if_index, vrf_id = 0;
5982 u8 sw_if_index_set = 0;
5986 /* Parse args required to build the message */
5987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5989 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5990 sw_if_index_set = 1;
5991 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5992 sw_if_index_set = 1;
5993 else if (unformat (i, "vrf %d", &vrf_id))
5995 else if (unformat (i, "ipv6"))
6001 if (sw_if_index_set == 0)
6003 errmsg ("missing interface name or sw_if_index");
6007 /* Construct the API message */
6008 M (SW_INTERFACE_SET_TABLE, mp);
6010 mp->sw_if_index = ntohl (sw_if_index);
6011 mp->is_ipv6 = is_ipv6;
6012 mp->vrf_id = ntohl (vrf_id);
6017 /* Wait for a reply... */
6022 static void vl_api_sw_interface_get_table_reply_t_handler
6023 (vl_api_sw_interface_get_table_reply_t * mp)
6025 vat_main_t *vam = &vat_main;
6027 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6029 vam->retval = ntohl (mp->retval);
6030 vam->result_ready = 1;
6034 static void vl_api_sw_interface_get_table_reply_t_handler_json
6035 (vl_api_sw_interface_get_table_reply_t * mp)
6037 vat_main_t *vam = &vat_main;
6038 vat_json_node_t node;
6040 vat_json_init_object (&node);
6041 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6042 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6044 vat_json_print (vam->ofp, &node);
6045 vat_json_free (&node);
6047 vam->retval = ntohl (mp->retval);
6048 vam->result_ready = 1;
6052 api_sw_interface_get_table (vat_main_t * vam)
6054 unformat_input_t *i = vam->input;
6055 vl_api_sw_interface_get_table_t *mp;
6057 u8 sw_if_index_set = 0;
6061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6063 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6064 sw_if_index_set = 1;
6065 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6066 sw_if_index_set = 1;
6067 else if (unformat (i, "ipv6"))
6073 if (sw_if_index_set == 0)
6075 errmsg ("missing interface name or sw_if_index");
6079 M (SW_INTERFACE_GET_TABLE, mp);
6080 mp->sw_if_index = htonl (sw_if_index);
6081 mp->is_ipv6 = is_ipv6;
6089 api_sw_interface_set_vpath (vat_main_t * vam)
6091 unformat_input_t *i = vam->input;
6092 vl_api_sw_interface_set_vpath_t *mp;
6093 u32 sw_if_index = 0;
6094 u8 sw_if_index_set = 0;
6098 /* Parse args required to build the message */
6099 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6101 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6102 sw_if_index_set = 1;
6103 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6104 sw_if_index_set = 1;
6105 else if (unformat (i, "enable"))
6107 else if (unformat (i, "disable"))
6113 if (sw_if_index_set == 0)
6115 errmsg ("missing interface name or sw_if_index");
6119 /* Construct the API message */
6120 M (SW_INTERFACE_SET_VPATH, mp);
6122 mp->sw_if_index = ntohl (sw_if_index);
6123 mp->enable = is_enable;
6128 /* Wait for a reply... */
6134 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6136 unformat_input_t *i = vam->input;
6137 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6138 u32 sw_if_index = 0;
6139 u8 sw_if_index_set = 0;
6144 /* Parse args required to build the message */
6145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6147 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6148 sw_if_index_set = 1;
6149 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6150 sw_if_index_set = 1;
6151 else if (unformat (i, "enable"))
6153 else if (unformat (i, "disable"))
6155 else if (unformat (i, "ip4"))
6157 else if (unformat (i, "ip6"))
6163 if (sw_if_index_set == 0)
6165 errmsg ("missing interface name or sw_if_index");
6169 /* Construct the API message */
6170 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6172 mp->sw_if_index = ntohl (sw_if_index);
6173 mp->enable = is_enable;
6174 mp->is_ipv6 = is_ipv6;
6179 /* Wait for a reply... */
6186 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6188 unformat_input_t *i = vam->input;
6189 vl_api_sw_interface_set_l2_xconnect_t *mp;
6191 u8 rx_sw_if_index_set = 0;
6193 u8 tx_sw_if_index_set = 0;
6197 /* Parse args required to build the message */
6198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6200 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6201 rx_sw_if_index_set = 1;
6202 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6203 tx_sw_if_index_set = 1;
6204 else if (unformat (i, "rx"))
6206 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6208 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6210 rx_sw_if_index_set = 1;
6215 else if (unformat (i, "tx"))
6217 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6219 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6221 tx_sw_if_index_set = 1;
6226 else if (unformat (i, "enable"))
6228 else if (unformat (i, "disable"))
6234 if (rx_sw_if_index_set == 0)
6236 errmsg ("missing rx interface name or rx_sw_if_index");
6240 if (enable && (tx_sw_if_index_set == 0))
6242 errmsg ("missing tx interface name or tx_sw_if_index");
6246 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6248 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6249 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6250 mp->enable = enable;
6258 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6260 unformat_input_t *i = vam->input;
6261 vl_api_sw_interface_set_l2_bridge_t *mp;
6263 u8 rx_sw_if_index_set = 0;
6271 /* Parse args required to build the message */
6272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6274 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6275 rx_sw_if_index_set = 1;
6276 else if (unformat (i, "bd_id %d", &bd_id))
6280 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6281 rx_sw_if_index_set = 1;
6282 else if (unformat (i, "shg %d", &shg))
6284 else if (unformat (i, "bvi"))
6286 else if (unformat (i, "enable"))
6288 else if (unformat (i, "disable"))
6294 if (rx_sw_if_index_set == 0)
6296 errmsg ("missing rx interface name or sw_if_index");
6300 if (enable && (bd_id_set == 0))
6302 errmsg ("missing bridge domain");
6306 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6308 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6309 mp->bd_id = ntohl (bd_id);
6312 mp->enable = enable;
6320 api_bridge_domain_dump (vat_main_t * vam)
6322 unformat_input_t *i = vam->input;
6323 vl_api_bridge_domain_dump_t *mp;
6324 vl_api_control_ping_t *mp_ping;
6328 /* Parse args required to build the message */
6329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6331 if (unformat (i, "bd_id %d", &bd_id))
6337 M (BRIDGE_DOMAIN_DUMP, mp);
6338 mp->bd_id = ntohl (bd_id);
6341 /* Use a control ping for synchronization */
6342 M (CONTROL_PING, mp_ping);
6350 api_bridge_domain_add_del (vat_main_t * vam)
6352 unformat_input_t *i = vam->input;
6353 vl_api_bridge_domain_add_del_t *mp;
6356 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6360 /* Parse args required to build the message */
6361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6363 if (unformat (i, "bd_id %d", &bd_id))
6365 else if (unformat (i, "flood %d", &flood))
6367 else if (unformat (i, "uu-flood %d", &uu_flood))
6369 else if (unformat (i, "forward %d", &forward))
6371 else if (unformat (i, "learn %d", &learn))
6373 else if (unformat (i, "arp-term %d", &arp_term))
6375 else if (unformat (i, "mac-age %d", &mac_age))
6377 else if (unformat (i, "del"))
6380 flood = uu_flood = forward = learn = 0;
6388 errmsg ("missing bridge domain");
6394 errmsg ("mac age must be less than 256 ");
6398 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6400 mp->bd_id = ntohl (bd_id);
6402 mp->uu_flood = uu_flood;
6403 mp->forward = forward;
6405 mp->arp_term = arp_term;
6406 mp->is_add = is_add;
6407 mp->mac_age = (u8) mac_age;
6415 api_l2fib_flush_bd (vat_main_t * vam)
6417 unformat_input_t *i = vam->input;
6418 vl_api_l2fib_flush_bd_t *mp;
6422 /* Parse args required to build the message */
6423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6425 if (unformat (i, "bd_id %d", &bd_id));
6432 errmsg ("missing bridge domain");
6436 M (L2FIB_FLUSH_BD, mp);
6438 mp->bd_id = htonl (bd_id);
6446 api_l2fib_flush_int (vat_main_t * vam)
6448 unformat_input_t *i = vam->input;
6449 vl_api_l2fib_flush_int_t *mp;
6450 u32 sw_if_index = ~0;
6453 /* Parse args required to build the message */
6454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6456 if (unformat (i, "sw_if_index %d", &sw_if_index));
6458 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6463 if (sw_if_index == ~0)
6465 errmsg ("missing interface name or sw_if_index");
6469 M (L2FIB_FLUSH_INT, mp);
6471 mp->sw_if_index = ntohl (sw_if_index);
6479 api_l2fib_add_del (vat_main_t * vam)
6481 unformat_input_t *i = vam->input;
6482 vl_api_l2fib_add_del_t *mp;
6488 u32 sw_if_index = ~0;
6489 u8 sw_if_index_set = 0;
6498 /* Parse args required to build the message */
6499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6501 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
6503 else if (unformat (i, "bd_id %d", &bd_id))
6505 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6506 sw_if_index_set = 1;
6507 else if (unformat (i, "sw_if"))
6509 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6512 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6513 sw_if_index_set = 1;
6518 else if (unformat (i, "static"))
6520 else if (unformat (i, "filter"))
6525 else if (unformat (i, "bvi"))
6530 else if (unformat (i, "del"))
6532 else if (unformat (i, "count %d", &count))
6540 errmsg ("missing mac address");
6546 errmsg ("missing bridge domain");
6550 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6552 errmsg ("missing interface name or sw_if_index");
6558 /* Turn on async mode */
6559 vam->async_mode = 1;
6560 vam->async_errors = 0;
6561 before = vat_time_now (vam);
6564 for (j = 0; j < count; j++)
6566 M (L2FIB_ADD_DEL, mp);
6569 mp->bd_id = ntohl (bd_id);
6570 mp->is_add = is_add;
6574 mp->sw_if_index = ntohl (sw_if_index);
6575 mp->static_mac = static_mac;
6576 mp->filter_mac = filter_mac;
6577 mp->bvi_mac = bvi_mac;
6579 increment_mac_address (&mac);
6586 vl_api_control_ping_t *mp_ping;
6589 /* Shut off async mode */
6590 vam->async_mode = 0;
6592 M (CONTROL_PING, mp_ping);
6595 timeout = vat_time_now (vam) + 1.0;
6596 while (vat_time_now (vam) < timeout)
6597 if (vam->result_ready == 1)
6602 if (vam->retval == -99)
6605 if (vam->async_errors > 0)
6607 errmsg ("%d asynchronous errors", vam->async_errors);
6610 vam->async_errors = 0;
6611 after = vat_time_now (vam);
6613 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6614 count, after - before, count / (after - before));
6620 /* Wait for a reply... */
6624 /* Return the good/bad news */
6625 return (vam->retval);
6629 api_bridge_domain_set_mac_age (vat_main_t * vam)
6631 unformat_input_t *i = vam->input;
6632 vl_api_bridge_domain_set_mac_age_t *mp;
6637 /* Parse args required to build the message */
6638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6640 if (unformat (i, "bd_id %d", &bd_id));
6641 else if (unformat (i, "mac-age %d", &mac_age));
6648 errmsg ("missing bridge domain");
6654 errmsg ("mac age must be less than 256 ");
6658 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6660 mp->bd_id = htonl (bd_id);
6661 mp->mac_age = (u8) mac_age;
6669 api_l2_flags (vat_main_t * vam)
6671 unformat_input_t *i = vam->input;
6672 vl_api_l2_flags_t *mp;
6675 u8 sw_if_index_set = 0;
6679 /* Parse args required to build the message */
6680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6682 if (unformat (i, "sw_if_index %d", &sw_if_index))
6683 sw_if_index_set = 1;
6684 else if (unformat (i, "sw_if"))
6686 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6689 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6690 sw_if_index_set = 1;
6695 else if (unformat (i, "learn"))
6697 else if (unformat (i, "forward"))
6699 else if (unformat (i, "flood"))
6701 else if (unformat (i, "uu-flood"))
6702 flags |= L2_UU_FLOOD;
6703 else if (unformat (i, "arp-term"))
6704 flags |= L2_ARP_TERM;
6705 else if (unformat (i, "off"))
6707 else if (unformat (i, "disable"))
6713 if (sw_if_index_set == 0)
6715 errmsg ("missing interface name or sw_if_index");
6721 mp->sw_if_index = ntohl (sw_if_index);
6722 mp->feature_bitmap = ntohl (flags);
6723 mp->is_set = is_set;
6731 api_bridge_flags (vat_main_t * vam)
6733 unformat_input_t *i = vam->input;
6734 vl_api_bridge_flags_t *mp;
6741 /* Parse args required to build the message */
6742 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6744 if (unformat (i, "bd_id %d", &bd_id))
6746 else if (unformat (i, "learn"))
6748 else if (unformat (i, "forward"))
6750 else if (unformat (i, "flood"))
6752 else if (unformat (i, "uu-flood"))
6753 flags |= L2_UU_FLOOD;
6754 else if (unformat (i, "arp-term"))
6755 flags |= L2_ARP_TERM;
6756 else if (unformat (i, "off"))
6758 else if (unformat (i, "disable"))
6766 errmsg ("missing bridge domain");
6770 M (BRIDGE_FLAGS, mp);
6772 mp->bd_id = ntohl (bd_id);
6773 mp->feature_bitmap = ntohl (flags);
6774 mp->is_set = is_set;
6782 api_bd_ip_mac_add_del (vat_main_t * vam)
6784 unformat_input_t *i = vam->input;
6785 vl_api_bd_ip_mac_add_del_t *mp;
6792 ip4_address_t v4addr;
6793 ip6_address_t v6addr;
6798 /* Parse args required to build the message */
6799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6801 if (unformat (i, "bd_id %d", &bd_id))
6805 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6809 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6814 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6818 else if (unformat (i, "del"))
6826 errmsg ("missing bridge domain");
6829 else if (ip_set == 0)
6831 errmsg ("missing IP address");
6834 else if (mac_set == 0)
6836 errmsg ("missing MAC address");
6840 M (BD_IP_MAC_ADD_DEL, mp);
6842 mp->bd_id = ntohl (bd_id);
6843 mp->is_ipv6 = is_ipv6;
6844 mp->is_add = is_add;
6846 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6848 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6849 clib_memcpy (mp->mac_address, macaddr, 6);
6856 api_tap_connect (vat_main_t * vam)
6858 unformat_input_t *i = vam->input;
6859 vl_api_tap_connect_t *mp;
6865 ip4_address_t ip4_address;
6867 int ip4_address_set = 0;
6868 ip6_address_t ip6_address;
6870 int ip6_address_set = 0;
6873 memset (mac_address, 0, sizeof (mac_address));
6875 /* Parse args required to build the message */
6876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6878 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6882 else if (unformat (i, "random-mac"))
6884 else if (unformat (i, "tapname %s", &tap_name))
6886 else if (unformat (i, "tag %s", &tag))
6888 else if (unformat (i, "address %U/%d",
6889 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6890 ip4_address_set = 1;
6891 else if (unformat (i, "address %U/%d",
6892 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6893 ip6_address_set = 1;
6900 errmsg ("missing tap name");
6903 if (vec_len (tap_name) > 63)
6905 errmsg ("tap name too long");
6908 vec_add1 (tap_name, 0);
6910 if (vec_len (tag) > 63)
6912 errmsg ("tag too long");
6916 /* Construct the API message */
6917 M (TAP_CONNECT, mp);
6919 mp->use_random_mac = random_mac;
6920 clib_memcpy (mp->mac_address, mac_address, 6);
6921 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6923 clib_memcpy (mp->tag, tag, vec_len (tag));
6925 if (ip4_address_set)
6927 mp->ip4_address_set = 1;
6928 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6929 mp->ip4_mask_width = ip4_mask_width;
6931 if (ip6_address_set)
6933 mp->ip6_address_set = 1;
6934 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6935 mp->ip6_mask_width = ip6_mask_width;
6938 vec_free (tap_name);
6944 /* Wait for a reply... */
6950 api_tap_modify (vat_main_t * vam)
6952 unformat_input_t *i = vam->input;
6953 vl_api_tap_modify_t *mp;
6958 u32 sw_if_index = ~0;
6959 u8 sw_if_index_set = 0;
6962 memset (mac_address, 0, sizeof (mac_address));
6964 /* Parse args required to build the message */
6965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6967 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6968 sw_if_index_set = 1;
6969 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6970 sw_if_index_set = 1;
6971 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6975 else if (unformat (i, "random-mac"))
6977 else if (unformat (i, "tapname %s", &tap_name))
6983 if (sw_if_index_set == 0)
6985 errmsg ("missing vpp interface name");
6990 errmsg ("missing tap name");
6993 if (vec_len (tap_name) > 63)
6995 errmsg ("tap name too long");
6997 vec_add1 (tap_name, 0);
6999 /* Construct the API message */
7002 mp->use_random_mac = random_mac;
7003 mp->sw_if_index = ntohl (sw_if_index);
7004 clib_memcpy (mp->mac_address, mac_address, 6);
7005 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7006 vec_free (tap_name);
7011 /* Wait for a reply... */
7017 api_tap_delete (vat_main_t * vam)
7019 unformat_input_t *i = vam->input;
7020 vl_api_tap_delete_t *mp;
7021 u32 sw_if_index = ~0;
7022 u8 sw_if_index_set = 0;
7025 /* Parse args required to build the message */
7026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7029 sw_if_index_set = 1;
7030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7031 sw_if_index_set = 1;
7036 if (sw_if_index_set == 0)
7038 errmsg ("missing vpp interface name");
7042 /* Construct the API message */
7045 mp->sw_if_index = ntohl (sw_if_index);
7050 /* Wait for a reply... */
7056 api_ip_table_add_del (vat_main_t * vam)
7058 unformat_input_t *i = vam->input;
7059 vl_api_ip_table_add_del_t *mp;
7065 /* Parse args required to build the message */
7066 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7068 if (unformat (i, "ipv6"))
7070 else if (unformat (i, "del"))
7072 else if (unformat (i, "add"))
7074 else if (unformat (i, "table %d", &table_id))
7078 clib_warning ("parse error '%U'", format_unformat_error, i);
7085 errmsg ("missing table-ID");
7089 /* Construct the API message */
7090 M (IP_TABLE_ADD_DEL, mp);
7092 mp->table_id = ntohl (table_id);
7093 mp->is_ipv6 = is_ipv6;
7094 mp->is_add = is_add;
7099 /* Wait for a reply... */
7106 api_ip_add_del_route (vat_main_t * vam)
7108 unformat_input_t *i = vam->input;
7109 vl_api_ip_add_del_route_t *mp;
7110 u32 sw_if_index = ~0, vrf_id = 0;
7112 u8 is_local = 0, is_drop = 0;
7113 u8 is_unreach = 0, is_prohibit = 0;
7114 u8 create_vrf_if_needed = 0;
7116 u32 next_hop_weight = 1;
7118 u8 is_multipath = 0;
7120 u8 address_length_set = 0;
7121 u32 next_hop_table_id = 0;
7122 u32 resolve_attempts = 0;
7123 u32 dst_address_length = 0;
7124 u8 next_hop_set = 0;
7125 ip4_address_t v4_dst_address, v4_next_hop_address;
7126 ip6_address_t v6_dst_address, v6_next_hop_address;
7130 u32 random_add_del = 0;
7131 u32 *random_vector = 0;
7133 u32 random_seed = 0xdeaddabe;
7134 u32 classify_table_index = ~0;
7136 u8 resolve_host = 0, resolve_attached = 0;
7137 mpls_label_t *next_hop_out_label_stack = NULL;
7138 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7139 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7141 /* Parse args required to build the message */
7142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7144 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7146 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7148 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
7153 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
7158 else if (unformat (i, "/%d", &dst_address_length))
7160 address_length_set = 1;
7163 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
7164 &v4_next_hop_address))
7168 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
7169 &v6_next_hop_address))
7173 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
7175 else if (unformat (i, "weight %d", &next_hop_weight))
7177 else if (unformat (i, "drop"))
7181 else if (unformat (i, "null-send-unreach"))
7185 else if (unformat (i, "null-send-prohibit"))
7189 else if (unformat (i, "local"))
7193 else if (unformat (i, "classify %d", &classify_table_index))
7197 else if (unformat (i, "del"))
7199 else if (unformat (i, "add"))
7201 else if (unformat (i, "not-last"))
7203 else if (unformat (i, "resolve-via-host"))
7205 else if (unformat (i, "resolve-via-attached"))
7206 resolve_attached = 1;
7207 else if (unformat (i, "multipath"))
7209 else if (unformat (i, "vrf %d", &vrf_id))
7211 else if (unformat (i, "create-vrf"))
7212 create_vrf_if_needed = 1;
7213 else if (unformat (i, "count %d", &count))
7215 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
7217 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7219 else if (unformat (i, "out-label %d", &next_hop_out_label))
7220 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7221 else if (unformat (i, "via-label %d", &next_hop_via_label))
7223 else if (unformat (i, "random"))
7225 else if (unformat (i, "seed %d", &random_seed))
7229 clib_warning ("parse error '%U'", format_unformat_error, i);
7234 if (!next_hop_set && !is_drop && !is_local &&
7235 !is_classify && !is_unreach && !is_prohibit &&
7236 MPLS_LABEL_INVALID == next_hop_via_label)
7239 ("next hop / local / drop / unreach / prohibit / classify not set");
7243 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
7245 errmsg ("next hop and next-hop via label set");
7248 if (address_set == 0)
7250 errmsg ("missing addresses");
7254 if (address_length_set == 0)
7256 errmsg ("missing address length");
7260 /* Generate a pile of unique, random routes */
7263 u32 this_random_address;
7264 random_hash = hash_create (count, sizeof (uword));
7266 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
7267 for (j = 0; j <= count; j++)
7271 this_random_address = random_u32 (&random_seed);
7272 this_random_address =
7273 clib_host_to_net_u32 (this_random_address);
7275 while (hash_get (random_hash, this_random_address));
7276 vec_add1 (random_vector, this_random_address);
7277 hash_set (random_hash, this_random_address, 1);
7279 hash_free (random_hash);
7280 v4_dst_address.as_u32 = random_vector[0];
7285 /* Turn on async mode */
7286 vam->async_mode = 1;
7287 vam->async_errors = 0;
7288 before = vat_time_now (vam);
7291 for (j = 0; j < count; j++)
7293 /* Construct the API message */
7294 M2 (IP_ADD_DEL_ROUTE, mp,
7295 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7297 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7298 mp->table_id = ntohl (vrf_id);
7299 mp->create_vrf_if_needed = create_vrf_if_needed;
7301 mp->is_add = is_add;
7302 mp->is_drop = is_drop;
7303 mp->is_unreach = is_unreach;
7304 mp->is_prohibit = is_prohibit;
7305 mp->is_ipv6 = is_ipv6;
7306 mp->is_local = is_local;
7307 mp->is_classify = is_classify;
7308 mp->is_multipath = is_multipath;
7309 mp->is_resolve_host = resolve_host;
7310 mp->is_resolve_attached = resolve_attached;
7311 mp->not_last = not_last;
7312 mp->next_hop_weight = next_hop_weight;
7313 mp->dst_address_length = dst_address_length;
7314 mp->next_hop_table_id = ntohl (next_hop_table_id);
7315 mp->classify_table_index = ntohl (classify_table_index);
7316 mp->next_hop_via_label = ntohl (next_hop_via_label);
7317 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7318 if (0 != mp->next_hop_n_out_labels)
7320 memcpy (mp->next_hop_out_label_stack,
7321 next_hop_out_label_stack,
7322 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7323 vec_free (next_hop_out_label_stack);
7328 clib_memcpy (mp->dst_address, &v6_dst_address,
7329 sizeof (v6_dst_address));
7331 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
7332 sizeof (v6_next_hop_address));
7333 increment_v6_address (&v6_dst_address);
7337 clib_memcpy (mp->dst_address, &v4_dst_address,
7338 sizeof (v4_dst_address));
7340 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
7341 sizeof (v4_next_hop_address));
7343 v4_dst_address.as_u32 = random_vector[j + 1];
7345 increment_v4_address (&v4_dst_address);
7349 /* If we receive SIGTERM, stop now... */
7354 /* When testing multiple add/del ops, use a control-ping to sync */
7357 vl_api_control_ping_t *mp_ping;
7361 /* Shut off async mode */
7362 vam->async_mode = 0;
7364 M (CONTROL_PING, mp_ping);
7367 timeout = vat_time_now (vam) + 1.0;
7368 while (vat_time_now (vam) < timeout)
7369 if (vam->result_ready == 1)
7374 if (vam->retval == -99)
7377 if (vam->async_errors > 0)
7379 errmsg ("%d asynchronous errors", vam->async_errors);
7382 vam->async_errors = 0;
7383 after = vat_time_now (vam);
7385 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7389 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7390 count, after - before, count / (after - before));
7396 /* Wait for a reply... */
7401 /* Return the good/bad news */
7402 return (vam->retval);
7406 api_ip_mroute_add_del (vat_main_t * vam)
7408 unformat_input_t *i = vam->input;
7409 vl_api_ip_mroute_add_del_t *mp;
7410 u32 sw_if_index = ~0, vrf_id = 0;
7413 u8 create_vrf_if_needed = 0;
7416 u32 grp_address_length = 0;
7417 ip4_address_t v4_grp_address, v4_src_address;
7418 ip6_address_t v6_grp_address, v6_src_address;
7419 mfib_itf_flags_t iflags = 0;
7420 mfib_entry_flags_t eflags = 0;
7423 /* Parse args required to build the message */
7424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7426 if (unformat (i, "sw_if_index %d", &sw_if_index))
7428 else if (unformat (i, "%U %U",
7429 unformat_ip4_address, &v4_src_address,
7430 unformat_ip4_address, &v4_grp_address))
7432 grp_address_length = 64;
7436 else if (unformat (i, "%U %U",
7437 unformat_ip6_address, &v6_src_address,
7438 unformat_ip6_address, &v6_grp_address))
7440 grp_address_length = 256;
7444 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
7446 memset (&v4_src_address, 0, sizeof (v4_src_address));
7447 grp_address_length = 32;
7451 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
7453 memset (&v6_src_address, 0, sizeof (v6_src_address));
7454 grp_address_length = 128;
7458 else if (unformat (i, "/%d", &grp_address_length))
7460 else if (unformat (i, "local"))
7464 else if (unformat (i, "del"))
7466 else if (unformat (i, "add"))
7468 else if (unformat (i, "vrf %d", &vrf_id))
7470 else if (unformat (i, "create-vrf"))
7471 create_vrf_if_needed = 1;
7472 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
7474 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
7478 clib_warning ("parse error '%U'", format_unformat_error, i);
7483 if (address_set == 0)
7485 errmsg ("missing addresses\n");
7489 /* Construct the API message */
7490 M (IP_MROUTE_ADD_DEL, mp);
7492 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7493 mp->table_id = ntohl (vrf_id);
7494 mp->create_vrf_if_needed = create_vrf_if_needed;
7496 mp->is_add = is_add;
7497 mp->is_ipv6 = is_ipv6;
7498 mp->is_local = is_local;
7499 mp->itf_flags = ntohl (iflags);
7500 mp->entry_flags = ntohl (eflags);
7501 mp->grp_address_length = grp_address_length;
7502 mp->grp_address_length = ntohs (mp->grp_address_length);
7506 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
7507 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
7511 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
7512 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
7518 /* Wait for a reply... */
7524 api_mpls_table_add_del (vat_main_t * vam)
7526 unformat_input_t *i = vam->input;
7527 vl_api_mpls_table_add_del_t *mp;
7532 /* Parse args required to build the message */
7533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7535 if (unformat (i, "table %d", &table_id))
7537 else if (unformat (i, "del"))
7539 else if (unformat (i, "add"))
7543 clib_warning ("parse error '%U'", format_unformat_error, i);
7550 errmsg ("missing table-ID");
7554 /* Construct the API message */
7555 M (MPLS_TABLE_ADD_DEL, mp);
7557 mp->mt_table_id = ntohl (table_id);
7558 mp->mt_is_add = is_add;
7563 /* Wait for a reply... */
7570 api_mpls_route_add_del (vat_main_t * vam)
7572 unformat_input_t *i = vam->input;
7573 vl_api_mpls_route_add_del_t *mp;
7574 u32 sw_if_index = ~0, table_id = 0;
7575 u8 create_table_if_needed = 0;
7577 u32 next_hop_weight = 1;
7578 u8 is_multipath = 0;
7579 u32 next_hop_table_id = 0;
7580 u8 next_hop_set = 0;
7581 ip4_address_t v4_next_hop_address = {
7584 ip6_address_t v6_next_hop_address = { {0} };
7588 u32 classify_table_index = ~0;
7590 u8 resolve_host = 0, resolve_attached = 0;
7591 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7592 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7593 mpls_label_t *next_hop_out_label_stack = NULL;
7594 mpls_label_t local_label = MPLS_LABEL_INVALID;
7596 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
7598 /* Parse args required to build the message */
7599 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7601 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7603 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7605 else if (unformat (i, "%d", &local_label))
7607 else if (unformat (i, "eos"))
7609 else if (unformat (i, "non-eos"))
7611 else if (unformat (i, "via %U", unformat_ip4_address,
7612 &v4_next_hop_address))
7615 next_hop_proto = DPO_PROTO_IP4;
7617 else if (unformat (i, "via %U", unformat_ip6_address,
7618 &v6_next_hop_address))
7621 next_hop_proto = DPO_PROTO_IP6;
7623 else if (unformat (i, "weight %d", &next_hop_weight))
7625 else if (unformat (i, "create-table"))
7626 create_table_if_needed = 1;
7627 else if (unformat (i, "classify %d", &classify_table_index))
7631 else if (unformat (i, "del"))
7633 else if (unformat (i, "add"))
7635 else if (unformat (i, "resolve-via-host"))
7637 else if (unformat (i, "resolve-via-attached"))
7638 resolve_attached = 1;
7639 else if (unformat (i, "multipath"))
7641 else if (unformat (i, "count %d", &count))
7643 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
7646 next_hop_proto = DPO_PROTO_IP4;
7648 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
7651 next_hop_proto = DPO_PROTO_IP6;
7653 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7655 else if (unformat (i, "via-label %d", &next_hop_via_label))
7657 else if (unformat (i, "out-label %d", &next_hop_out_label))
7658 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7661 clib_warning ("parse error '%U'", format_unformat_error, i);
7666 if (!next_hop_set && !is_classify)
7668 errmsg ("next hop / classify not set");
7672 if (MPLS_LABEL_INVALID == local_label)
7674 errmsg ("missing label");
7680 /* Turn on async mode */
7681 vam->async_mode = 1;
7682 vam->async_errors = 0;
7683 before = vat_time_now (vam);
7686 for (j = 0; j < count; j++)
7688 /* Construct the API message */
7689 M2 (MPLS_ROUTE_ADD_DEL, mp,
7690 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7692 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
7693 mp->mr_table_id = ntohl (table_id);
7694 mp->mr_create_table_if_needed = create_table_if_needed;
7696 mp->mr_is_add = is_add;
7697 mp->mr_next_hop_proto = next_hop_proto;
7698 mp->mr_is_classify = is_classify;
7699 mp->mr_is_multipath = is_multipath;
7700 mp->mr_is_resolve_host = resolve_host;
7701 mp->mr_is_resolve_attached = resolve_attached;
7702 mp->mr_next_hop_weight = next_hop_weight;
7703 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
7704 mp->mr_classify_table_index = ntohl (classify_table_index);
7705 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
7706 mp->mr_label = ntohl (local_label);
7707 mp->mr_eos = is_eos;
7709 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7710 if (0 != mp->mr_next_hop_n_out_labels)
7712 memcpy (mp->mr_next_hop_out_label_stack,
7713 next_hop_out_label_stack,
7714 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7715 vec_free (next_hop_out_label_stack);
7720 if (DPO_PROTO_IP4 == next_hop_proto)
7722 clib_memcpy (mp->mr_next_hop,
7723 &v4_next_hop_address,
7724 sizeof (v4_next_hop_address));
7726 else if (DPO_PROTO_IP6 == next_hop_proto)
7729 clib_memcpy (mp->mr_next_hop,
7730 &v6_next_hop_address,
7731 sizeof (v6_next_hop_address));
7738 /* If we receive SIGTERM, stop now... */
7743 /* When testing multiple add/del ops, use a control-ping to sync */
7746 vl_api_control_ping_t *mp_ping;
7750 /* Shut off async mode */
7751 vam->async_mode = 0;
7753 M (CONTROL_PING, mp_ping);
7756 timeout = vat_time_now (vam) + 1.0;
7757 while (vat_time_now (vam) < timeout)
7758 if (vam->result_ready == 1)
7763 if (vam->retval == -99)
7766 if (vam->async_errors > 0)
7768 errmsg ("%d asynchronous errors", vam->async_errors);
7771 vam->async_errors = 0;
7772 after = vat_time_now (vam);
7774 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7778 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7779 count, after - before, count / (after - before));
7785 /* Wait for a reply... */
7790 /* Return the good/bad news */
7791 return (vam->retval);
7795 api_mpls_ip_bind_unbind (vat_main_t * vam)
7797 unformat_input_t *i = vam->input;
7798 vl_api_mpls_ip_bind_unbind_t *mp;
7799 u32 ip_table_id = 0;
7800 u8 create_table_if_needed = 0;
7803 ip4_address_t v4_address;
7804 ip6_address_t v6_address;
7807 mpls_label_t local_label = MPLS_LABEL_INVALID;
7810 /* Parse args required to build the message */
7811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7813 if (unformat (i, "%U/%d", unformat_ip4_address,
7814 &v4_address, &address_length))
7819 else if (unformat (i, "%U/%d", unformat_ip6_address,
7820 &v6_address, &address_length))
7825 else if (unformat (i, "%d", &local_label))
7827 else if (unformat (i, "create-table"))
7828 create_table_if_needed = 1;
7829 else if (unformat (i, "table-id %d", &ip_table_id))
7831 else if (unformat (i, "unbind"))
7833 else if (unformat (i, "bind"))
7837 clib_warning ("parse error '%U'", format_unformat_error, i);
7844 errmsg ("IP addres not set");
7848 if (MPLS_LABEL_INVALID == local_label)
7850 errmsg ("missing label");
7854 /* Construct the API message */
7855 M (MPLS_IP_BIND_UNBIND, mp);
7857 mp->mb_create_table_if_needed = create_table_if_needed;
7858 mp->mb_is_bind = is_bind;
7859 mp->mb_is_ip4 = is_ip4;
7860 mp->mb_ip_table_id = ntohl (ip_table_id);
7861 mp->mb_mpls_table_id = 0;
7862 mp->mb_label = ntohl (local_label);
7863 mp->mb_address_length = address_length;
7866 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7868 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7873 /* Wait for a reply... */
7879 api_proxy_arp_add_del (vat_main_t * vam)
7881 unformat_input_t *i = vam->input;
7882 vl_api_proxy_arp_add_del_t *mp;
7885 ip4_address_t lo, hi;
7889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7891 if (unformat (i, "vrf %d", &vrf_id))
7893 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7894 unformat_ip4_address, &hi))
7896 else if (unformat (i, "del"))
7900 clib_warning ("parse error '%U'", format_unformat_error, i);
7907 errmsg ("address range not set");
7911 M (PROXY_ARP_ADD_DEL, mp);
7913 mp->vrf_id = ntohl (vrf_id);
7914 mp->is_add = is_add;
7915 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7916 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7924 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7926 unformat_input_t *i = vam->input;
7927 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7930 u8 sw_if_index_set = 0;
7933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7935 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7936 sw_if_index_set = 1;
7937 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7938 sw_if_index_set = 1;
7939 else if (unformat (i, "enable"))
7941 else if (unformat (i, "disable"))
7945 clib_warning ("parse error '%U'", format_unformat_error, i);
7950 if (sw_if_index_set == 0)
7952 errmsg ("missing interface name or sw_if_index");
7956 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7958 mp->sw_if_index = ntohl (sw_if_index);
7959 mp->enable_disable = enable;
7967 api_mpls_tunnel_add_del (vat_main_t * vam)
7969 unformat_input_t *i = vam->input;
7970 vl_api_mpls_tunnel_add_del_t *mp;
7974 u32 sw_if_index = ~0;
7975 u32 next_hop_sw_if_index = ~0;
7976 u32 next_hop_proto_is_ip4 = 1;
7978 u32 next_hop_table_id = 0;
7979 ip4_address_t v4_next_hop_address = {
7982 ip6_address_t v6_next_hop_address = { {0} };
7983 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7986 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7988 if (unformat (i, "add"))
7990 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7992 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7994 else if (unformat (i, "via %U",
7995 unformat_ip4_address, &v4_next_hop_address))
7997 next_hop_proto_is_ip4 = 1;
7999 else if (unformat (i, "via %U",
8000 unformat_ip6_address, &v6_next_hop_address))
8002 next_hop_proto_is_ip4 = 0;
8004 else if (unformat (i, "l2-only"))
8006 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8008 else if (unformat (i, "out-label %d", &next_hop_out_label))
8009 vec_add1 (labels, ntohl (next_hop_out_label));
8012 clib_warning ("parse error '%U'", format_unformat_error, i);
8017 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
8019 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
8020 mp->mt_sw_if_index = ntohl (sw_if_index);
8021 mp->mt_is_add = is_add;
8022 mp->mt_l2_only = l2_only;
8023 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
8024 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
8026 mp->mt_next_hop_n_out_labels = vec_len (labels);
8028 if (0 != mp->mt_next_hop_n_out_labels)
8030 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
8031 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
8035 if (next_hop_proto_is_ip4)
8037 clib_memcpy (mp->mt_next_hop,
8038 &v4_next_hop_address, sizeof (v4_next_hop_address));
8042 clib_memcpy (mp->mt_next_hop,
8043 &v6_next_hop_address, sizeof (v6_next_hop_address));
8052 api_sw_interface_set_unnumbered (vat_main_t * vam)
8054 unformat_input_t *i = vam->input;
8055 vl_api_sw_interface_set_unnumbered_t *mp;
8057 u32 unnum_sw_index = ~0;
8059 u8 sw_if_index_set = 0;
8062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8064 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8065 sw_if_index_set = 1;
8066 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8067 sw_if_index_set = 1;
8068 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8070 else if (unformat (i, "del"))
8074 clib_warning ("parse error '%U'", format_unformat_error, i);
8079 if (sw_if_index_set == 0)
8081 errmsg ("missing interface name or sw_if_index");
8085 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8087 mp->sw_if_index = ntohl (sw_if_index);
8088 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8089 mp->is_add = is_add;
8097 api_ip_neighbor_add_del (vat_main_t * vam)
8099 unformat_input_t *i = vam->input;
8100 vl_api_ip_neighbor_add_del_t *mp;
8102 u8 sw_if_index_set = 0;
8105 u8 is_no_fib_entry = 0;
8108 u8 v4_address_set = 0;
8109 u8 v6_address_set = 0;
8110 ip4_address_t v4address;
8111 ip6_address_t v6address;
8114 memset (mac_address, 0, sizeof (mac_address));
8116 /* Parse args required to build the message */
8117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8119 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8123 else if (unformat (i, "del"))
8126 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8127 sw_if_index_set = 1;
8128 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8129 sw_if_index_set = 1;
8130 else if (unformat (i, "is_static"))
8132 else if (unformat (i, "no-fib-entry"))
8133 is_no_fib_entry = 1;
8134 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
8136 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
8140 clib_warning ("parse error '%U'", format_unformat_error, i);
8145 if (sw_if_index_set == 0)
8147 errmsg ("missing interface name or sw_if_index");
8150 if (v4_address_set && v6_address_set)
8152 errmsg ("both v4 and v6 addresses set");
8155 if (!v4_address_set && !v6_address_set)
8157 errmsg ("no address set");
8161 /* Construct the API message */
8162 M (IP_NEIGHBOR_ADD_DEL, mp);
8164 mp->sw_if_index = ntohl (sw_if_index);
8165 mp->is_add = is_add;
8166 mp->is_static = is_static;
8167 mp->is_no_adj_fib = is_no_fib_entry;
8169 clib_memcpy (mp->mac_address, mac_address, 6);
8173 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
8177 /* mp->is_ipv6 = 0; via memset in M macro above */
8178 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
8184 /* Wait for a reply, return good/bad news */
8190 api_reset_vrf (vat_main_t * vam)
8192 unformat_input_t *i = vam->input;
8193 vl_api_reset_vrf_t *mp;
8199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8201 if (unformat (i, "vrf %d", &vrf_id))
8203 else if (unformat (i, "ipv6"))
8207 clib_warning ("parse error '%U'", format_unformat_error, i);
8212 if (vrf_id_set == 0)
8214 errmsg ("missing vrf id");
8220 mp->vrf_id = ntohl (vrf_id);
8221 mp->is_ipv6 = is_ipv6;
8229 api_create_vlan_subif (vat_main_t * vam)
8231 unformat_input_t *i = vam->input;
8232 vl_api_create_vlan_subif_t *mp;
8234 u8 sw_if_index_set = 0;
8239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8241 if (unformat (i, "sw_if_index %d", &sw_if_index))
8242 sw_if_index_set = 1;
8244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8245 sw_if_index_set = 1;
8246 else if (unformat (i, "vlan %d", &vlan_id))
8250 clib_warning ("parse error '%U'", format_unformat_error, i);
8255 if (sw_if_index_set == 0)
8257 errmsg ("missing interface name or sw_if_index");
8261 if (vlan_id_set == 0)
8263 errmsg ("missing vlan_id");
8266 M (CREATE_VLAN_SUBIF, mp);
8268 mp->sw_if_index = ntohl (sw_if_index);
8269 mp->vlan_id = ntohl (vlan_id);
8276 #define foreach_create_subif_bit \
8283 _(outer_vlan_id_any) \
8284 _(inner_vlan_id_any)
8287 api_create_subif (vat_main_t * vam)
8289 unformat_input_t *i = vam->input;
8290 vl_api_create_subif_t *mp;
8292 u8 sw_if_index_set = 0;
8299 u32 exact_match = 0;
8300 u32 default_sub = 0;
8301 u32 outer_vlan_id_any = 0;
8302 u32 inner_vlan_id_any = 0;
8304 u16 outer_vlan_id = 0;
8305 u16 inner_vlan_id = 0;
8308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8310 if (unformat (i, "sw_if_index %d", &sw_if_index))
8311 sw_if_index_set = 1;
8313 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8314 sw_if_index_set = 1;
8315 else if (unformat (i, "sub_id %d", &sub_id))
8317 else if (unformat (i, "outer_vlan_id %d", &tmp))
8318 outer_vlan_id = tmp;
8319 else if (unformat (i, "inner_vlan_id %d", &tmp))
8320 inner_vlan_id = tmp;
8322 #define _(a) else if (unformat (i, #a)) a = 1 ;
8323 foreach_create_subif_bit
8327 clib_warning ("parse error '%U'", format_unformat_error, i);
8332 if (sw_if_index_set == 0)
8334 errmsg ("missing interface name or sw_if_index");
8338 if (sub_id_set == 0)
8340 errmsg ("missing sub_id");
8343 M (CREATE_SUBIF, mp);
8345 mp->sw_if_index = ntohl (sw_if_index);
8346 mp->sub_id = ntohl (sub_id);
8348 #define _(a) mp->a = a;
8349 foreach_create_subif_bit;
8352 mp->outer_vlan_id = ntohs (outer_vlan_id);
8353 mp->inner_vlan_id = ntohs (inner_vlan_id);
8361 api_oam_add_del (vat_main_t * vam)
8363 unformat_input_t *i = vam->input;
8364 vl_api_oam_add_del_t *mp;
8367 ip4_address_t src, dst;
8372 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8374 if (unformat (i, "vrf %d", &vrf_id))
8376 else if (unformat (i, "src %U", unformat_ip4_address, &src))
8378 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
8380 else if (unformat (i, "del"))
8384 clib_warning ("parse error '%U'", format_unformat_error, i);
8391 errmsg ("missing src addr");
8397 errmsg ("missing dst addr");
8401 M (OAM_ADD_DEL, mp);
8403 mp->vrf_id = ntohl (vrf_id);
8404 mp->is_add = is_add;
8405 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
8406 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
8414 api_reset_fib (vat_main_t * vam)
8416 unformat_input_t *i = vam->input;
8417 vl_api_reset_fib_t *mp;
8423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8425 if (unformat (i, "vrf %d", &vrf_id))
8427 else if (unformat (i, "ipv6"))
8431 clib_warning ("parse error '%U'", format_unformat_error, i);
8436 if (vrf_id_set == 0)
8438 errmsg ("missing vrf id");
8444 mp->vrf_id = ntohl (vrf_id);
8445 mp->is_ipv6 = is_ipv6;
8453 api_dhcp_proxy_config (vat_main_t * vam)
8455 unformat_input_t *i = vam->input;
8456 vl_api_dhcp_proxy_config_t *mp;
8458 u32 server_vrf_id = 0;
8460 u8 v4_address_set = 0;
8461 u8 v6_address_set = 0;
8462 ip4_address_t v4address;
8463 ip6_address_t v6address;
8464 u8 v4_src_address_set = 0;
8465 u8 v6_src_address_set = 0;
8466 ip4_address_t v4srcaddress;
8467 ip6_address_t v6srcaddress;
8470 /* Parse args required to build the message */
8471 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8473 if (unformat (i, "del"))
8475 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
8477 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
8479 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
8481 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
8483 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
8484 v4_src_address_set = 1;
8485 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
8486 v6_src_address_set = 1;
8491 if (v4_address_set && v6_address_set)
8493 errmsg ("both v4 and v6 server addresses set");
8496 if (!v4_address_set && !v6_address_set)
8498 errmsg ("no server addresses set");
8502 if (v4_src_address_set && v6_src_address_set)
8504 errmsg ("both v4 and v6 src addresses set");
8507 if (!v4_src_address_set && !v6_src_address_set)
8509 errmsg ("no src addresses set");
8513 if (!(v4_src_address_set && v4_address_set) &&
8514 !(v6_src_address_set && v6_address_set))
8516 errmsg ("no matching server and src addresses set");
8520 /* Construct the API message */
8521 M (DHCP_PROXY_CONFIG, mp);
8523 mp->is_add = is_add;
8524 mp->rx_vrf_id = ntohl (rx_vrf_id);
8525 mp->server_vrf_id = ntohl (server_vrf_id);
8529 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
8530 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
8534 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
8535 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
8541 /* Wait for a reply, return good/bad news */
8546 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
8547 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
8550 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
8552 vat_main_t *vam = &vat_main;
8553 u32 i, count = mp->count;
8554 vl_api_dhcp_server_t *s;
8558 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
8559 ntohl (mp->rx_vrf_id),
8560 format_ip6_address, mp->dhcp_src_address,
8561 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
8564 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
8565 ntohl (mp->rx_vrf_id),
8566 format_ip4_address, mp->dhcp_src_address,
8567 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
8569 for (i = 0; i < count; i++)
8571 s = &mp->servers[i];
8575 " Server Table-ID %d, Server Address %U",
8576 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
8579 " Server Table-ID %d, Server Address %U",
8580 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
8584 static void vl_api_dhcp_proxy_details_t_handler_json
8585 (vl_api_dhcp_proxy_details_t * mp)
8587 vat_main_t *vam = &vat_main;
8588 vat_json_node_t *node = NULL;
8589 u32 i, count = mp->count;
8591 struct in6_addr ip6;
8592 vl_api_dhcp_server_t *s;
8594 if (VAT_JSON_ARRAY != vam->json_tree.type)
8596 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8597 vat_json_init_array (&vam->json_tree);
8599 node = vat_json_array_add (&vam->json_tree);
8601 vat_json_init_object (node);
8602 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
8603 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
8604 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
8608 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
8609 vat_json_object_add_ip6 (node, "src_address", ip6);
8613 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
8614 vat_json_object_add_ip4 (node, "src_address", ip4);
8617 for (i = 0; i < count; i++)
8619 s = &mp->servers[i];
8621 vat_json_object_add_uint (node, "server-table-id",
8622 ntohl (s->server_vrf_id));
8626 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
8627 vat_json_object_add_ip4 (node, "src_address", ip4);
8631 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
8632 vat_json_object_add_ip6 (node, "server_address", ip6);
8638 api_dhcp_proxy_dump (vat_main_t * vam)
8640 unformat_input_t *i = vam->input;
8641 vl_api_control_ping_t *mp_ping;
8642 vl_api_dhcp_proxy_dump_t *mp;
8646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8648 if (unformat (i, "ipv6"))
8652 clib_warning ("parse error '%U'", format_unformat_error, i);
8657 M (DHCP_PROXY_DUMP, mp);
8659 mp->is_ip6 = is_ipv6;
8662 /* Use a control ping for synchronization */
8663 M (CONTROL_PING, mp_ping);
8671 api_dhcp_proxy_set_vss (vat_main_t * vam)
8673 unformat_input_t *i = vam->input;
8674 vl_api_dhcp_proxy_set_vss_t *mp;
8685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8687 if (unformat (i, "tbl_id %d", &tbl_id))
8689 if (unformat (i, "fib_id %d", &fib_id))
8691 if (unformat (i, "oui %d", &oui))
8693 else if (unformat (i, "ipv6"))
8695 else if (unformat (i, "del"))
8699 clib_warning ("parse error '%U'", format_unformat_error, i);
8704 if (tbl_id_set == 0)
8706 errmsg ("missing tbl id");
8710 if (fib_id_set == 0)
8712 errmsg ("missing fib id");
8717 errmsg ("missing oui");
8721 M (DHCP_PROXY_SET_VSS, mp);
8722 mp->tbl_id = ntohl (tbl_id);
8723 mp->fib_id = ntohl (fib_id);
8724 mp->oui = ntohl (oui);
8725 mp->is_ipv6 = is_ipv6;
8726 mp->is_add = is_add;
8734 api_dhcp_client_config (vat_main_t * vam)
8736 unformat_input_t *i = vam->input;
8737 vl_api_dhcp_client_config_t *mp;
8739 u8 sw_if_index_set = 0;
8742 u8 disable_event = 0;
8745 /* Parse args required to build the message */
8746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8748 if (unformat (i, "del"))
8751 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8752 sw_if_index_set = 1;
8753 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8754 sw_if_index_set = 1;
8755 else if (unformat (i, "hostname %s", &hostname))
8757 else if (unformat (i, "disable_event"))
8763 if (sw_if_index_set == 0)
8765 errmsg ("missing interface name or sw_if_index");
8769 if (vec_len (hostname) > 63)
8771 errmsg ("hostname too long");
8773 vec_add1 (hostname, 0);
8775 /* Construct the API message */
8776 M (DHCP_CLIENT_CONFIG, mp);
8778 mp->sw_if_index = htonl (sw_if_index);
8779 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
8780 vec_free (hostname);
8781 mp->is_add = is_add;
8782 mp->want_dhcp_event = disable_event ? 0 : 1;
8783 mp->pid = htonl (getpid ());
8788 /* Wait for a reply, return good/bad news */
8794 api_set_ip_flow_hash (vat_main_t * vam)
8796 unformat_input_t *i = vam->input;
8797 vl_api_set_ip_flow_hash_t *mp;
8809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8811 if (unformat (i, "vrf %d", &vrf_id))
8813 else if (unformat (i, "ipv6"))
8815 else if (unformat (i, "src"))
8817 else if (unformat (i, "dst"))
8819 else if (unformat (i, "sport"))
8821 else if (unformat (i, "dport"))
8823 else if (unformat (i, "proto"))
8825 else if (unformat (i, "reverse"))
8830 clib_warning ("parse error '%U'", format_unformat_error, i);
8835 if (vrf_id_set == 0)
8837 errmsg ("missing vrf id");
8841 M (SET_IP_FLOW_HASH, mp);
8847 mp->reverse = reverse;
8848 mp->vrf_id = ntohl (vrf_id);
8849 mp->is_ipv6 = is_ipv6;
8857 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
8859 unformat_input_t *i = vam->input;
8860 vl_api_sw_interface_ip6_enable_disable_t *mp;
8862 u8 sw_if_index_set = 0;
8866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8868 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8869 sw_if_index_set = 1;
8870 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8871 sw_if_index_set = 1;
8872 else if (unformat (i, "enable"))
8874 else if (unformat (i, "disable"))
8878 clib_warning ("parse error '%U'", format_unformat_error, i);
8883 if (sw_if_index_set == 0)
8885 errmsg ("missing interface name or sw_if_index");
8889 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8891 mp->sw_if_index = ntohl (sw_if_index);
8892 mp->enable = enable;
8900 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8902 unformat_input_t *i = vam->input;
8903 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8905 u8 sw_if_index_set = 0;
8906 u8 v6_address_set = 0;
8907 ip6_address_t v6address;
8910 /* Parse args required to build the message */
8911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8913 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8914 sw_if_index_set = 1;
8915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8916 sw_if_index_set = 1;
8917 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8923 if (sw_if_index_set == 0)
8925 errmsg ("missing interface name or sw_if_index");
8928 if (!v6_address_set)
8930 errmsg ("no address set");
8934 /* Construct the API message */
8935 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8937 mp->sw_if_index = ntohl (sw_if_index);
8938 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8943 /* Wait for a reply, return good/bad news */
8949 api_ip6nd_proxy_add_del (vat_main_t * vam)
8951 unformat_input_t *i = vam->input;
8952 vl_api_ip6nd_proxy_add_del_t *mp;
8953 u32 sw_if_index = ~0;
8954 u8 v6_address_set = 0;
8955 ip6_address_t v6address;
8959 /* Parse args required to build the message */
8960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8962 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8964 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8966 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8968 if (unformat (i, "del"))
8972 clib_warning ("parse error '%U'", format_unformat_error, i);
8977 if (sw_if_index == ~0)
8979 errmsg ("missing interface name or sw_if_index");
8982 if (!v6_address_set)
8984 errmsg ("no address set");
8988 /* Construct the API message */
8989 M (IP6ND_PROXY_ADD_DEL, mp);
8991 mp->is_del = is_del;
8992 mp->sw_if_index = ntohl (sw_if_index);
8993 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8998 /* Wait for a reply, return good/bad news */
9004 api_ip6nd_proxy_dump (vat_main_t * vam)
9006 vl_api_ip6nd_proxy_dump_t *mp;
9007 vl_api_control_ping_t *mp_ping;
9010 M (IP6ND_PROXY_DUMP, mp);
9014 /* Use a control ping for synchronization */
9015 M (CONTROL_PING, mp_ping);
9022 static void vl_api_ip6nd_proxy_details_t_handler
9023 (vl_api_ip6nd_proxy_details_t * mp)
9025 vat_main_t *vam = &vat_main;
9027 print (vam->ofp, "host %U sw_if_index %d",
9028 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
9031 static void vl_api_ip6nd_proxy_details_t_handler_json
9032 (vl_api_ip6nd_proxy_details_t * mp)
9034 vat_main_t *vam = &vat_main;
9035 struct in6_addr ip6;
9036 vat_json_node_t *node = NULL;
9038 if (VAT_JSON_ARRAY != vam->json_tree.type)
9040 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9041 vat_json_init_array (&vam->json_tree);
9043 node = vat_json_array_add (&vam->json_tree);
9045 vat_json_init_object (node);
9046 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9048 clib_memcpy (&ip6, mp->address, sizeof (ip6));
9049 vat_json_object_add_ip6 (node, "host", ip6);
9053 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9055 unformat_input_t *i = vam->input;
9056 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9058 u8 sw_if_index_set = 0;
9059 u32 address_length = 0;
9060 u8 v6_address_set = 0;
9061 ip6_address_t v6address;
9063 u8 no_advertise = 0;
9065 u8 no_autoconfig = 0;
9068 u32 val_lifetime = 0;
9069 u32 pref_lifetime = 0;
9072 /* Parse args required to build the message */
9073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9075 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9076 sw_if_index_set = 1;
9077 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9078 sw_if_index_set = 1;
9079 else if (unformat (i, "%U/%d",
9080 unformat_ip6_address, &v6address, &address_length))
9082 else if (unformat (i, "val_life %d", &val_lifetime))
9084 else if (unformat (i, "pref_life %d", &pref_lifetime))
9086 else if (unformat (i, "def"))
9088 else if (unformat (i, "noadv"))
9090 else if (unformat (i, "offl"))
9092 else if (unformat (i, "noauto"))
9094 else if (unformat (i, "nolink"))
9096 else if (unformat (i, "isno"))
9100 clib_warning ("parse error '%U'", format_unformat_error, i);
9105 if (sw_if_index_set == 0)
9107 errmsg ("missing interface name or sw_if_index");
9110 if (!v6_address_set)
9112 errmsg ("no address set");
9116 /* Construct the API message */
9117 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9119 mp->sw_if_index = ntohl (sw_if_index);
9120 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9121 mp->address_length = address_length;
9122 mp->use_default = use_default;
9123 mp->no_advertise = no_advertise;
9124 mp->off_link = off_link;
9125 mp->no_autoconfig = no_autoconfig;
9126 mp->no_onlink = no_onlink;
9128 mp->val_lifetime = ntohl (val_lifetime);
9129 mp->pref_lifetime = ntohl (pref_lifetime);
9134 /* Wait for a reply, return good/bad news */
9140 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9142 unformat_input_t *i = vam->input;
9143 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9145 u8 sw_if_index_set = 0;
9150 u8 send_unicast = 0;
9153 u8 default_router = 0;
9154 u32 max_interval = 0;
9155 u32 min_interval = 0;
9157 u32 initial_count = 0;
9158 u32 initial_interval = 0;
9162 /* Parse args required to build the message */
9163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9165 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9166 sw_if_index_set = 1;
9167 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9168 sw_if_index_set = 1;
9169 else if (unformat (i, "maxint %d", &max_interval))
9171 else if (unformat (i, "minint %d", &min_interval))
9173 else if (unformat (i, "life %d", &lifetime))
9175 else if (unformat (i, "count %d", &initial_count))
9177 else if (unformat (i, "interval %d", &initial_interval))
9179 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9181 else if (unformat (i, "managed"))
9183 else if (unformat (i, "other"))
9185 else if (unformat (i, "ll"))
9187 else if (unformat (i, "send"))
9189 else if (unformat (i, "cease"))
9191 else if (unformat (i, "isno"))
9193 else if (unformat (i, "def"))
9197 clib_warning ("parse error '%U'", format_unformat_error, i);
9202 if (sw_if_index_set == 0)
9204 errmsg ("missing interface name or sw_if_index");
9208 /* Construct the API message */
9209 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9211 mp->sw_if_index = ntohl (sw_if_index);
9212 mp->max_interval = ntohl (max_interval);
9213 mp->min_interval = ntohl (min_interval);
9214 mp->lifetime = ntohl (lifetime);
9215 mp->initial_count = ntohl (initial_count);
9216 mp->initial_interval = ntohl (initial_interval);
9217 mp->suppress = suppress;
9218 mp->managed = managed;
9220 mp->ll_option = ll_option;
9221 mp->send_unicast = send_unicast;
9224 mp->default_router = default_router;
9229 /* Wait for a reply, return good/bad news */
9235 api_set_arp_neighbor_limit (vat_main_t * vam)
9237 unformat_input_t *i = vam->input;
9238 vl_api_set_arp_neighbor_limit_t *mp;
9244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9246 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9248 else if (unformat (i, "ipv6"))
9252 clib_warning ("parse error '%U'", format_unformat_error, i);
9259 errmsg ("missing limit value");
9263 M (SET_ARP_NEIGHBOR_LIMIT, mp);
9265 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
9266 mp->is_ipv6 = is_ipv6;
9274 api_l2_patch_add_del (vat_main_t * vam)
9276 unformat_input_t *i = vam->input;
9277 vl_api_l2_patch_add_del_t *mp;
9279 u8 rx_sw_if_index_set = 0;
9281 u8 tx_sw_if_index_set = 0;
9285 /* Parse args required to build the message */
9286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9288 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9289 rx_sw_if_index_set = 1;
9290 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9291 tx_sw_if_index_set = 1;
9292 else if (unformat (i, "rx"))
9294 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9296 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9298 rx_sw_if_index_set = 1;
9303 else if (unformat (i, "tx"))
9305 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9307 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9309 tx_sw_if_index_set = 1;
9314 else if (unformat (i, "del"))
9320 if (rx_sw_if_index_set == 0)
9322 errmsg ("missing rx interface name or rx_sw_if_index");
9326 if (tx_sw_if_index_set == 0)
9328 errmsg ("missing tx interface name or tx_sw_if_index");
9332 M (L2_PATCH_ADD_DEL, mp);
9334 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9335 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9336 mp->is_add = is_add;
9344 u8 localsid_addr[16];
9353 api_sr_localsid_add_del (vat_main_t * vam)
9355 unformat_input_t *i = vam->input;
9356 vl_api_sr_localsid_add_del_t *mp;
9359 ip6_address_t localsid;
9363 u32 fib_table = ~(u32) 0;
9364 ip6_address_t next_hop;
9366 bool nexthop_set = 0;
9370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9372 if (unformat (i, "del"))
9374 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9375 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
9377 else if (unformat (i, "behavior %u", &behavior));
9378 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9379 else if (unformat (i, "fib-table %u", &fib_table));
9380 else if (unformat (i, "end.psp %u", &behavior));
9385 M (SR_LOCALSID_ADD_DEL, mp);
9387 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
9389 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
9390 mp->behavior = behavior;
9391 mp->sw_if_index = ntohl (sw_if_index);
9392 mp->fib_table = ntohl (fib_table);
9393 mp->end_psp = end_psp;
9394 mp->is_del = is_del;
9402 api_ioam_enable (vat_main_t * vam)
9404 unformat_input_t *input = vam->input;
9405 vl_api_ioam_enable_t *mp;
9407 int has_trace_option = 0;
9408 int has_pot_option = 0;
9409 int has_seqno_option = 0;
9410 int has_analyse_option = 0;
9413 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9415 if (unformat (input, "trace"))
9416 has_trace_option = 1;
9417 else if (unformat (input, "pot"))
9419 else if (unformat (input, "seqno"))
9420 has_seqno_option = 1;
9421 else if (unformat (input, "analyse"))
9422 has_analyse_option = 1;
9426 M (IOAM_ENABLE, mp);
9427 mp->id = htons (id);
9428 mp->seqno = has_seqno_option;
9429 mp->analyse = has_analyse_option;
9430 mp->pot_enable = has_pot_option;
9431 mp->trace_enable = has_trace_option;
9440 api_ioam_disable (vat_main_t * vam)
9442 vl_api_ioam_disable_t *mp;
9445 M (IOAM_DISABLE, mp);
9451 #define foreach_tcp_proto_field \
9455 #define foreach_udp_proto_field \
9459 #define foreach_ip4_proto_field \
9471 u16 src_port, dst_port;
9474 #if VPP_API_TEST_BUILTIN == 0
9476 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9478 u8 **maskp = va_arg (*args, u8 **);
9480 u8 found_something = 0;
9483 #define _(a) u8 a=0;
9484 foreach_tcp_proto_field;
9487 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9490 #define _(a) else if (unformat (input, #a)) a=1;
9491 foreach_tcp_proto_field
9497 #define _(a) found_something += a;
9498 foreach_tcp_proto_field;
9501 if (found_something == 0)
9504 vec_validate (mask, sizeof (*tcp) - 1);
9506 tcp = (tcp_header_t *) mask;
9508 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
9509 foreach_tcp_proto_field;
9517 unformat_udp_mask (unformat_input_t * input, va_list * args)
9519 u8 **maskp = va_arg (*args, u8 **);
9521 u8 found_something = 0;
9524 #define _(a) u8 a=0;
9525 foreach_udp_proto_field;
9528 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9531 #define _(a) else if (unformat (input, #a)) a=1;
9532 foreach_udp_proto_field
9538 #define _(a) found_something += a;
9539 foreach_udp_proto_field;
9542 if (found_something == 0)
9545 vec_validate (mask, sizeof (*udp) - 1);
9547 udp = (udp_header_t *) mask;
9549 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
9550 foreach_udp_proto_field;
9558 unformat_l4_mask (unformat_input_t * input, va_list * args)
9560 u8 **maskp = va_arg (*args, u8 **);
9561 u16 src_port = 0, dst_port = 0;
9562 tcpudp_header_t *tcpudp;
9564 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9566 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9568 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9570 else if (unformat (input, "src_port"))
9572 else if (unformat (input, "dst_port"))
9578 if (!src_port && !dst_port)
9582 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9584 tcpudp = (tcpudp_header_t *) mask;
9585 tcpudp->src_port = src_port;
9586 tcpudp->dst_port = dst_port;
9594 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9596 u8 **maskp = va_arg (*args, u8 **);
9598 u8 found_something = 0;
9601 #define _(a) u8 a=0;
9602 foreach_ip4_proto_field;
9608 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9610 if (unformat (input, "version"))
9612 else if (unformat (input, "hdr_length"))
9614 else if (unformat (input, "src"))
9616 else if (unformat (input, "dst"))
9618 else if (unformat (input, "proto"))
9621 #define _(a) else if (unformat (input, #a)) a=1;
9622 foreach_ip4_proto_field
9628 #define _(a) found_something += a;
9629 foreach_ip4_proto_field;
9632 if (found_something == 0)
9635 vec_validate (mask, sizeof (*ip) - 1);
9637 ip = (ip4_header_t *) mask;
9639 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9640 foreach_ip4_proto_field;
9643 ip->ip_version_and_header_length = 0;
9646 ip->ip_version_and_header_length |= 0xF0;
9649 ip->ip_version_and_header_length |= 0x0F;
9655 #define foreach_ip6_proto_field \
9663 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9665 u8 **maskp = va_arg (*args, u8 **);
9667 u8 found_something = 0;
9669 u32 ip_version_traffic_class_and_flow_label;
9671 #define _(a) u8 a=0;
9672 foreach_ip6_proto_field;
9675 u8 traffic_class = 0;
9678 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9680 if (unformat (input, "version"))
9682 else if (unformat (input, "traffic-class"))
9684 else if (unformat (input, "flow-label"))
9686 else if (unformat (input, "src"))
9688 else if (unformat (input, "dst"))
9690 else if (unformat (input, "proto"))
9693 #define _(a) else if (unformat (input, #a)) a=1;
9694 foreach_ip6_proto_field
9700 #define _(a) found_something += a;
9701 foreach_ip6_proto_field;
9704 if (found_something == 0)
9707 vec_validate (mask, sizeof (*ip) - 1);
9709 ip = (ip6_header_t *) mask;
9711 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9712 foreach_ip6_proto_field;
9715 ip_version_traffic_class_and_flow_label = 0;
9718 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9721 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9724 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9726 ip->ip_version_traffic_class_and_flow_label =
9727 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9734 unformat_l3_mask (unformat_input_t * input, va_list * args)
9736 u8 **maskp = va_arg (*args, u8 **);
9738 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9740 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9742 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9751 unformat_l2_mask (unformat_input_t * input, va_list * args)
9753 u8 **maskp = va_arg (*args, u8 **);
9768 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9770 if (unformat (input, "src"))
9772 else if (unformat (input, "dst"))
9774 else if (unformat (input, "proto"))
9776 else if (unformat (input, "tag1"))
9778 else if (unformat (input, "tag2"))
9780 else if (unformat (input, "ignore-tag1"))
9782 else if (unformat (input, "ignore-tag2"))
9784 else if (unformat (input, "cos1"))
9786 else if (unformat (input, "cos2"))
9788 else if (unformat (input, "dot1q"))
9790 else if (unformat (input, "dot1ad"))
9795 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9796 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9799 if (tag1 || ignore_tag1 || cos1 || dot1q)
9801 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9804 vec_validate (mask, len - 1);
9807 memset (mask, 0xff, 6);
9810 memset (mask + 6, 0xff, 6);
9814 /* inner vlan tag */
9823 mask[21] = mask[20] = 0xff;
9844 mask[16] = mask[17] = 0xff;
9854 mask[12] = mask[13] = 0xff;
9861 unformat_classify_mask (unformat_input_t * input, va_list * args)
9863 u8 **maskp = va_arg (*args, u8 **);
9864 u32 *skipp = va_arg (*args, u32 *);
9865 u32 *matchp = va_arg (*args, u32 *);
9873 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9875 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9877 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9879 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9881 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9895 if (mask || l2 || l3 || l4)
9899 /* "With a free Ethernet header in every package" */
9901 vec_validate (l2, 13);
9905 vec_append (mask, l3);
9910 vec_append (mask, l4);
9915 /* Scan forward looking for the first significant mask octet */
9916 for (i = 0; i < vec_len (mask); i++)
9920 /* compute (skip, match) params */
9921 *skipp = i / sizeof (u32x4);
9922 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9924 /* Pad mask to an even multiple of the vector size */
9925 while (vec_len (mask) % sizeof (u32x4))
9928 match = vec_len (mask) / sizeof (u32x4);
9930 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9932 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9933 if (*tmp || *(tmp + 1))
9938 clib_warning ("BUG: match 0");
9940 _vec_len (mask) = match * sizeof (u32x4);
9950 #endif /* VPP_API_TEST_BUILTIN */
9952 #define foreach_l2_next \
9954 _(ethernet, ETHERNET_INPUT) \
9959 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9961 u32 *miss_next_indexp = va_arg (*args, u32 *);
9966 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9970 if (unformat (input, "%d", &tmp))
9979 *miss_next_indexp = next_index;
9983 #define foreach_ip_next \
9989 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9991 u32 *miss_next_indexp = va_arg (*args, u32 *);
9996 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10000 if (unformat (input, "%d", &tmp))
10009 *miss_next_indexp = next_index;
10013 #define foreach_acl_next \
10017 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10019 u32 *miss_next_indexp = va_arg (*args, u32 *);
10020 u32 next_index = 0;
10024 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10028 if (unformat (input, "permit"))
10033 else if (unformat (input, "%d", &tmp))
10042 *miss_next_indexp = next_index;
10047 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10049 u32 *r = va_arg (*args, u32 *);
10051 if (unformat (input, "conform-color"))
10052 *r = POLICE_CONFORM;
10053 else if (unformat (input, "exceed-color"))
10054 *r = POLICE_EXCEED;
10062 api_classify_add_del_table (vat_main_t * vam)
10064 unformat_input_t *i = vam->input;
10065 vl_api_classify_add_del_table_t *mp;
10072 u32 table_index = ~0;
10073 u32 next_table_index = ~0;
10074 u32 miss_next_index = ~0;
10075 u32 memory_size = 32 << 20;
10077 u32 current_data_flag = 0;
10078 int current_data_offset = 0;
10081 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10083 if (unformat (i, "del"))
10085 else if (unformat (i, "del-chain"))
10090 else if (unformat (i, "buckets %d", &nbuckets))
10092 else if (unformat (i, "memory_size %d", &memory_size))
10094 else if (unformat (i, "skip %d", &skip))
10096 else if (unformat (i, "match %d", &match))
10098 else if (unformat (i, "table %d", &table_index))
10100 else if (unformat (i, "mask %U", unformat_classify_mask,
10101 &mask, &skip, &match))
10103 else if (unformat (i, "next-table %d", &next_table_index))
10105 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10108 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10111 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10114 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10116 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10122 if (is_add && mask == 0)
10124 errmsg ("Mask required");
10128 if (is_add && skip == ~0)
10130 errmsg ("skip count required");
10134 if (is_add && match == ~0)
10136 errmsg ("match count required");
10140 if (!is_add && table_index == ~0)
10142 errmsg ("table index required for delete");
10146 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10148 mp->is_add = is_add;
10149 mp->del_chain = del_chain;
10150 mp->table_index = ntohl (table_index);
10151 mp->nbuckets = ntohl (nbuckets);
10152 mp->memory_size = ntohl (memory_size);
10153 mp->skip_n_vectors = ntohl (skip);
10154 mp->match_n_vectors = ntohl (match);
10155 mp->next_table_index = ntohl (next_table_index);
10156 mp->miss_next_index = ntohl (miss_next_index);
10157 mp->current_data_flag = ntohl (current_data_flag);
10158 mp->current_data_offset = ntohl (current_data_offset);
10159 clib_memcpy (mp->mask, mask, vec_len (mask));
10168 #if VPP_API_TEST_BUILTIN == 0
10170 unformat_l4_match (unformat_input_t * input, va_list * args)
10172 u8 **matchp = va_arg (*args, u8 **);
10174 u8 *proto_header = 0;
10180 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10182 if (unformat (input, "src_port %d", &src_port))
10184 else if (unformat (input, "dst_port %d", &dst_port))
10190 h.src_port = clib_host_to_net_u16 (src_port);
10191 h.dst_port = clib_host_to_net_u16 (dst_port);
10192 vec_validate (proto_header, sizeof (h) - 1);
10193 memcpy (proto_header, &h, sizeof (h));
10195 *matchp = proto_header;
10201 unformat_ip4_match (unformat_input_t * input, va_list * args)
10203 u8 **matchp = va_arg (*args, u8 **);
10208 int hdr_length = 0;
10209 u32 hdr_length_val;
10210 int src = 0, dst = 0;
10211 ip4_address_t src_val, dst_val;
10218 int fragment_id = 0;
10219 u32 fragment_id_val;
10225 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10227 if (unformat (input, "version %d", &version_val))
10229 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10231 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10233 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10235 else if (unformat (input, "proto %d", &proto_val))
10237 else if (unformat (input, "tos %d", &tos_val))
10239 else if (unformat (input, "length %d", &length_val))
10241 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10243 else if (unformat (input, "ttl %d", &ttl_val))
10245 else if (unformat (input, "checksum %d", &checksum_val))
10251 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10252 + ttl + checksum == 0)
10256 * Aligned because we use the real comparison functions
10258 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10260 ip = (ip4_header_t *) match;
10262 /* These are realistically matched in practice */
10264 ip->src_address.as_u32 = src_val.as_u32;
10267 ip->dst_address.as_u32 = dst_val.as_u32;
10270 ip->protocol = proto_val;
10273 /* These are not, but they're included for completeness */
10275 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10278 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10284 ip->length = clib_host_to_net_u16 (length_val);
10290 ip->checksum = clib_host_to_net_u16 (checksum_val);
10297 unformat_ip6_match (unformat_input_t * input, va_list * args)
10299 u8 **matchp = va_arg (*args, u8 **);
10304 u8 traffic_class = 0;
10305 u32 traffic_class_val = 0;
10308 int src = 0, dst = 0;
10309 ip6_address_t src_val, dst_val;
10312 int payload_length = 0;
10313 u32 payload_length_val;
10316 u32 ip_version_traffic_class_and_flow_label;
10318 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10320 if (unformat (input, "version %d", &version_val))
10322 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10324 else if (unformat (input, "flow_label %d", &flow_label_val))
10326 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10328 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10330 else if (unformat (input, "proto %d", &proto_val))
10332 else if (unformat (input, "payload_length %d", &payload_length_val))
10333 payload_length = 1;
10334 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10340 if (version + traffic_class + flow_label + src + dst + proto +
10341 payload_length + hop_limit == 0)
10345 * Aligned because we use the real comparison functions
10347 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10349 ip = (ip6_header_t *) match;
10352 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10355 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10358 ip->protocol = proto_val;
10360 ip_version_traffic_class_and_flow_label = 0;
10363 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10366 ip_version_traffic_class_and_flow_label |=
10367 (traffic_class_val & 0xFF) << 20;
10370 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10372 ip->ip_version_traffic_class_and_flow_label =
10373 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10375 if (payload_length)
10376 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10379 ip->hop_limit = hop_limit_val;
10386 unformat_l3_match (unformat_input_t * input, va_list * args)
10388 u8 **matchp = va_arg (*args, u8 **);
10390 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10392 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10394 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10403 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10405 u8 *tagp = va_arg (*args, u8 *);
10408 if (unformat (input, "%d", &tag))
10410 tagp[0] = (tag >> 8) & 0x0F;
10411 tagp[1] = tag & 0xFF;
10419 unformat_l2_match (unformat_input_t * input, va_list * args)
10421 u8 **matchp = va_arg (*args, u8 **);
10434 u8 ignore_tag1 = 0;
10435 u8 ignore_tag2 = 0;
10441 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10443 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10446 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10448 else if (unformat (input, "proto %U",
10449 unformat_ethernet_type_host_byte_order, &proto_val))
10451 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10453 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10455 else if (unformat (input, "ignore-tag1"))
10457 else if (unformat (input, "ignore-tag2"))
10459 else if (unformat (input, "cos1 %d", &cos1_val))
10461 else if (unformat (input, "cos2 %d", &cos2_val))
10466 if ((src + dst + proto + tag1 + tag2 +
10467 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10470 if (tag1 || ignore_tag1 || cos1)
10472 if (tag2 || ignore_tag2 || cos2)
10475 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10478 clib_memcpy (match, dst_val, 6);
10481 clib_memcpy (match + 6, src_val, 6);
10485 /* inner vlan tag */
10486 match[19] = tag2_val[1];
10487 match[18] = tag2_val[0];
10489 match[18] |= (cos2_val & 0x7) << 5;
10492 match[21] = proto_val & 0xff;
10493 match[20] = proto_val >> 8;
10497 match[15] = tag1_val[1];
10498 match[14] = tag1_val[0];
10501 match[14] |= (cos1_val & 0x7) << 5;
10507 match[15] = tag1_val[1];
10508 match[14] = tag1_val[0];
10511 match[17] = proto_val & 0xff;
10512 match[16] = proto_val >> 8;
10515 match[14] |= (cos1_val & 0x7) << 5;
10521 match[18] |= (cos2_val & 0x7) << 5;
10523 match[14] |= (cos1_val & 0x7) << 5;
10526 match[13] = proto_val & 0xff;
10527 match[12] = proto_val >> 8;
10536 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10538 u8 **matchp = va_arg (*args, u8 **);
10539 u32 skip_n_vectors = va_arg (*args, u32);
10540 u32 match_n_vectors = va_arg (*args, u32);
10547 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10549 if (unformat (input, "hex %U", unformat_hex_string, &match))
10551 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10553 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10555 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10569 if (match || l2 || l3 || l4)
10571 if (l2 || l3 || l4)
10573 /* "Win a free Ethernet header in every packet" */
10575 vec_validate_aligned (l2, 13, sizeof (u32x4));
10579 vec_append_aligned (match, l3, sizeof (u32x4));
10584 vec_append_aligned (match, l4, sizeof (u32x4));
10589 /* Make sure the vector is big enough even if key is all 0's */
10590 vec_validate_aligned
10591 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10594 /* Set size, include skipped vectors */
10595 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10606 api_classify_add_del_session (vat_main_t * vam)
10608 unformat_input_t *i = vam->input;
10609 vl_api_classify_add_del_session_t *mp;
10611 u32 table_index = ~0;
10612 u32 hit_next_index = ~0;
10613 u32 opaque_index = ~0;
10616 u32 skip_n_vectors = 0;
10617 u32 match_n_vectors = 0;
10623 * Warning: you have to supply skip_n and match_n
10624 * because the API client cant simply look at the classify
10628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10630 if (unformat (i, "del"))
10632 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10635 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10638 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10641 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10643 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10645 else if (unformat (i, "opaque-index %d", &opaque_index))
10647 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10649 else if (unformat (i, "match_n %d", &match_n_vectors))
10651 else if (unformat (i, "match %U", api_unformat_classify_match,
10652 &match, skip_n_vectors, match_n_vectors))
10654 else if (unformat (i, "advance %d", &advance))
10656 else if (unformat (i, "table-index %d", &table_index))
10658 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10660 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10662 else if (unformat (i, "action %d", &action))
10664 else if (unformat (i, "metadata %d", &metadata))
10670 if (table_index == ~0)
10672 errmsg ("Table index required");
10676 if (is_add && match == 0)
10678 errmsg ("Match value required");
10682 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10684 mp->is_add = is_add;
10685 mp->table_index = ntohl (table_index);
10686 mp->hit_next_index = ntohl (hit_next_index);
10687 mp->opaque_index = ntohl (opaque_index);
10688 mp->advance = ntohl (advance);
10689 mp->action = action;
10690 mp->metadata = ntohl (metadata);
10691 clib_memcpy (mp->match, match, vec_len (match));
10700 api_classify_set_interface_ip_table (vat_main_t * vam)
10702 unformat_input_t *i = vam->input;
10703 vl_api_classify_set_interface_ip_table_t *mp;
10705 int sw_if_index_set;
10706 u32 table_index = ~0;
10710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10712 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10713 sw_if_index_set = 1;
10714 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10715 sw_if_index_set = 1;
10716 else if (unformat (i, "table %d", &table_index))
10720 clib_warning ("parse error '%U'", format_unformat_error, i);
10725 if (sw_if_index_set == 0)
10727 errmsg ("missing interface name or sw_if_index");
10732 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10734 mp->sw_if_index = ntohl (sw_if_index);
10735 mp->table_index = ntohl (table_index);
10736 mp->is_ipv6 = is_ipv6;
10744 api_classify_set_interface_l2_tables (vat_main_t * vam)
10746 unformat_input_t *i = vam->input;
10747 vl_api_classify_set_interface_l2_tables_t *mp;
10749 int sw_if_index_set;
10750 u32 ip4_table_index = ~0;
10751 u32 ip6_table_index = ~0;
10752 u32 other_table_index = ~0;
10756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10758 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10759 sw_if_index_set = 1;
10760 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10761 sw_if_index_set = 1;
10762 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10764 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10766 else if (unformat (i, "other-table %d", &other_table_index))
10768 else if (unformat (i, "is-input %d", &is_input))
10772 clib_warning ("parse error '%U'", format_unformat_error, i);
10777 if (sw_if_index_set == 0)
10779 errmsg ("missing interface name or sw_if_index");
10784 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10786 mp->sw_if_index = ntohl (sw_if_index);
10787 mp->ip4_table_index = ntohl (ip4_table_index);
10788 mp->ip6_table_index = ntohl (ip6_table_index);
10789 mp->other_table_index = ntohl (other_table_index);
10790 mp->is_input = (u8) is_input;
10798 api_set_ipfix_exporter (vat_main_t * vam)
10800 unformat_input_t *i = vam->input;
10801 vl_api_set_ipfix_exporter_t *mp;
10802 ip4_address_t collector_address;
10803 u8 collector_address_set = 0;
10804 u32 collector_port = ~0;
10805 ip4_address_t src_address;
10806 u8 src_address_set = 0;
10809 u32 template_interval = ~0;
10810 u8 udp_checksum = 0;
10813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10815 if (unformat (i, "collector_address %U", unformat_ip4_address,
10816 &collector_address))
10817 collector_address_set = 1;
10818 else if (unformat (i, "collector_port %d", &collector_port))
10820 else if (unformat (i, "src_address %U", unformat_ip4_address,
10822 src_address_set = 1;
10823 else if (unformat (i, "vrf_id %d", &vrf_id))
10825 else if (unformat (i, "path_mtu %d", &path_mtu))
10827 else if (unformat (i, "template_interval %d", &template_interval))
10829 else if (unformat (i, "udp_checksum"))
10835 if (collector_address_set == 0)
10837 errmsg ("collector_address required");
10841 if (src_address_set == 0)
10843 errmsg ("src_address required");
10847 M (SET_IPFIX_EXPORTER, mp);
10849 memcpy (mp->collector_address, collector_address.data,
10850 sizeof (collector_address.data));
10851 mp->collector_port = htons ((u16) collector_port);
10852 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10853 mp->vrf_id = htonl (vrf_id);
10854 mp->path_mtu = htonl (path_mtu);
10855 mp->template_interval = htonl (template_interval);
10856 mp->udp_checksum = udp_checksum;
10864 api_set_ipfix_classify_stream (vat_main_t * vam)
10866 unformat_input_t *i = vam->input;
10867 vl_api_set_ipfix_classify_stream_t *mp;
10869 u32 src_port = UDP_DST_PORT_ipfix;
10872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10874 if (unformat (i, "domain %d", &domain_id))
10876 else if (unformat (i, "src_port %d", &src_port))
10880 errmsg ("unknown input `%U'", format_unformat_error, i);
10885 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10887 mp->domain_id = htonl (domain_id);
10888 mp->src_port = htons ((u16) src_port);
10896 api_ipfix_classify_table_add_del (vat_main_t * vam)
10898 unformat_input_t *i = vam->input;
10899 vl_api_ipfix_classify_table_add_del_t *mp;
10901 u32 classify_table_index = ~0;
10903 u8 transport_protocol = 255;
10906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10908 if (unformat (i, "add"))
10910 else if (unformat (i, "del"))
10912 else if (unformat (i, "table %d", &classify_table_index))
10914 else if (unformat (i, "ip4"))
10916 else if (unformat (i, "ip6"))
10918 else if (unformat (i, "tcp"))
10919 transport_protocol = 6;
10920 else if (unformat (i, "udp"))
10921 transport_protocol = 17;
10924 errmsg ("unknown input `%U'", format_unformat_error, i);
10931 errmsg ("expecting: add|del");
10934 if (classify_table_index == ~0)
10936 errmsg ("classifier table not specified");
10939 if (ip_version == 0)
10941 errmsg ("IP version not specified");
10945 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10947 mp->is_add = is_add;
10948 mp->table_id = htonl (classify_table_index);
10949 mp->ip_version = ip_version;
10950 mp->transport_protocol = transport_protocol;
10958 api_get_node_index (vat_main_t * vam)
10960 unformat_input_t *i = vam->input;
10961 vl_api_get_node_index_t *mp;
10965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10967 if (unformat (i, "node %s", &name))
10974 errmsg ("node name required");
10977 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10979 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10983 M (GET_NODE_INDEX, mp);
10984 clib_memcpy (mp->node_name, name, vec_len (name));
10993 api_get_next_index (vat_main_t * vam)
10995 unformat_input_t *i = vam->input;
10996 vl_api_get_next_index_t *mp;
10997 u8 *node_name = 0, *next_node_name = 0;
11000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11002 if (unformat (i, "node-name %s", &node_name))
11004 else if (unformat (i, "next-node-name %s", &next_node_name))
11008 if (node_name == 0)
11010 errmsg ("node name required");
11013 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11015 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11019 if (next_node_name == 0)
11021 errmsg ("next node name required");
11024 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11026 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11030 M (GET_NEXT_INDEX, mp);
11031 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11032 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11033 vec_free (node_name);
11034 vec_free (next_node_name);
11042 api_add_node_next (vat_main_t * vam)
11044 unformat_input_t *i = vam->input;
11045 vl_api_add_node_next_t *mp;
11050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11052 if (unformat (i, "node %s", &name))
11054 else if (unformat (i, "next %s", &next))
11061 errmsg ("node name required");
11064 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11066 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11071 errmsg ("next node required");
11074 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11076 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11080 M (ADD_NODE_NEXT, mp);
11081 clib_memcpy (mp->node_name, name, vec_len (name));
11082 clib_memcpy (mp->next_name, next, vec_len (next));
11092 api_l2tpv3_create_tunnel (vat_main_t * vam)
11094 unformat_input_t *i = vam->input;
11095 ip6_address_t client_address, our_address;
11096 int client_address_set = 0;
11097 int our_address_set = 0;
11098 u32 local_session_id = 0;
11099 u32 remote_session_id = 0;
11100 u64 local_cookie = 0;
11101 u64 remote_cookie = 0;
11102 u8 l2_sublayer_present = 0;
11103 vl_api_l2tpv3_create_tunnel_t *mp;
11106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11108 if (unformat (i, "client_address %U", unformat_ip6_address,
11110 client_address_set = 1;
11111 else if (unformat (i, "our_address %U", unformat_ip6_address,
11113 our_address_set = 1;
11114 else if (unformat (i, "local_session_id %d", &local_session_id))
11116 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11118 else if (unformat (i, "local_cookie %lld", &local_cookie))
11120 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11122 else if (unformat (i, "l2-sublayer-present"))
11123 l2_sublayer_present = 1;
11128 if (client_address_set == 0)
11130 errmsg ("client_address required");
11134 if (our_address_set == 0)
11136 errmsg ("our_address required");
11140 M (L2TPV3_CREATE_TUNNEL, mp);
11142 clib_memcpy (mp->client_address, client_address.as_u8,
11143 sizeof (mp->client_address));
11145 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11147 mp->local_session_id = ntohl (local_session_id);
11148 mp->remote_session_id = ntohl (remote_session_id);
11149 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11150 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11151 mp->l2_sublayer_present = l2_sublayer_present;
11160 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11162 unformat_input_t *i = vam->input;
11164 u8 sw_if_index_set = 0;
11165 u64 new_local_cookie = 0;
11166 u64 new_remote_cookie = 0;
11167 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11172 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11173 sw_if_index_set = 1;
11174 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11175 sw_if_index_set = 1;
11176 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11178 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11184 if (sw_if_index_set == 0)
11186 errmsg ("missing interface name or sw_if_index");
11190 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11192 mp->sw_if_index = ntohl (sw_if_index);
11193 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11194 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11202 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11204 unformat_input_t *i = vam->input;
11205 vl_api_l2tpv3_interface_enable_disable_t *mp;
11207 u8 sw_if_index_set = 0;
11208 u8 enable_disable = 1;
11211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11213 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11214 sw_if_index_set = 1;
11215 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11216 sw_if_index_set = 1;
11217 else if (unformat (i, "enable"))
11218 enable_disable = 1;
11219 else if (unformat (i, "disable"))
11220 enable_disable = 0;
11225 if (sw_if_index_set == 0)
11227 errmsg ("missing interface name or sw_if_index");
11231 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11233 mp->sw_if_index = ntohl (sw_if_index);
11234 mp->enable_disable = enable_disable;
11242 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11244 unformat_input_t *i = vam->input;
11245 vl_api_l2tpv3_set_lookup_key_t *mp;
11249 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11251 if (unformat (i, "lookup_v6_src"))
11252 key = L2T_LOOKUP_SRC_ADDRESS;
11253 else if (unformat (i, "lookup_v6_dst"))
11254 key = L2T_LOOKUP_DST_ADDRESS;
11255 else if (unformat (i, "lookup_session_id"))
11256 key = L2T_LOOKUP_SESSION_ID;
11261 if (key == (u8) ~ 0)
11263 errmsg ("l2tp session lookup key unset");
11267 M (L2TPV3_SET_LOOKUP_KEY, mp);
11276 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11277 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11279 vat_main_t *vam = &vat_main;
11281 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11282 format_ip6_address, mp->our_address,
11283 format_ip6_address, mp->client_address,
11284 clib_net_to_host_u32 (mp->sw_if_index));
11287 " local cookies %016llx %016llx remote cookie %016llx",
11288 clib_net_to_host_u64 (mp->local_cookie[0]),
11289 clib_net_to_host_u64 (mp->local_cookie[1]),
11290 clib_net_to_host_u64 (mp->remote_cookie));
11292 print (vam->ofp, " local session-id %d remote session-id %d",
11293 clib_net_to_host_u32 (mp->local_session_id),
11294 clib_net_to_host_u32 (mp->remote_session_id));
11296 print (vam->ofp, " l2 specific sublayer %s\n",
11297 mp->l2_sublayer_present ? "preset" : "absent");
11301 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11302 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11304 vat_main_t *vam = &vat_main;
11305 vat_json_node_t *node = NULL;
11306 struct in6_addr addr;
11308 if (VAT_JSON_ARRAY != vam->json_tree.type)
11310 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11311 vat_json_init_array (&vam->json_tree);
11313 node = vat_json_array_add (&vam->json_tree);
11315 vat_json_init_object (node);
11317 clib_memcpy (&addr, mp->our_address, sizeof (addr));
11318 vat_json_object_add_ip6 (node, "our_address", addr);
11319 clib_memcpy (&addr, mp->client_address, sizeof (addr));
11320 vat_json_object_add_ip6 (node, "client_address", addr);
11322 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11323 vat_json_init_array (lc);
11324 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11325 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11326 vat_json_object_add_uint (node, "remote_cookie",
11327 clib_net_to_host_u64 (mp->remote_cookie));
11329 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11330 vat_json_object_add_uint (node, "local_session_id",
11331 clib_net_to_host_u32 (mp->local_session_id));
11332 vat_json_object_add_uint (node, "remote_session_id",
11333 clib_net_to_host_u32 (mp->remote_session_id));
11334 vat_json_object_add_string_copy (node, "l2_sublayer",
11335 mp->l2_sublayer_present ? (u8 *) "present"
11336 : (u8 *) "absent");
11340 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11342 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11343 vl_api_control_ping_t *mp_ping;
11346 /* Get list of l2tpv3-tunnel interfaces */
11347 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11350 /* Use a control ping for synchronization */
11351 M (CONTROL_PING, mp_ping);
11359 static void vl_api_sw_interface_tap_details_t_handler
11360 (vl_api_sw_interface_tap_details_t * mp)
11362 vat_main_t *vam = &vat_main;
11364 print (vam->ofp, "%-16s %d",
11365 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
11368 static void vl_api_sw_interface_tap_details_t_handler_json
11369 (vl_api_sw_interface_tap_details_t * mp)
11371 vat_main_t *vam = &vat_main;
11372 vat_json_node_t *node = NULL;
11374 if (VAT_JSON_ARRAY != vam->json_tree.type)
11376 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11377 vat_json_init_array (&vam->json_tree);
11379 node = vat_json_array_add (&vam->json_tree);
11381 vat_json_init_object (node);
11382 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11383 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11387 api_sw_interface_tap_dump (vat_main_t * vam)
11389 vl_api_sw_interface_tap_dump_t *mp;
11390 vl_api_control_ping_t *mp_ping;
11393 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
11394 /* Get list of tap interfaces */
11395 M (SW_INTERFACE_TAP_DUMP, mp);
11398 /* Use a control ping for synchronization */
11399 M (CONTROL_PING, mp_ping);
11406 static uword unformat_vxlan_decap_next
11407 (unformat_input_t * input, va_list * args)
11409 u32 *result = va_arg (*args, u32 *);
11412 if (unformat (input, "l2"))
11413 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11414 else if (unformat (input, "%d", &tmp))
11422 api_vxlan_add_del_tunnel (vat_main_t * vam)
11424 unformat_input_t *line_input = vam->input;
11425 vl_api_vxlan_add_del_tunnel_t *mp;
11426 ip46_address_t src, dst;
11428 u8 ipv4_set = 0, ipv6_set = 0;
11432 u32 mcast_sw_if_index = ~0;
11433 u32 encap_vrf_id = 0;
11434 u32 decap_next_index = ~0;
11438 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11439 memset (&src, 0, sizeof src);
11440 memset (&dst, 0, sizeof dst);
11442 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11444 if (unformat (line_input, "del"))
11447 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11453 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11459 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11465 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11470 else if (unformat (line_input, "group %U %U",
11471 unformat_ip4_address, &dst.ip4,
11472 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11474 grp_set = dst_set = 1;
11477 else if (unformat (line_input, "group %U",
11478 unformat_ip4_address, &dst.ip4))
11480 grp_set = dst_set = 1;
11483 else if (unformat (line_input, "group %U %U",
11484 unformat_ip6_address, &dst.ip6,
11485 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11487 grp_set = dst_set = 1;
11490 else if (unformat (line_input, "group %U",
11491 unformat_ip6_address, &dst.ip6))
11493 grp_set = dst_set = 1;
11497 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11499 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11501 else if (unformat (line_input, "decap-next %U",
11502 unformat_vxlan_decap_next, &decap_next_index))
11504 else if (unformat (line_input, "vni %d", &vni))
11508 errmsg ("parse error '%U'", format_unformat_error, line_input);
11515 errmsg ("tunnel src address not specified");
11520 errmsg ("tunnel dst address not specified");
11524 if (grp_set && !ip46_address_is_multicast (&dst))
11526 errmsg ("tunnel group address not multicast");
11529 if (grp_set && mcast_sw_if_index == ~0)
11531 errmsg ("tunnel nonexistent multicast device");
11534 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11536 errmsg ("tunnel dst address must be unicast");
11541 if (ipv4_set && ipv6_set)
11543 errmsg ("both IPv4 and IPv6 addresses specified");
11547 if ((vni == 0) || (vni >> 24))
11549 errmsg ("vni not specified or out of range");
11553 M (VXLAN_ADD_DEL_TUNNEL, mp);
11557 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11558 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11562 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11563 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11565 mp->encap_vrf_id = ntohl (encap_vrf_id);
11566 mp->decap_next_index = ntohl (decap_next_index);
11567 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11568 mp->vni = ntohl (vni);
11569 mp->is_add = is_add;
11570 mp->is_ipv6 = ipv6_set;
11577 static void vl_api_vxlan_tunnel_details_t_handler
11578 (vl_api_vxlan_tunnel_details_t * mp)
11580 vat_main_t *vam = &vat_main;
11581 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11582 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11584 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
11585 ntohl (mp->sw_if_index),
11586 format_ip46_address, &src, IP46_TYPE_ANY,
11587 format_ip46_address, &dst, IP46_TYPE_ANY,
11588 ntohl (mp->encap_vrf_id),
11589 ntohl (mp->decap_next_index), ntohl (mp->vni),
11590 ntohl (mp->mcast_sw_if_index));
11593 static void vl_api_vxlan_tunnel_details_t_handler_json
11594 (vl_api_vxlan_tunnel_details_t * mp)
11596 vat_main_t *vam = &vat_main;
11597 vat_json_node_t *node = NULL;
11599 if (VAT_JSON_ARRAY != vam->json_tree.type)
11601 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11602 vat_json_init_array (&vam->json_tree);
11604 node = vat_json_array_add (&vam->json_tree);
11606 vat_json_init_object (node);
11607 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11610 struct in6_addr ip6;
11612 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11613 vat_json_object_add_ip6 (node, "src_address", ip6);
11614 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11615 vat_json_object_add_ip6 (node, "dst_address", ip6);
11619 struct in_addr ip4;
11621 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11622 vat_json_object_add_ip4 (node, "src_address", ip4);
11623 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11624 vat_json_object_add_ip4 (node, "dst_address", ip4);
11626 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11627 vat_json_object_add_uint (node, "decap_next_index",
11628 ntohl (mp->decap_next_index));
11629 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11630 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11631 vat_json_object_add_uint (node, "mcast_sw_if_index",
11632 ntohl (mp->mcast_sw_if_index));
11636 api_vxlan_tunnel_dump (vat_main_t * vam)
11638 unformat_input_t *i = vam->input;
11639 vl_api_vxlan_tunnel_dump_t *mp;
11640 vl_api_control_ping_t *mp_ping;
11642 u8 sw_if_index_set = 0;
11645 /* Parse args required to build the message */
11646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11648 if (unformat (i, "sw_if_index %d", &sw_if_index))
11649 sw_if_index_set = 1;
11654 if (sw_if_index_set == 0)
11659 if (!vam->json_output)
11661 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
11662 "sw_if_index", "src_address", "dst_address",
11663 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11666 /* Get list of vxlan-tunnel interfaces */
11667 M (VXLAN_TUNNEL_DUMP, mp);
11669 mp->sw_if_index = htonl (sw_if_index);
11673 /* Use a control ping for synchronization */
11674 M (CONTROL_PING, mp_ping);
11682 api_gre_add_del_tunnel (vat_main_t * vam)
11684 unformat_input_t *line_input = vam->input;
11685 vl_api_gre_add_del_tunnel_t *mp;
11686 ip4_address_t src4, dst4;
11687 ip6_address_t src6, dst6;
11694 u32 outer_fib_id = 0;
11697 memset (&src4, 0, sizeof src4);
11698 memset (&dst4, 0, sizeof dst4);
11699 memset (&src6, 0, sizeof src6);
11700 memset (&dst6, 0, sizeof dst6);
11702 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11704 if (unformat (line_input, "del"))
11706 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
11711 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
11716 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
11721 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
11726 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
11728 else if (unformat (line_input, "teb"))
11732 errmsg ("parse error '%U'", format_unformat_error, line_input);
11739 errmsg ("tunnel src address not specified");
11744 errmsg ("tunnel dst address not specified");
11747 if (ipv4_set && ipv6_set)
11749 errmsg ("both IPv4 and IPv6 addresses specified");
11754 M (GRE_ADD_DEL_TUNNEL, mp);
11758 clib_memcpy (&mp->src_address, &src4, 4);
11759 clib_memcpy (&mp->dst_address, &dst4, 4);
11763 clib_memcpy (&mp->src_address, &src6, 16);
11764 clib_memcpy (&mp->dst_address, &dst6, 16);
11766 mp->outer_fib_id = ntohl (outer_fib_id);
11767 mp->is_add = is_add;
11769 mp->is_ipv6 = ipv6_set;
11776 static void vl_api_gre_tunnel_details_t_handler
11777 (vl_api_gre_tunnel_details_t * mp)
11779 vat_main_t *vam = &vat_main;
11780 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
11781 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
11783 print (vam->ofp, "%11d%24U%24U%6d%14d",
11784 ntohl (mp->sw_if_index),
11785 format_ip46_address, &src, IP46_TYPE_ANY,
11786 format_ip46_address, &dst, IP46_TYPE_ANY,
11787 mp->teb, ntohl (mp->outer_fib_id));
11790 static void vl_api_gre_tunnel_details_t_handler_json
11791 (vl_api_gre_tunnel_details_t * mp)
11793 vat_main_t *vam = &vat_main;
11794 vat_json_node_t *node = NULL;
11795 struct in_addr ip4;
11796 struct in6_addr ip6;
11798 if (VAT_JSON_ARRAY != vam->json_tree.type)
11800 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11801 vat_json_init_array (&vam->json_tree);
11803 node = vat_json_array_add (&vam->json_tree);
11805 vat_json_init_object (node);
11806 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11809 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11810 vat_json_object_add_ip4 (node, "src_address", ip4);
11811 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11812 vat_json_object_add_ip4 (node, "dst_address", ip4);
11816 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
11817 vat_json_object_add_ip6 (node, "src_address", ip6);
11818 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
11819 vat_json_object_add_ip6 (node, "dst_address", ip6);
11821 vat_json_object_add_uint (node, "teb", mp->teb);
11822 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11823 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
11827 api_gre_tunnel_dump (vat_main_t * vam)
11829 unformat_input_t *i = vam->input;
11830 vl_api_gre_tunnel_dump_t *mp;
11831 vl_api_control_ping_t *mp_ping;
11833 u8 sw_if_index_set = 0;
11836 /* Parse args required to build the message */
11837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11839 if (unformat (i, "sw_if_index %d", &sw_if_index))
11840 sw_if_index_set = 1;
11845 if (sw_if_index_set == 0)
11850 if (!vam->json_output)
11852 print (vam->ofp, "%11s%24s%24s%6s%14s",
11853 "sw_if_index", "src_address", "dst_address", "teb",
11857 /* Get list of gre-tunnel interfaces */
11858 M (GRE_TUNNEL_DUMP, mp);
11860 mp->sw_if_index = htonl (sw_if_index);
11864 /* Use a control ping for synchronization */
11865 M (CONTROL_PING, mp_ping);
11873 api_l2_fib_clear_table (vat_main_t * vam)
11875 // unformat_input_t * i = vam->input;
11876 vl_api_l2_fib_clear_table_t *mp;
11879 M (L2_FIB_CLEAR_TABLE, mp);
11887 api_l2_interface_efp_filter (vat_main_t * vam)
11889 unformat_input_t *i = vam->input;
11890 vl_api_l2_interface_efp_filter_t *mp;
11893 u8 sw_if_index_set = 0;
11896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11898 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11899 sw_if_index_set = 1;
11900 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11901 sw_if_index_set = 1;
11902 else if (unformat (i, "enable"))
11904 else if (unformat (i, "disable"))
11908 clib_warning ("parse error '%U'", format_unformat_error, i);
11913 if (sw_if_index_set == 0)
11915 errmsg ("missing sw_if_index");
11919 M (L2_INTERFACE_EFP_FILTER, mp);
11921 mp->sw_if_index = ntohl (sw_if_index);
11922 mp->enable_disable = enable;
11929 #define foreach_vtr_op \
11930 _("disable", L2_VTR_DISABLED) \
11931 _("push-1", L2_VTR_PUSH_1) \
11932 _("push-2", L2_VTR_PUSH_2) \
11933 _("pop-1", L2_VTR_POP_1) \
11934 _("pop-2", L2_VTR_POP_2) \
11935 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11936 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11937 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11938 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11941 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11943 unformat_input_t *i = vam->input;
11944 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11946 u8 sw_if_index_set = 0;
11949 u32 push_dot1q = 1;
11954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11956 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11957 sw_if_index_set = 1;
11958 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11959 sw_if_index_set = 1;
11960 else if (unformat (i, "vtr_op %d", &vtr_op))
11962 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11965 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11967 else if (unformat (i, "tag1 %d", &tag1))
11969 else if (unformat (i, "tag2 %d", &tag2))
11973 clib_warning ("parse error '%U'", format_unformat_error, i);
11978 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11980 errmsg ("missing vtr operation or sw_if_index");
11984 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11985 mp->sw_if_index = ntohl (sw_if_index);
11986 mp->vtr_op = ntohl (vtr_op);
11987 mp->push_dot1q = ntohl (push_dot1q);
11988 mp->tag1 = ntohl (tag1);
11989 mp->tag2 = ntohl (tag2);
11997 api_create_vhost_user_if (vat_main_t * vam)
11999 unformat_input_t *i = vam->input;
12000 vl_api_create_vhost_user_if_t *mp;
12003 u8 file_name_set = 0;
12004 u32 custom_dev_instance = ~0;
12006 u8 use_custom_mac = 0;
12010 /* Shut up coverity */
12011 memset (hwaddr, 0, sizeof (hwaddr));
12013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12015 if (unformat (i, "socket %s", &file_name))
12019 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12021 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12022 use_custom_mac = 1;
12023 else if (unformat (i, "server"))
12025 else if (unformat (i, "tag %s", &tag))
12031 if (file_name_set == 0)
12033 errmsg ("missing socket file name");
12037 if (vec_len (file_name) > 255)
12039 errmsg ("socket file name too long");
12042 vec_add1 (file_name, 0);
12044 M (CREATE_VHOST_USER_IF, mp);
12046 mp->is_server = is_server;
12047 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12048 vec_free (file_name);
12049 if (custom_dev_instance != ~0)
12052 mp->custom_dev_instance = ntohl (custom_dev_instance);
12054 mp->use_custom_mac = use_custom_mac;
12055 clib_memcpy (mp->mac_address, hwaddr, 6);
12057 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12066 api_modify_vhost_user_if (vat_main_t * vam)
12068 unformat_input_t *i = vam->input;
12069 vl_api_modify_vhost_user_if_t *mp;
12072 u8 file_name_set = 0;
12073 u32 custom_dev_instance = ~0;
12074 u8 sw_if_index_set = 0;
12075 u32 sw_if_index = (u32) ~ 0;
12078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12080 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12081 sw_if_index_set = 1;
12082 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12083 sw_if_index_set = 1;
12084 else if (unformat (i, "socket %s", &file_name))
12088 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12090 else if (unformat (i, "server"))
12096 if (sw_if_index_set == 0)
12098 errmsg ("missing sw_if_index or interface name");
12102 if (file_name_set == 0)
12104 errmsg ("missing socket file name");
12108 if (vec_len (file_name) > 255)
12110 errmsg ("socket file name too long");
12113 vec_add1 (file_name, 0);
12115 M (MODIFY_VHOST_USER_IF, mp);
12117 mp->sw_if_index = ntohl (sw_if_index);
12118 mp->is_server = is_server;
12119 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12120 vec_free (file_name);
12121 if (custom_dev_instance != ~0)
12124 mp->custom_dev_instance = ntohl (custom_dev_instance);
12133 api_delete_vhost_user_if (vat_main_t * vam)
12135 unformat_input_t *i = vam->input;
12136 vl_api_delete_vhost_user_if_t *mp;
12137 u32 sw_if_index = ~0;
12138 u8 sw_if_index_set = 0;
12141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12143 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12144 sw_if_index_set = 1;
12145 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12146 sw_if_index_set = 1;
12151 if (sw_if_index_set == 0)
12153 errmsg ("missing sw_if_index or interface name");
12158 M (DELETE_VHOST_USER_IF, mp);
12160 mp->sw_if_index = ntohl (sw_if_index);
12167 static void vl_api_sw_interface_vhost_user_details_t_handler
12168 (vl_api_sw_interface_vhost_user_details_t * mp)
12170 vat_main_t *vam = &vat_main;
12172 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12173 (char *) mp->interface_name,
12174 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12175 clib_net_to_host_u64 (mp->features), mp->is_server,
12176 ntohl (mp->num_regions), (char *) mp->sock_filename);
12177 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12180 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12181 (vl_api_sw_interface_vhost_user_details_t * mp)
12183 vat_main_t *vam = &vat_main;
12184 vat_json_node_t *node = NULL;
12186 if (VAT_JSON_ARRAY != vam->json_tree.type)
12188 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12189 vat_json_init_array (&vam->json_tree);
12191 node = vat_json_array_add (&vam->json_tree);
12193 vat_json_init_object (node);
12194 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12195 vat_json_object_add_string_copy (node, "interface_name",
12196 mp->interface_name);
12197 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12198 ntohl (mp->virtio_net_hdr_sz));
12199 vat_json_object_add_uint (node, "features",
12200 clib_net_to_host_u64 (mp->features));
12201 vat_json_object_add_uint (node, "is_server", mp->is_server);
12202 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12203 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12204 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12208 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12210 vl_api_sw_interface_vhost_user_dump_t *mp;
12211 vl_api_control_ping_t *mp_ping;
12214 "Interface name idx hdr_sz features server regions filename");
12216 /* Get list of vhost-user interfaces */
12217 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12220 /* Use a control ping for synchronization */
12221 M (CONTROL_PING, mp_ping);
12229 api_show_version (vat_main_t * vam)
12231 vl_api_show_version_t *mp;
12234 M (SHOW_VERSION, mp);
12243 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12245 unformat_input_t *line_input = vam->input;
12246 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12247 ip4_address_t local4, remote4;
12248 ip6_address_t local6, remote6;
12250 u8 ipv4_set = 0, ipv6_set = 0;
12254 u32 mcast_sw_if_index = ~0;
12255 u32 encap_vrf_id = 0;
12256 u32 decap_vrf_id = 0;
12262 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12263 memset (&local4, 0, sizeof local4);
12264 memset (&remote4, 0, sizeof remote4);
12265 memset (&local6, 0, sizeof local6);
12266 memset (&remote6, 0, sizeof remote6);
12268 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12270 if (unformat (line_input, "del"))
12272 else if (unformat (line_input, "local %U",
12273 unformat_ip4_address, &local4))
12278 else if (unformat (line_input, "remote %U",
12279 unformat_ip4_address, &remote4))
12284 else if (unformat (line_input, "local %U",
12285 unformat_ip6_address, &local6))
12290 else if (unformat (line_input, "remote %U",
12291 unformat_ip6_address, &remote6))
12296 else if (unformat (line_input, "group %U %U",
12297 unformat_ip4_address, &remote4,
12298 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12300 grp_set = remote_set = 1;
12303 else if (unformat (line_input, "group %U",
12304 unformat_ip4_address, &remote4))
12306 grp_set = remote_set = 1;
12309 else if (unformat (line_input, "group %U %U",
12310 unformat_ip6_address, &remote6,
12311 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12313 grp_set = remote_set = 1;
12316 else if (unformat (line_input, "group %U",
12317 unformat_ip6_address, &remote6))
12319 grp_set = remote_set = 1;
12323 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12325 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12327 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12329 else if (unformat (line_input, "vni %d", &vni))
12331 else if (unformat (line_input, "next-ip4"))
12333 else if (unformat (line_input, "next-ip6"))
12335 else if (unformat (line_input, "next-ethernet"))
12337 else if (unformat (line_input, "next-nsh"))
12341 errmsg ("parse error '%U'", format_unformat_error, line_input);
12346 if (local_set == 0)
12348 errmsg ("tunnel local address not specified");
12351 if (remote_set == 0)
12353 errmsg ("tunnel remote address not specified");
12356 if (grp_set && mcast_sw_if_index == ~0)
12358 errmsg ("tunnel nonexistent multicast device");
12361 if (ipv4_set && ipv6_set)
12363 errmsg ("both IPv4 and IPv6 addresses specified");
12369 errmsg ("vni not specified");
12373 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12378 clib_memcpy (&mp->local, &local6, sizeof (local6));
12379 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12383 clib_memcpy (&mp->local, &local4, sizeof (local4));
12384 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12387 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12388 mp->encap_vrf_id = ntohl (encap_vrf_id);
12389 mp->decap_vrf_id = ntohl (decap_vrf_id);
12390 mp->protocol = protocol;
12391 mp->vni = ntohl (vni);
12392 mp->is_add = is_add;
12393 mp->is_ipv6 = ipv6_set;
12400 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12401 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12403 vat_main_t *vam = &vat_main;
12404 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12405 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12407 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12408 ntohl (mp->sw_if_index),
12409 format_ip46_address, &local, IP46_TYPE_ANY,
12410 format_ip46_address, &remote, IP46_TYPE_ANY,
12411 ntohl (mp->vni), mp->protocol,
12412 ntohl (mp->mcast_sw_if_index),
12413 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12417 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12418 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12420 vat_main_t *vam = &vat_main;
12421 vat_json_node_t *node = NULL;
12422 struct in_addr ip4;
12423 struct in6_addr ip6;
12425 if (VAT_JSON_ARRAY != vam->json_tree.type)
12427 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12428 vat_json_init_array (&vam->json_tree);
12430 node = vat_json_array_add (&vam->json_tree);
12432 vat_json_init_object (node);
12433 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12436 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12437 vat_json_object_add_ip6 (node, "local", ip6);
12438 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12439 vat_json_object_add_ip6 (node, "remote", ip6);
12443 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12444 vat_json_object_add_ip4 (node, "local", ip4);
12445 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12446 vat_json_object_add_ip4 (node, "remote", ip4);
12448 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12449 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12450 vat_json_object_add_uint (node, "mcast_sw_if_index",
12451 ntohl (mp->mcast_sw_if_index));
12452 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12453 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12454 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12458 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12460 unformat_input_t *i = vam->input;
12461 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12462 vl_api_control_ping_t *mp_ping;
12464 u8 sw_if_index_set = 0;
12467 /* Parse args required to build the message */
12468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12470 if (unformat (i, "sw_if_index %d", &sw_if_index))
12471 sw_if_index_set = 1;
12476 if (sw_if_index_set == 0)
12481 if (!vam->json_output)
12483 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12484 "sw_if_index", "local", "remote", "vni",
12485 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12488 /* Get list of vxlan-tunnel interfaces */
12489 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12491 mp->sw_if_index = htonl (sw_if_index);
12495 /* Use a control ping for synchronization */
12496 M (CONTROL_PING, mp_ping);
12505 format_l2_fib_mac_address (u8 * s, va_list * args)
12507 u8 *a = va_arg (*args, u8 *);
12509 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
12510 a[2], a[3], a[4], a[5], a[6], a[7]);
12513 static void vl_api_l2_fib_table_details_t_handler
12514 (vl_api_l2_fib_table_details_t * mp)
12516 vat_main_t *vam = &vat_main;
12518 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12520 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
12521 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12525 static void vl_api_l2_fib_table_details_t_handler_json
12526 (vl_api_l2_fib_table_details_t * mp)
12528 vat_main_t *vam = &vat_main;
12529 vat_json_node_t *node = NULL;
12531 if (VAT_JSON_ARRAY != vam->json_tree.type)
12533 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12534 vat_json_init_array (&vam->json_tree);
12536 node = vat_json_array_add (&vam->json_tree);
12538 vat_json_init_object (node);
12539 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12540 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
12541 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12542 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12543 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12544 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12548 api_l2_fib_table_dump (vat_main_t * vam)
12550 unformat_input_t *i = vam->input;
12551 vl_api_l2_fib_table_dump_t *mp;
12552 vl_api_control_ping_t *mp_ping;
12557 /* Parse args required to build the message */
12558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12560 if (unformat (i, "bd_id %d", &bd_id))
12566 if (bd_id_set == 0)
12568 errmsg ("missing bridge domain");
12572 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12574 /* Get list of l2 fib entries */
12575 M (L2_FIB_TABLE_DUMP, mp);
12577 mp->bd_id = ntohl (bd_id);
12580 /* Use a control ping for synchronization */
12581 M (CONTROL_PING, mp_ping);
12590 api_interface_name_renumber (vat_main_t * vam)
12592 unformat_input_t *line_input = vam->input;
12593 vl_api_interface_name_renumber_t *mp;
12594 u32 sw_if_index = ~0;
12595 u32 new_show_dev_instance = ~0;
12598 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12600 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
12603 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12605 else if (unformat (line_input, "new_show_dev_instance %d",
12606 &new_show_dev_instance))
12612 if (sw_if_index == ~0)
12614 errmsg ("missing interface name or sw_if_index");
12618 if (new_show_dev_instance == ~0)
12620 errmsg ("missing new_show_dev_instance");
12624 M (INTERFACE_NAME_RENUMBER, mp);
12626 mp->sw_if_index = ntohl (sw_if_index);
12627 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
12635 api_want_ip4_arp_events (vat_main_t * vam)
12637 unformat_input_t *line_input = vam->input;
12638 vl_api_want_ip4_arp_events_t *mp;
12639 ip4_address_t address;
12640 int address_set = 0;
12641 u32 enable_disable = 1;
12644 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12646 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
12648 else if (unformat (line_input, "del"))
12649 enable_disable = 0;
12654 if (address_set == 0)
12656 errmsg ("missing addresses");
12660 M (WANT_IP4_ARP_EVENTS, mp);
12661 mp->enable_disable = enable_disable;
12662 mp->pid = htonl (getpid ());
12663 mp->address = address.as_u32;
12671 api_want_ip6_nd_events (vat_main_t * vam)
12673 unformat_input_t *line_input = vam->input;
12674 vl_api_want_ip6_nd_events_t *mp;
12675 ip6_address_t address;
12676 int address_set = 0;
12677 u32 enable_disable = 1;
12680 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12682 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
12684 else if (unformat (line_input, "del"))
12685 enable_disable = 0;
12690 if (address_set == 0)
12692 errmsg ("missing addresses");
12696 M (WANT_IP6_ND_EVENTS, mp);
12697 mp->enable_disable = enable_disable;
12698 mp->pid = htonl (getpid ());
12699 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
12707 api_want_l2_macs_events (vat_main_t * vam)
12709 unformat_input_t *line_input = vam->input;
12710 vl_api_want_l2_macs_events_t *mp;
12711 u8 enable_disable = 1;
12712 u32 scan_delay = 0;
12713 u32 max_macs_in_event = 0;
12714 u32 learn_limit = 0;
12717 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12719 if (unformat (line_input, "learn-limit %d", &learn_limit))
12721 else if (unformat (line_input, "scan-delay %d", &scan_delay))
12723 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
12725 else if (unformat (line_input, "disable"))
12726 enable_disable = 0;
12731 M (WANT_L2_MACS_EVENTS, mp);
12732 mp->enable_disable = enable_disable;
12733 mp->pid = htonl (getpid ());
12734 mp->learn_limit = htonl (learn_limit);
12735 mp->scan_delay = (u8) scan_delay;
12736 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
12743 api_input_acl_set_interface (vat_main_t * vam)
12745 unformat_input_t *i = vam->input;
12746 vl_api_input_acl_set_interface_t *mp;
12748 int sw_if_index_set;
12749 u32 ip4_table_index = ~0;
12750 u32 ip6_table_index = ~0;
12751 u32 l2_table_index = ~0;
12755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12757 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12758 sw_if_index_set = 1;
12759 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12760 sw_if_index_set = 1;
12761 else if (unformat (i, "del"))
12763 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12765 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12767 else if (unformat (i, "l2-table %d", &l2_table_index))
12771 clib_warning ("parse error '%U'", format_unformat_error, i);
12776 if (sw_if_index_set == 0)
12778 errmsg ("missing interface name or sw_if_index");
12782 M (INPUT_ACL_SET_INTERFACE, mp);
12784 mp->sw_if_index = ntohl (sw_if_index);
12785 mp->ip4_table_index = ntohl (ip4_table_index);
12786 mp->ip6_table_index = ntohl (ip6_table_index);
12787 mp->l2_table_index = ntohl (l2_table_index);
12788 mp->is_add = is_add;
12796 api_ip_address_dump (vat_main_t * vam)
12798 unformat_input_t *i = vam->input;
12799 vl_api_ip_address_dump_t *mp;
12800 vl_api_control_ping_t *mp_ping;
12801 u32 sw_if_index = ~0;
12802 u8 sw_if_index_set = 0;
12807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12809 if (unformat (i, "sw_if_index %d", &sw_if_index))
12810 sw_if_index_set = 1;
12812 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12813 sw_if_index_set = 1;
12814 else if (unformat (i, "ipv4"))
12816 else if (unformat (i, "ipv6"))
12822 if (ipv4_set && ipv6_set)
12824 errmsg ("ipv4 and ipv6 flags cannot be both set");
12828 if ((!ipv4_set) && (!ipv6_set))
12830 errmsg ("no ipv4 nor ipv6 flag set");
12834 if (sw_if_index_set == 0)
12836 errmsg ("missing interface name or sw_if_index");
12840 vam->current_sw_if_index = sw_if_index;
12841 vam->is_ipv6 = ipv6_set;
12843 M (IP_ADDRESS_DUMP, mp);
12844 mp->sw_if_index = ntohl (sw_if_index);
12845 mp->is_ipv6 = ipv6_set;
12848 /* Use a control ping for synchronization */
12849 M (CONTROL_PING, mp_ping);
12857 api_ip_dump (vat_main_t * vam)
12859 vl_api_ip_dump_t *mp;
12860 vl_api_control_ping_t *mp_ping;
12861 unformat_input_t *in = vam->input;
12868 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
12870 if (unformat (in, "ipv4"))
12872 else if (unformat (in, "ipv6"))
12878 if (ipv4_set && ipv6_set)
12880 errmsg ("ipv4 and ipv6 flags cannot be both set");
12884 if ((!ipv4_set) && (!ipv6_set))
12886 errmsg ("no ipv4 nor ipv6 flag set");
12890 is_ipv6 = ipv6_set;
12891 vam->is_ipv6 = is_ipv6;
12893 /* free old data */
12894 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12896 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12898 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12901 mp->is_ipv6 = ipv6_set;
12904 /* Use a control ping for synchronization */
12905 M (CONTROL_PING, mp_ping);
12913 api_ipsec_spd_add_del (vat_main_t * vam)
12915 unformat_input_t *i = vam->input;
12916 vl_api_ipsec_spd_add_del_t *mp;
12921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12923 if (unformat (i, "spd_id %d", &spd_id))
12925 else if (unformat (i, "del"))
12929 clib_warning ("parse error '%U'", format_unformat_error, i);
12935 errmsg ("spd_id must be set");
12939 M (IPSEC_SPD_ADD_DEL, mp);
12941 mp->spd_id = ntohl (spd_id);
12942 mp->is_add = is_add;
12950 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12952 unformat_input_t *i = vam->input;
12953 vl_api_ipsec_interface_add_del_spd_t *mp;
12955 u8 sw_if_index_set = 0;
12956 u32 spd_id = (u32) ~ 0;
12960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12962 if (unformat (i, "del"))
12964 else if (unformat (i, "spd_id %d", &spd_id))
12967 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12968 sw_if_index_set = 1;
12969 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12970 sw_if_index_set = 1;
12973 clib_warning ("parse error '%U'", format_unformat_error, i);
12979 if (spd_id == (u32) ~ 0)
12981 errmsg ("spd_id must be set");
12985 if (sw_if_index_set == 0)
12987 errmsg ("missing interface name or sw_if_index");
12991 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12993 mp->spd_id = ntohl (spd_id);
12994 mp->sw_if_index = ntohl (sw_if_index);
12995 mp->is_add = is_add;
13003 api_ipsec_spd_add_del_entry (vat_main_t * vam)
13005 unformat_input_t *i = vam->input;
13006 vl_api_ipsec_spd_add_del_entry_t *mp;
13007 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
13008 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13010 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13011 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13012 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
13013 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
13016 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
13017 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
13018 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
13019 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
13020 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
13021 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
13023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13025 if (unformat (i, "del"))
13027 if (unformat (i, "outbound"))
13029 if (unformat (i, "inbound"))
13031 else if (unformat (i, "spd_id %d", &spd_id))
13033 else if (unformat (i, "sa_id %d", &sa_id))
13035 else if (unformat (i, "priority %d", &priority))
13037 else if (unformat (i, "protocol %d", &protocol))
13039 else if (unformat (i, "lport_start %d", &lport_start))
13041 else if (unformat (i, "lport_stop %d", &lport_stop))
13043 else if (unformat (i, "rport_start %d", &rport_start))
13045 else if (unformat (i, "rport_stop %d", &rport_stop))
13049 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
13055 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
13062 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
13068 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
13075 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
13081 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
13088 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
13094 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
13100 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13102 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13104 clib_warning ("unsupported action: 'resolve'");
13110 clib_warning ("parse error '%U'", format_unformat_error, i);
13116 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
13118 mp->spd_id = ntohl (spd_id);
13119 mp->priority = ntohl (priority);
13120 mp->is_outbound = is_outbound;
13122 mp->is_ipv6 = is_ipv6;
13123 if (is_ipv6 || is_ip_any)
13125 clib_memcpy (mp->remote_address_start, &raddr6_start,
13126 sizeof (ip6_address_t));
13127 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
13128 sizeof (ip6_address_t));
13129 clib_memcpy (mp->local_address_start, &laddr6_start,
13130 sizeof (ip6_address_t));
13131 clib_memcpy (mp->local_address_stop, &laddr6_stop,
13132 sizeof (ip6_address_t));
13136 clib_memcpy (mp->remote_address_start, &raddr4_start,
13137 sizeof (ip4_address_t));
13138 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
13139 sizeof (ip4_address_t));
13140 clib_memcpy (mp->local_address_start, &laddr4_start,
13141 sizeof (ip4_address_t));
13142 clib_memcpy (mp->local_address_stop, &laddr4_stop,
13143 sizeof (ip4_address_t));
13145 mp->protocol = (u8) protocol;
13146 mp->local_port_start = ntohs ((u16) lport_start);
13147 mp->local_port_stop = ntohs ((u16) lport_stop);
13148 mp->remote_port_start = ntohs ((u16) rport_start);
13149 mp->remote_port_stop = ntohs ((u16) rport_stop);
13150 mp->policy = (u8) policy;
13151 mp->sa_id = ntohl (sa_id);
13152 mp->is_add = is_add;
13153 mp->is_ip_any = is_ip_any;
13160 api_ipsec_sad_add_del_entry (vat_main_t * vam)
13162 unformat_input_t *i = vam->input;
13163 vl_api_ipsec_sad_add_del_entry_t *mp;
13164 u32 sad_id = 0, spi = 0;
13165 u8 *ck = 0, *ik = 0;
13168 u8 protocol = IPSEC_PROTOCOL_AH;
13169 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
13170 u32 crypto_alg = 0, integ_alg = 0;
13171 ip4_address_t tun_src4;
13172 ip4_address_t tun_dst4;
13173 ip6_address_t tun_src6;
13174 ip6_address_t tun_dst6;
13177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13179 if (unformat (i, "del"))
13181 else if (unformat (i, "sad_id %d", &sad_id))
13183 else if (unformat (i, "spi %d", &spi))
13185 else if (unformat (i, "esp"))
13186 protocol = IPSEC_PROTOCOL_ESP;
13187 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
13190 is_tunnel_ipv6 = 0;
13192 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
13195 is_tunnel_ipv6 = 0;
13197 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
13200 is_tunnel_ipv6 = 1;
13202 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
13205 is_tunnel_ipv6 = 1;
13209 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
13211 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
13212 crypto_alg >= IPSEC_CRYPTO_N_ALG)
13214 clib_warning ("unsupported crypto-alg: '%U'",
13215 format_ipsec_crypto_alg, crypto_alg);
13219 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13223 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
13225 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
13226 integ_alg >= IPSEC_INTEG_N_ALG)
13228 clib_warning ("unsupported integ-alg: '%U'",
13229 format_ipsec_integ_alg, integ_alg);
13233 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13237 clib_warning ("parse error '%U'", format_unformat_error, i);
13243 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
13245 mp->sad_id = ntohl (sad_id);
13246 mp->is_add = is_add;
13247 mp->protocol = protocol;
13248 mp->spi = ntohl (spi);
13249 mp->is_tunnel = is_tunnel;
13250 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
13251 mp->crypto_algorithm = crypto_alg;
13252 mp->integrity_algorithm = integ_alg;
13253 mp->crypto_key_length = vec_len (ck);
13254 mp->integrity_key_length = vec_len (ik);
13256 if (mp->crypto_key_length > sizeof (mp->crypto_key))
13257 mp->crypto_key_length = sizeof (mp->crypto_key);
13259 if (mp->integrity_key_length > sizeof (mp->integrity_key))
13260 mp->integrity_key_length = sizeof (mp->integrity_key);
13263 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
13265 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
13269 if (is_tunnel_ipv6)
13271 clib_memcpy (mp->tunnel_src_address, &tun_src6,
13272 sizeof (ip6_address_t));
13273 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
13274 sizeof (ip6_address_t));
13278 clib_memcpy (mp->tunnel_src_address, &tun_src4,
13279 sizeof (ip4_address_t));
13280 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
13281 sizeof (ip4_address_t));
13291 api_ipsec_sa_set_key (vat_main_t * vam)
13293 unformat_input_t *i = vam->input;
13294 vl_api_ipsec_sa_set_key_t *mp;
13296 u8 *ck = 0, *ik = 0;
13299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13301 if (unformat (i, "sa_id %d", &sa_id))
13303 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13305 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13309 clib_warning ("parse error '%U'", format_unformat_error, i);
13314 M (IPSEC_SA_SET_KEY, mp);
13316 mp->sa_id = ntohl (sa_id);
13317 mp->crypto_key_length = vec_len (ck);
13318 mp->integrity_key_length = vec_len (ik);
13320 if (mp->crypto_key_length > sizeof (mp->crypto_key))
13321 mp->crypto_key_length = sizeof (mp->crypto_key);
13323 if (mp->integrity_key_length > sizeof (mp->integrity_key))
13324 mp->integrity_key_length = sizeof (mp->integrity_key);
13327 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
13329 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
13337 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13339 unformat_input_t *i = vam->input;
13340 vl_api_ipsec_tunnel_if_add_del_t *mp;
13341 u32 local_spi = 0, remote_spi = 0;
13342 u32 crypto_alg = 0, integ_alg = 0;
13343 u8 *lck = NULL, *rck = NULL;
13344 u8 *lik = NULL, *rik = NULL;
13345 ip4_address_t local_ip = { {0} };
13346 ip4_address_t remote_ip = { {0} };
13349 u8 anti_replay = 0;
13352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13354 if (unformat (i, "del"))
13356 else if (unformat (i, "esn"))
13358 else if (unformat (i, "anti_replay"))
13360 else if (unformat (i, "local_spi %d", &local_spi))
13362 else if (unformat (i, "remote_spi %d", &remote_spi))
13364 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
13366 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
13368 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13371 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13373 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13375 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13379 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
13381 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
13382 crypto_alg >= IPSEC_CRYPTO_N_ALG)
13384 errmsg ("unsupported crypto-alg: '%U'\n",
13385 format_ipsec_crypto_alg, crypto_alg);
13391 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
13393 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
13394 integ_alg >= IPSEC_INTEG_N_ALG)
13396 errmsg ("unsupported integ-alg: '%U'\n",
13397 format_ipsec_integ_alg, integ_alg);
13403 errmsg ("parse error '%U'\n", format_unformat_error, i);
13408 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13410 mp->is_add = is_add;
13412 mp->anti_replay = anti_replay;
13414 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
13415 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
13417 mp->local_spi = htonl (local_spi);
13418 mp->remote_spi = htonl (remote_spi);
13419 mp->crypto_alg = (u8) crypto_alg;
13421 mp->local_crypto_key_len = 0;
13424 mp->local_crypto_key_len = vec_len (lck);
13425 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13426 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13427 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13430 mp->remote_crypto_key_len = 0;
13433 mp->remote_crypto_key_len = vec_len (rck);
13434 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13435 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13436 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13439 mp->integ_alg = (u8) integ_alg;
13441 mp->local_integ_key_len = 0;
13444 mp->local_integ_key_len = vec_len (lik);
13445 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13446 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13447 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13450 mp->remote_integ_key_len = 0;
13453 mp->remote_integ_key_len = vec_len (rik);
13454 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13455 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13456 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13465 api_ikev2_profile_add_del (vat_main_t * vam)
13467 unformat_input_t *i = vam->input;
13468 vl_api_ikev2_profile_add_del_t *mp;
13473 const char *valid_chars = "a-zA-Z0-9_";
13475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13477 if (unformat (i, "del"))
13479 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13480 vec_add1 (name, 0);
13483 errmsg ("parse error '%U'", format_unformat_error, i);
13488 if (!vec_len (name))
13490 errmsg ("profile name must be specified");
13494 if (vec_len (name) > 64)
13496 errmsg ("profile name too long");
13500 M (IKEV2_PROFILE_ADD_DEL, mp);
13502 clib_memcpy (mp->name, name, vec_len (name));
13503 mp->is_add = is_add;
13512 api_ikev2_profile_set_auth (vat_main_t * vam)
13514 unformat_input_t *i = vam->input;
13515 vl_api_ikev2_profile_set_auth_t *mp;
13518 u32 auth_method = 0;
13522 const char *valid_chars = "a-zA-Z0-9_";
13524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13526 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13527 vec_add1 (name, 0);
13528 else if (unformat (i, "auth_method %U",
13529 unformat_ikev2_auth_method, &auth_method))
13531 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
13533 else if (unformat (i, "auth_data %v", &data))
13537 errmsg ("parse error '%U'", format_unformat_error, i);
13542 if (!vec_len (name))
13544 errmsg ("profile name must be specified");
13548 if (vec_len (name) > 64)
13550 errmsg ("profile name too long");
13554 if (!vec_len (data))
13556 errmsg ("auth_data must be specified");
13562 errmsg ("auth_method must be specified");
13566 M (IKEV2_PROFILE_SET_AUTH, mp);
13568 mp->is_hex = is_hex;
13569 mp->auth_method = (u8) auth_method;
13570 mp->data_len = vec_len (data);
13571 clib_memcpy (mp->name, name, vec_len (name));
13572 clib_memcpy (mp->data, data, vec_len (data));
13582 api_ikev2_profile_set_id (vat_main_t * vam)
13584 unformat_input_t *i = vam->input;
13585 vl_api_ikev2_profile_set_id_t *mp;
13593 const char *valid_chars = "a-zA-Z0-9_";
13595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13597 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13598 vec_add1 (name, 0);
13599 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
13601 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
13603 data = vec_new (u8, 4);
13604 clib_memcpy (data, ip4.as_u8, 4);
13606 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
13608 else if (unformat (i, "id_data %v", &data))
13610 else if (unformat (i, "local"))
13612 else if (unformat (i, "remote"))
13616 errmsg ("parse error '%U'", format_unformat_error, i);
13621 if (!vec_len (name))
13623 errmsg ("profile name must be specified");
13627 if (vec_len (name) > 64)
13629 errmsg ("profile name too long");
13633 if (!vec_len (data))
13635 errmsg ("id_data must be specified");
13641 errmsg ("id_type must be specified");
13645 M (IKEV2_PROFILE_SET_ID, mp);
13647 mp->is_local = is_local;
13648 mp->id_type = (u8) id_type;
13649 mp->data_len = vec_len (data);
13650 clib_memcpy (mp->name, name, vec_len (name));
13651 clib_memcpy (mp->data, data, vec_len (data));
13661 api_ikev2_profile_set_ts (vat_main_t * vam)
13663 unformat_input_t *i = vam->input;
13664 vl_api_ikev2_profile_set_ts_t *mp;
13667 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
13668 ip4_address_t start_addr, end_addr;
13670 const char *valid_chars = "a-zA-Z0-9_";
13673 start_addr.as_u32 = 0;
13674 end_addr.as_u32 = (u32) ~ 0;
13676 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13678 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13679 vec_add1 (name, 0);
13680 else if (unformat (i, "protocol %d", &proto))
13682 else if (unformat (i, "start_port %d", &start_port))
13684 else if (unformat (i, "end_port %d", &end_port))
13687 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
13689 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
13691 else if (unformat (i, "local"))
13693 else if (unformat (i, "remote"))
13697 errmsg ("parse error '%U'", format_unformat_error, i);
13702 if (!vec_len (name))
13704 errmsg ("profile name must be specified");
13708 if (vec_len (name) > 64)
13710 errmsg ("profile name too long");
13714 M (IKEV2_PROFILE_SET_TS, mp);
13716 mp->is_local = is_local;
13717 mp->proto = (u8) proto;
13718 mp->start_port = (u16) start_port;
13719 mp->end_port = (u16) end_port;
13720 mp->start_addr = start_addr.as_u32;
13721 mp->end_addr = end_addr.as_u32;
13722 clib_memcpy (mp->name, name, vec_len (name));
13731 api_ikev2_set_local_key (vat_main_t * vam)
13733 unformat_input_t *i = vam->input;
13734 vl_api_ikev2_set_local_key_t *mp;
13738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13740 if (unformat (i, "file %v", &file))
13741 vec_add1 (file, 0);
13744 errmsg ("parse error '%U'", format_unformat_error, i);
13749 if (!vec_len (file))
13751 errmsg ("RSA key file must be specified");
13755 if (vec_len (file) > 256)
13757 errmsg ("file name too long");
13761 M (IKEV2_SET_LOCAL_KEY, mp);
13763 clib_memcpy (mp->key_file, file, vec_len (file));
13772 api_ikev2_set_responder (vat_main_t * vam)
13774 unformat_input_t *i = vam->input;
13775 vl_api_ikev2_set_responder_t *mp;
13778 u32 sw_if_index = ~0;
13779 ip4_address_t address;
13781 const char *valid_chars = "a-zA-Z0-9_";
13783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13786 (i, "%U interface %d address %U", unformat_token, valid_chars,
13787 &name, &sw_if_index, unformat_ip4_address, &address))
13788 vec_add1 (name, 0);
13791 errmsg ("parse error '%U'", format_unformat_error, i);
13796 if (!vec_len (name))
13798 errmsg ("profile name must be specified");
13802 if (vec_len (name) > 64)
13804 errmsg ("profile name too long");
13808 M (IKEV2_SET_RESPONDER, mp);
13810 clib_memcpy (mp->name, name, vec_len (name));
13813 mp->sw_if_index = sw_if_index;
13814 clib_memcpy (mp->address, &address, sizeof (address));
13822 api_ikev2_set_ike_transforms (vat_main_t * vam)
13824 unformat_input_t *i = vam->input;
13825 vl_api_ikev2_set_ike_transforms_t *mp;
13828 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13830 const char *valid_chars = "a-zA-Z0-9_";
13832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13834 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13835 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13836 vec_add1 (name, 0);
13839 errmsg ("parse error '%U'", format_unformat_error, i);
13844 if (!vec_len (name))
13846 errmsg ("profile name must be specified");
13850 if (vec_len (name) > 64)
13852 errmsg ("profile name too long");
13856 M (IKEV2_SET_IKE_TRANSFORMS, mp);
13858 clib_memcpy (mp->name, name, vec_len (name));
13860 mp->crypto_alg = crypto_alg;
13861 mp->crypto_key_size = crypto_key_size;
13862 mp->integ_alg = integ_alg;
13863 mp->dh_group = dh_group;
13872 api_ikev2_set_esp_transforms (vat_main_t * vam)
13874 unformat_input_t *i = vam->input;
13875 vl_api_ikev2_set_esp_transforms_t *mp;
13878 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13880 const char *valid_chars = "a-zA-Z0-9_";
13882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13884 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13885 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13886 vec_add1 (name, 0);
13889 errmsg ("parse error '%U'", format_unformat_error, i);
13894 if (!vec_len (name))
13896 errmsg ("profile name must be specified");
13900 if (vec_len (name) > 64)
13902 errmsg ("profile name too long");
13906 M (IKEV2_SET_ESP_TRANSFORMS, mp);
13908 clib_memcpy (mp->name, name, vec_len (name));
13910 mp->crypto_alg = crypto_alg;
13911 mp->crypto_key_size = crypto_key_size;
13912 mp->integ_alg = integ_alg;
13913 mp->dh_group = dh_group;
13921 api_ikev2_set_sa_lifetime (vat_main_t * vam)
13923 unformat_input_t *i = vam->input;
13924 vl_api_ikev2_set_sa_lifetime_t *mp;
13927 u64 lifetime, lifetime_maxdata;
13928 u32 lifetime_jitter, handover;
13930 const char *valid_chars = "a-zA-Z0-9_";
13932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13934 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
13935 &lifetime, &lifetime_jitter, &handover,
13936 &lifetime_maxdata))
13937 vec_add1 (name, 0);
13940 errmsg ("parse error '%U'", format_unformat_error, i);
13945 if (!vec_len (name))
13947 errmsg ("profile name must be specified");
13951 if (vec_len (name) > 64)
13953 errmsg ("profile name too long");
13957 M (IKEV2_SET_SA_LIFETIME, mp);
13959 clib_memcpy (mp->name, name, vec_len (name));
13961 mp->lifetime = lifetime;
13962 mp->lifetime_jitter = lifetime_jitter;
13963 mp->handover = handover;
13964 mp->lifetime_maxdata = lifetime_maxdata;
13972 api_ikev2_initiate_sa_init (vat_main_t * vam)
13974 unformat_input_t *i = vam->input;
13975 vl_api_ikev2_initiate_sa_init_t *mp;
13979 const char *valid_chars = "a-zA-Z0-9_";
13981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13983 if (unformat (i, "%U", unformat_token, valid_chars, &name))
13984 vec_add1 (name, 0);
13987 errmsg ("parse error '%U'", format_unformat_error, i);
13992 if (!vec_len (name))
13994 errmsg ("profile name must be specified");
13998 if (vec_len (name) > 64)
14000 errmsg ("profile name too long");
14004 M (IKEV2_INITIATE_SA_INIT, mp);
14006 clib_memcpy (mp->name, name, vec_len (name));
14015 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
14017 unformat_input_t *i = vam->input;
14018 vl_api_ikev2_initiate_del_ike_sa_t *mp;
14023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14025 if (unformat (i, "%lx", &ispi))
14029 errmsg ("parse error '%U'", format_unformat_error, i);
14034 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
14044 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
14046 unformat_input_t *i = vam->input;
14047 vl_api_ikev2_initiate_del_child_sa_t *mp;
14052 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14054 if (unformat (i, "%x", &ispi))
14058 errmsg ("parse error '%U'", format_unformat_error, i);
14063 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
14073 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
14075 unformat_input_t *i = vam->input;
14076 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
14081 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14083 if (unformat (i, "%x", &ispi))
14087 errmsg ("parse error '%U'", format_unformat_error, i);
14092 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
14105 api_map_add_domain (vat_main_t * vam)
14107 unformat_input_t *i = vam->input;
14108 vl_api_map_add_domain_t *mp;
14110 ip4_address_t ip4_prefix;
14111 ip6_address_t ip6_prefix;
14112 ip6_address_t ip6_src;
14113 u32 num_m_args = 0;
14114 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
14115 0, psid_length = 0;
14116 u8 is_translation = 0;
14118 u32 ip6_src_len = 128;
14121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14123 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
14124 &ip4_prefix, &ip4_prefix_len))
14126 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
14127 &ip6_prefix, &ip6_prefix_len))
14131 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
14134 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
14136 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
14138 else if (unformat (i, "psid-offset %d", &psid_offset))
14140 else if (unformat (i, "psid-len %d", &psid_length))
14142 else if (unformat (i, "mtu %d", &mtu))
14144 else if (unformat (i, "map-t"))
14145 is_translation = 1;
14148 clib_warning ("parse error '%U'", format_unformat_error, i);
14153 if (num_m_args < 3)
14155 errmsg ("mandatory argument(s) missing");
14159 /* Construct the API message */
14160 M (MAP_ADD_DOMAIN, mp);
14162 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
14163 mp->ip4_prefix_len = ip4_prefix_len;
14165 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
14166 mp->ip6_prefix_len = ip6_prefix_len;
14168 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
14169 mp->ip6_src_prefix_len = ip6_src_len;
14171 mp->ea_bits_len = ea_bits_len;
14172 mp->psid_offset = psid_offset;
14173 mp->psid_length = psid_length;
14174 mp->is_translation = is_translation;
14175 mp->mtu = htons (mtu);
14180 /* Wait for a reply, return good/bad news */
14186 api_map_del_domain (vat_main_t * vam)
14188 unformat_input_t *i = vam->input;
14189 vl_api_map_del_domain_t *mp;
14191 u32 num_m_args = 0;
14195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14197 if (unformat (i, "index %d", &index))
14201 clib_warning ("parse error '%U'", format_unformat_error, i);
14206 if (num_m_args != 1)
14208 errmsg ("mandatory argument(s) missing");
14212 /* Construct the API message */
14213 M (MAP_DEL_DOMAIN, mp);
14215 mp->index = ntohl (index);
14220 /* Wait for a reply, return good/bad news */
14226 api_map_add_del_rule (vat_main_t * vam)
14228 unformat_input_t *i = vam->input;
14229 vl_api_map_add_del_rule_t *mp;
14231 ip6_address_t ip6_dst;
14232 u32 num_m_args = 0, index, psid = 0;
14235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14237 if (unformat (i, "index %d", &index))
14239 else if (unformat (i, "psid %d", &psid))
14241 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
14243 else if (unformat (i, "del"))
14249 clib_warning ("parse error '%U'", format_unformat_error, i);
14254 /* Construct the API message */
14255 M (MAP_ADD_DEL_RULE, mp);
14257 mp->index = ntohl (index);
14258 mp->is_add = is_add;
14259 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
14260 mp->psid = ntohs (psid);
14265 /* Wait for a reply, return good/bad news */
14271 api_map_domain_dump (vat_main_t * vam)
14273 vl_api_map_domain_dump_t *mp;
14274 vl_api_control_ping_t *mp_ping;
14277 /* Construct the API message */
14278 M (MAP_DOMAIN_DUMP, mp);
14283 /* Use a control ping for synchronization */
14284 M (CONTROL_PING, mp_ping);
14292 api_map_rule_dump (vat_main_t * vam)
14294 unformat_input_t *i = vam->input;
14295 vl_api_map_rule_dump_t *mp;
14296 vl_api_control_ping_t *mp_ping;
14297 u32 domain_index = ~0;
14300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14302 if (unformat (i, "index %u", &domain_index))
14308 if (domain_index == ~0)
14310 clib_warning ("parse error: domain index expected");
14314 /* Construct the API message */
14315 M (MAP_RULE_DUMP, mp);
14317 mp->domain_index = htonl (domain_index);
14322 /* Use a control ping for synchronization */
14323 M (CONTROL_PING, mp_ping);
14330 static void vl_api_map_add_domain_reply_t_handler
14331 (vl_api_map_add_domain_reply_t * mp)
14333 vat_main_t *vam = &vat_main;
14334 i32 retval = ntohl (mp->retval);
14336 if (vam->async_mode)
14338 vam->async_errors += (retval < 0);
14342 vam->retval = retval;
14343 vam->result_ready = 1;
14347 static void vl_api_map_add_domain_reply_t_handler_json
14348 (vl_api_map_add_domain_reply_t * mp)
14350 vat_main_t *vam = &vat_main;
14351 vat_json_node_t node;
14353 vat_json_init_object (&node);
14354 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
14355 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
14357 vat_json_print (vam->ofp, &node);
14358 vat_json_free (&node);
14360 vam->retval = ntohl (mp->retval);
14361 vam->result_ready = 1;
14365 api_get_first_msg_id (vat_main_t * vam)
14367 vl_api_get_first_msg_id_t *mp;
14368 unformat_input_t *i = vam->input;
14373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14375 if (unformat (i, "client %s", &name))
14383 errmsg ("missing client name");
14386 vec_add1 (name, 0);
14388 if (vec_len (name) > 63)
14390 errmsg ("client name too long");
14394 M (GET_FIRST_MSG_ID, mp);
14395 clib_memcpy (mp->name, name, vec_len (name));
14402 api_cop_interface_enable_disable (vat_main_t * vam)
14404 unformat_input_t *line_input = vam->input;
14405 vl_api_cop_interface_enable_disable_t *mp;
14406 u32 sw_if_index = ~0;
14407 u8 enable_disable = 1;
14410 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14412 if (unformat (line_input, "disable"))
14413 enable_disable = 0;
14414 if (unformat (line_input, "enable"))
14415 enable_disable = 1;
14416 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14417 vam, &sw_if_index))
14419 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14425 if (sw_if_index == ~0)
14427 errmsg ("missing interface name or sw_if_index");
14431 /* Construct the API message */
14432 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14433 mp->sw_if_index = ntohl (sw_if_index);
14434 mp->enable_disable = enable_disable;
14438 /* Wait for the reply */
14444 api_cop_whitelist_enable_disable (vat_main_t * vam)
14446 unformat_input_t *line_input = vam->input;
14447 vl_api_cop_whitelist_enable_disable_t *mp;
14448 u32 sw_if_index = ~0;
14449 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14453 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14455 if (unformat (line_input, "ip4"))
14457 else if (unformat (line_input, "ip6"))
14459 else if (unformat (line_input, "default"))
14461 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14462 vam, &sw_if_index))
14464 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14466 else if (unformat (line_input, "fib-id %d", &fib_id))
14472 if (sw_if_index == ~0)
14474 errmsg ("missing interface name or sw_if_index");
14478 /* Construct the API message */
14479 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14480 mp->sw_if_index = ntohl (sw_if_index);
14481 mp->fib_id = ntohl (fib_id);
14484 mp->default_cop = default_cop;
14488 /* Wait for the reply */
14494 api_get_node_graph (vat_main_t * vam)
14496 vl_api_get_node_graph_t *mp;
14499 M (GET_NODE_GRAPH, mp);
14503 /* Wait for the reply */
14509 /** Used for parsing LISP eids */
14510 typedef CLIB_PACKED(struct{
14511 u8 addr[16]; /**< eid address */
14512 u32 len; /**< prefix length if IP */
14513 u8 type; /**< type of eid */
14518 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14520 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14522 memset (a, 0, sizeof (a[0]));
14524 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14526 a->type = 0; /* ipv4 type */
14528 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14530 a->type = 1; /* ipv6 type */
14532 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14534 a->type = 2; /* mac type */
14536 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14538 a->type = 3; /* NSH type */
14539 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14540 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14547 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14556 lisp_eid_size_vat (u8 type)
14573 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14575 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14579 api_one_add_del_locator_set (vat_main_t * vam)
14581 unformat_input_t *input = vam->input;
14582 vl_api_one_add_del_locator_set_t *mp;
14584 u8 *locator_set_name = NULL;
14585 u8 locator_set_name_set = 0;
14586 vl_api_local_locator_t locator, *locators = 0;
14587 u32 sw_if_index, priority, weight;
14591 /* Parse args required to build the message */
14592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14594 if (unformat (input, "del"))
14598 else if (unformat (input, "locator-set %s", &locator_set_name))
14600 locator_set_name_set = 1;
14602 else if (unformat (input, "sw_if_index %u p %u w %u",
14603 &sw_if_index, &priority, &weight))
14605 locator.sw_if_index = htonl (sw_if_index);
14606 locator.priority = priority;
14607 locator.weight = weight;
14608 vec_add1 (locators, locator);
14612 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14613 &sw_if_index, &priority, &weight))
14615 locator.sw_if_index = htonl (sw_if_index);
14616 locator.priority = priority;
14617 locator.weight = weight;
14618 vec_add1 (locators, locator);
14624 if (locator_set_name_set == 0)
14626 errmsg ("missing locator-set name");
14627 vec_free (locators);
14631 if (vec_len (locator_set_name) > 64)
14633 errmsg ("locator-set name too long");
14634 vec_free (locator_set_name);
14635 vec_free (locators);
14638 vec_add1 (locator_set_name, 0);
14640 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14642 /* Construct the API message */
14643 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14645 mp->is_add = is_add;
14646 clib_memcpy (mp->locator_set_name, locator_set_name,
14647 vec_len (locator_set_name));
14648 vec_free (locator_set_name);
14650 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14652 clib_memcpy (mp->locators, locators, data_len);
14653 vec_free (locators);
14658 /* Wait for a reply... */
14663 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14666 api_one_add_del_locator (vat_main_t * vam)
14668 unformat_input_t *input = vam->input;
14669 vl_api_one_add_del_locator_t *mp;
14670 u32 tmp_if_index = ~0;
14671 u32 sw_if_index = ~0;
14672 u8 sw_if_index_set = 0;
14673 u8 sw_if_index_if_name_set = 0;
14675 u8 priority_set = 0;
14679 u8 *locator_set_name = NULL;
14680 u8 locator_set_name_set = 0;
14683 /* Parse args required to build the message */
14684 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14686 if (unformat (input, "del"))
14690 else if (unformat (input, "locator-set %s", &locator_set_name))
14692 locator_set_name_set = 1;
14694 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14697 sw_if_index_if_name_set = 1;
14698 sw_if_index = tmp_if_index;
14700 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14702 sw_if_index_set = 1;
14703 sw_if_index = tmp_if_index;
14705 else if (unformat (input, "p %d", &priority))
14709 else if (unformat (input, "w %d", &weight))
14717 if (locator_set_name_set == 0)
14719 errmsg ("missing locator-set name");
14723 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14725 errmsg ("missing sw_if_index");
14726 vec_free (locator_set_name);
14730 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14732 errmsg ("cannot use both params interface name and sw_if_index");
14733 vec_free (locator_set_name);
14737 if (priority_set == 0)
14739 errmsg ("missing locator-set priority");
14740 vec_free (locator_set_name);
14744 if (weight_set == 0)
14746 errmsg ("missing locator-set weight");
14747 vec_free (locator_set_name);
14751 if (vec_len (locator_set_name) > 64)
14753 errmsg ("locator-set name too long");
14754 vec_free (locator_set_name);
14757 vec_add1 (locator_set_name, 0);
14759 /* Construct the API message */
14760 M (ONE_ADD_DEL_LOCATOR, mp);
14762 mp->is_add = is_add;
14763 mp->sw_if_index = ntohl (sw_if_index);
14764 mp->priority = priority;
14765 mp->weight = weight;
14766 clib_memcpy (mp->locator_set_name, locator_set_name,
14767 vec_len (locator_set_name));
14768 vec_free (locator_set_name);
14773 /* Wait for a reply... */
14778 #define api_lisp_add_del_locator api_one_add_del_locator
14781 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14783 u32 *key_id = va_arg (*args, u32 *);
14786 if (unformat (input, "%s", &s))
14788 if (!strcmp ((char *) s, "sha1"))
14789 key_id[0] = HMAC_SHA_1_96;
14790 else if (!strcmp ((char *) s, "sha256"))
14791 key_id[0] = HMAC_SHA_256_128;
14794 clib_warning ("invalid key_id: '%s'", s);
14795 key_id[0] = HMAC_NO_KEY;
14806 api_one_add_del_local_eid (vat_main_t * vam)
14808 unformat_input_t *input = vam->input;
14809 vl_api_one_add_del_local_eid_t *mp;
14812 lisp_eid_vat_t _eid, *eid = &_eid;
14813 u8 *locator_set_name = 0;
14814 u8 locator_set_name_set = 0;
14820 /* Parse args required to build the message */
14821 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14823 if (unformat (input, "del"))
14827 else if (unformat (input, "vni %d", &vni))
14831 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14835 else if (unformat (input, "locator-set %s", &locator_set_name))
14837 locator_set_name_set = 1;
14839 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14841 else if (unformat (input, "secret-key %_%v%_", &key))
14847 if (locator_set_name_set == 0)
14849 errmsg ("missing locator-set name");
14855 errmsg ("EID address not set!");
14856 vec_free (locator_set_name);
14860 if (key && (0 == key_id))
14862 errmsg ("invalid key_id!");
14866 if (vec_len (key) > 64)
14868 errmsg ("key too long");
14873 if (vec_len (locator_set_name) > 64)
14875 errmsg ("locator-set name too long");
14876 vec_free (locator_set_name);
14879 vec_add1 (locator_set_name, 0);
14881 /* Construct the API message */
14882 M (ONE_ADD_DEL_LOCAL_EID, mp);
14884 mp->is_add = is_add;
14885 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14886 mp->eid_type = eid->type;
14887 mp->prefix_len = eid->len;
14888 mp->vni = clib_host_to_net_u32 (vni);
14889 mp->key_id = clib_host_to_net_u16 (key_id);
14890 clib_memcpy (mp->locator_set_name, locator_set_name,
14891 vec_len (locator_set_name));
14892 clib_memcpy (mp->key, key, vec_len (key));
14894 vec_free (locator_set_name);
14900 /* Wait for a reply... */
14905 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14908 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14910 u32 dp_table = 0, vni = 0;;
14911 unformat_input_t *input = vam->input;
14912 vl_api_gpe_add_del_fwd_entry_t *mp;
14914 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14915 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14916 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14917 u32 action = ~0, w;
14918 ip4_address_t rmt_rloc4, lcl_rloc4;
14919 ip6_address_t rmt_rloc6, lcl_rloc6;
14920 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14923 memset (&rloc, 0, sizeof (rloc));
14925 /* Parse args required to build the message */
14926 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14928 if (unformat (input, "del"))
14930 else if (unformat (input, "add"))
14932 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14936 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14940 else if (unformat (input, "vrf %d", &dp_table))
14942 else if (unformat (input, "bd %d", &dp_table))
14944 else if (unformat (input, "vni %d", &vni))
14946 else if (unformat (input, "w %d", &w))
14950 errmsg ("No RLOC configured for setting priority/weight!");
14953 curr_rloc->weight = w;
14955 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14956 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14960 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14962 vec_add1 (lcl_locs, rloc);
14964 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14965 vec_add1 (rmt_locs, rloc);
14966 /* weight saved in rmt loc */
14967 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14969 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14970 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14973 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14975 vec_add1 (lcl_locs, rloc);
14977 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14978 vec_add1 (rmt_locs, rloc);
14979 /* weight saved in rmt loc */
14980 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14982 else if (unformat (input, "action %d", &action))
14988 clib_warning ("parse error '%U'", format_unformat_error, input);
14995 errmsg ("remote eid addresses not set");
14999 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15001 errmsg ("eid types don't match");
15005 if (0 == rmt_locs && (u32) ~ 0 == action)
15007 errmsg ("action not set for negative mapping");
15011 /* Construct the API message */
15012 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15013 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15015 mp->is_add = is_add;
15016 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15017 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15018 mp->eid_type = rmt_eid->type;
15019 mp->dp_table = clib_host_to_net_u32 (dp_table);
15020 mp->vni = clib_host_to_net_u32 (vni);
15021 mp->rmt_len = rmt_eid->len;
15022 mp->lcl_len = lcl_eid->len;
15023 mp->action = action;
15025 if (0 != rmt_locs && 0 != lcl_locs)
15027 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15028 clib_memcpy (mp->locs, lcl_locs,
15029 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15031 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15032 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15033 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15035 vec_free (lcl_locs);
15036 vec_free (rmt_locs);
15041 /* Wait for a reply... */
15047 api_one_add_del_map_server (vat_main_t * vam)
15049 unformat_input_t *input = vam->input;
15050 vl_api_one_add_del_map_server_t *mp;
15054 ip4_address_t ipv4;
15055 ip6_address_t ipv6;
15058 /* Parse args required to build the message */
15059 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15061 if (unformat (input, "del"))
15065 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15069 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15077 if (ipv4_set && ipv6_set)
15079 errmsg ("both eid v4 and v6 addresses set");
15083 if (!ipv4_set && !ipv6_set)
15085 errmsg ("eid addresses not set");
15089 /* Construct the API message */
15090 M (ONE_ADD_DEL_MAP_SERVER, mp);
15092 mp->is_add = is_add;
15096 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15101 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15107 /* Wait for a reply... */
15112 #define api_lisp_add_del_map_server api_one_add_del_map_server
15115 api_one_add_del_map_resolver (vat_main_t * vam)
15117 unformat_input_t *input = vam->input;
15118 vl_api_one_add_del_map_resolver_t *mp;
15122 ip4_address_t ipv4;
15123 ip6_address_t ipv6;
15126 /* Parse args required to build the message */
15127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15129 if (unformat (input, "del"))
15133 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15137 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15145 if (ipv4_set && ipv6_set)
15147 errmsg ("both eid v4 and v6 addresses set");
15151 if (!ipv4_set && !ipv6_set)
15153 errmsg ("eid addresses not set");
15157 /* Construct the API message */
15158 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15160 mp->is_add = is_add;
15164 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15169 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15175 /* Wait for a reply... */
15180 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15183 api_lisp_gpe_enable_disable (vat_main_t * vam)
15185 unformat_input_t *input = vam->input;
15186 vl_api_gpe_enable_disable_t *mp;
15191 /* Parse args required to build the message */
15192 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15194 if (unformat (input, "enable"))
15199 else if (unformat (input, "disable"))
15210 errmsg ("Value not set");
15214 /* Construct the API message */
15215 M (GPE_ENABLE_DISABLE, mp);
15222 /* Wait for a reply... */
15228 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15230 unformat_input_t *input = vam->input;
15231 vl_api_one_rloc_probe_enable_disable_t *mp;
15236 /* Parse args required to build the message */
15237 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15239 if (unformat (input, "enable"))
15244 else if (unformat (input, "disable"))
15252 errmsg ("Value not set");
15256 /* Construct the API message */
15257 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15259 mp->is_enabled = is_en;
15264 /* Wait for a reply... */
15269 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15272 api_one_map_register_enable_disable (vat_main_t * vam)
15274 unformat_input_t *input = vam->input;
15275 vl_api_one_map_register_enable_disable_t *mp;
15280 /* Parse args required to build the message */
15281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15283 if (unformat (input, "enable"))
15288 else if (unformat (input, "disable"))
15296 errmsg ("Value not set");
15300 /* Construct the API message */
15301 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15303 mp->is_enabled = is_en;
15308 /* Wait for a reply... */
15313 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15316 api_one_enable_disable (vat_main_t * vam)
15318 unformat_input_t *input = vam->input;
15319 vl_api_one_enable_disable_t *mp;
15324 /* Parse args required to build the message */
15325 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15327 if (unformat (input, "enable"))
15332 else if (unformat (input, "disable"))
15342 errmsg ("Value not set");
15346 /* Construct the API message */
15347 M (ONE_ENABLE_DISABLE, mp);
15354 /* Wait for a reply... */
15359 #define api_lisp_enable_disable api_one_enable_disable
15362 api_show_one_map_register_state (vat_main_t * vam)
15364 vl_api_show_one_map_register_state_t *mp;
15367 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15372 /* wait for reply */
15377 #define api_show_lisp_map_register_state api_show_one_map_register_state
15380 api_show_one_rloc_probe_state (vat_main_t * vam)
15382 vl_api_show_one_rloc_probe_state_t *mp;
15385 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15390 /* wait for reply */
15395 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15398 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15400 vl_api_one_add_del_l2_arp_entry_t *mp;
15401 unformat_input_t *input = vam->input;
15406 u8 mac[6] = { 0, };
15407 u32 ip4 = 0, bd = ~0;
15410 /* Parse args required to build the message */
15411 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15413 if (unformat (input, "del"))
15415 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15417 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15419 else if (unformat (input, "bd %d", &bd))
15423 errmsg ("parse error '%U'", format_unformat_error, input);
15428 if (!bd_set || !ip_set || (!mac_set && is_add))
15430 errmsg ("Missing BD, IP or MAC!");
15434 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15435 mp->is_add = is_add;
15436 clib_memcpy (mp->mac, mac, 6);
15437 mp->bd = clib_host_to_net_u32 (bd);
15443 /* wait for reply */
15449 api_one_l2_arp_bd_get (vat_main_t * vam)
15451 vl_api_one_l2_arp_bd_get_t *mp;
15454 M (ONE_L2_ARP_BD_GET, mp);
15459 /* wait for reply */
15465 api_one_l2_arp_entries_get (vat_main_t * vam)
15467 vl_api_one_l2_arp_entries_get_t *mp;
15468 unformat_input_t *input = vam->input;
15473 /* Parse args required to build the message */
15474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15476 if (unformat (input, "bd %d", &bd))
15480 errmsg ("parse error '%U'", format_unformat_error, input);
15487 errmsg ("Expected bridge domain!");
15491 M (ONE_L2_ARP_ENTRIES_GET, mp);
15492 mp->bd = clib_host_to_net_u32 (bd);
15497 /* wait for reply */
15503 api_one_stats_enable_disable (vat_main_t * vam)
15505 vl_api_one_stats_enable_disable_t *mp;
15506 unformat_input_t *input = vam->input;
15511 /* Parse args required to build the message */
15512 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15514 if (unformat (input, "enable"))
15519 else if (unformat (input, "disable"))
15529 errmsg ("Value not set");
15533 M (ONE_STATS_ENABLE_DISABLE, mp);
15539 /* wait for reply */
15545 api_show_one_stats_enable_disable (vat_main_t * vam)
15547 vl_api_show_one_stats_enable_disable_t *mp;
15550 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15555 /* wait for reply */
15561 api_show_one_map_request_mode (vat_main_t * vam)
15563 vl_api_show_one_map_request_mode_t *mp;
15566 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15571 /* wait for reply */
15576 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15579 api_one_map_request_mode (vat_main_t * vam)
15581 unformat_input_t *input = vam->input;
15582 vl_api_one_map_request_mode_t *mp;
15586 /* Parse args required to build the message */
15587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15589 if (unformat (input, "dst-only"))
15591 else if (unformat (input, "src-dst"))
15595 errmsg ("parse error '%U'", format_unformat_error, input);
15600 M (ONE_MAP_REQUEST_MODE, mp);
15607 /* wait for reply */
15612 #define api_lisp_map_request_mode api_one_map_request_mode
15615 * Enable/disable ONE proxy ITR.
15617 * @param vam vpp API test context
15618 * @return return code
15621 api_one_pitr_set_locator_set (vat_main_t * vam)
15623 u8 ls_name_set = 0;
15624 unformat_input_t *input = vam->input;
15625 vl_api_one_pitr_set_locator_set_t *mp;
15630 /* Parse args required to build the message */
15631 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15633 if (unformat (input, "del"))
15635 else if (unformat (input, "locator-set %s", &ls_name))
15639 errmsg ("parse error '%U'", format_unformat_error, input);
15646 errmsg ("locator-set name not set!");
15650 M (ONE_PITR_SET_LOCATOR_SET, mp);
15652 mp->is_add = is_add;
15653 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15654 vec_free (ls_name);
15659 /* wait for reply */
15664 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15667 api_one_nsh_set_locator_set (vat_main_t * vam)
15669 u8 ls_name_set = 0;
15670 unformat_input_t *input = vam->input;
15671 vl_api_one_nsh_set_locator_set_t *mp;
15676 /* Parse args required to build the message */
15677 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15679 if (unformat (input, "del"))
15681 else if (unformat (input, "ls %s", &ls_name))
15685 errmsg ("parse error '%U'", format_unformat_error, input);
15690 if (!ls_name_set && is_add)
15692 errmsg ("locator-set name not set!");
15696 M (ONE_NSH_SET_LOCATOR_SET, mp);
15698 mp->is_add = is_add;
15699 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15700 vec_free (ls_name);
15705 /* wait for reply */
15711 api_show_one_pitr (vat_main_t * vam)
15713 vl_api_show_one_pitr_t *mp;
15716 if (!vam->json_output)
15718 print (vam->ofp, "%=20s", "lisp status:");
15721 M (SHOW_ONE_PITR, mp);
15725 /* Wait for a reply... */
15730 #define api_show_lisp_pitr api_show_one_pitr
15733 api_one_use_petr (vat_main_t * vam)
15735 unformat_input_t *input = vam->input;
15736 vl_api_one_use_petr_t *mp;
15741 memset (&ip, 0, sizeof (ip));
15743 /* Parse args required to build the message */
15744 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15746 if (unformat (input, "disable"))
15749 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15752 ip_addr_version (&ip) = IP4;
15755 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15758 ip_addr_version (&ip) = IP6;
15762 errmsg ("parse error '%U'", format_unformat_error, input);
15767 M (ONE_USE_PETR, mp);
15769 mp->is_add = is_add;
15772 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
15774 clib_memcpy (mp->address, &ip, 4);
15776 clib_memcpy (mp->address, &ip, 16);
15782 /* wait for reply */
15787 #define api_lisp_use_petr api_one_use_petr
15790 api_show_one_nsh_mapping (vat_main_t * vam)
15792 vl_api_show_one_use_petr_t *mp;
15795 if (!vam->json_output)
15797 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15800 M (SHOW_ONE_NSH_MAPPING, mp);
15804 /* Wait for a reply... */
15810 api_show_one_use_petr (vat_main_t * vam)
15812 vl_api_show_one_use_petr_t *mp;
15815 if (!vam->json_output)
15817 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15820 M (SHOW_ONE_USE_PETR, mp);
15824 /* Wait for a reply... */
15829 #define api_show_lisp_use_petr api_show_one_use_petr
15832 * Add/delete mapping between vni and vrf
15835 api_one_eid_table_add_del_map (vat_main_t * vam)
15837 unformat_input_t *input = vam->input;
15838 vl_api_one_eid_table_add_del_map_t *mp;
15839 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15840 u32 vni, vrf, bd_index;
15843 /* Parse args required to build the message */
15844 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15846 if (unformat (input, "del"))
15848 else if (unformat (input, "vrf %d", &vrf))
15850 else if (unformat (input, "bd_index %d", &bd_index))
15852 else if (unformat (input, "vni %d", &vni))
15858 if (!vni_set || (!vrf_set && !bd_index_set))
15860 errmsg ("missing arguments!");
15864 if (vrf_set && bd_index_set)
15866 errmsg ("error: both vrf and bd entered!");
15870 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15872 mp->is_add = is_add;
15873 mp->vni = htonl (vni);
15874 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15875 mp->is_l2 = bd_index_set;
15880 /* wait for reply */
15885 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15888 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15890 u32 *action = va_arg (*args, u32 *);
15893 if (unformat (input, "%s", &s))
15895 if (!strcmp ((char *) s, "no-action"))
15897 else if (!strcmp ((char *) s, "natively-forward"))
15899 else if (!strcmp ((char *) s, "send-map-request"))
15901 else if (!strcmp ((char *) s, "drop"))
15905 clib_warning ("invalid action: '%s'", s);
15917 * Add/del remote mapping to/from ONE control plane
15919 * @param vam vpp API test context
15920 * @return return code
15923 api_one_add_del_remote_mapping (vat_main_t * vam)
15925 unformat_input_t *input = vam->input;
15926 vl_api_one_add_del_remote_mapping_t *mp;
15928 lisp_eid_vat_t _eid, *eid = &_eid;
15929 lisp_eid_vat_t _seid, *seid = &_seid;
15930 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15931 u32 action = ~0, p, w, data_len;
15932 ip4_address_t rloc4;
15933 ip6_address_t rloc6;
15934 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15937 memset (&rloc, 0, sizeof (rloc));
15939 /* Parse args required to build the message */
15940 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15942 if (unformat (input, "del-all"))
15946 else if (unformat (input, "del"))
15950 else if (unformat (input, "add"))
15954 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15958 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15962 else if (unformat (input, "vni %d", &vni))
15966 else if (unformat (input, "p %d w %d", &p, &w))
15970 errmsg ("No RLOC configured for setting priority/weight!");
15973 curr_rloc->priority = p;
15974 curr_rloc->weight = w;
15976 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15979 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15980 vec_add1 (rlocs, rloc);
15981 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15983 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15986 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15987 vec_add1 (rlocs, rloc);
15988 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15990 else if (unformat (input, "action %U",
15991 unformat_negative_mapping_action, &action))
15997 clib_warning ("parse error '%U'", format_unformat_error, input);
16004 errmsg ("missing params!");
16008 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16010 errmsg ("no action set for negative map-reply!");
16014 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16016 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16017 mp->is_add = is_add;
16018 mp->vni = htonl (vni);
16019 mp->action = (u8) action;
16020 mp->is_src_dst = seid_set;
16021 mp->eid_len = eid->len;
16022 mp->seid_len = seid->len;
16023 mp->del_all = del_all;
16024 mp->eid_type = eid->type;
16025 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16026 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
16028 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
16029 clib_memcpy (mp->rlocs, rlocs, data_len);
16035 /* Wait for a reply... */
16040 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
16043 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
16044 * forwarding entries in data-plane accordingly.
16046 * @param vam vpp API test context
16047 * @return return code
16050 api_one_add_del_adjacency (vat_main_t * vam)
16052 unformat_input_t *input = vam->input;
16053 vl_api_one_add_del_adjacency_t *mp;
16055 ip4_address_t leid4, reid4;
16056 ip6_address_t leid6, reid6;
16057 u8 reid_mac[6] = { 0 };
16058 u8 leid_mac[6] = { 0 };
16059 u8 reid_type, leid_type;
16060 u32 leid_len = 0, reid_len = 0, len;
16064 leid_type = reid_type = (u8) ~ 0;
16066 /* Parse args required to build the message */
16067 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16069 if (unformat (input, "del"))
16073 else if (unformat (input, "add"))
16077 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
16080 reid_type = 0; /* ipv4 */
16083 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
16086 reid_type = 1; /* ipv6 */
16089 else if (unformat (input, "reid %U", unformat_ethernet_address,
16092 reid_type = 2; /* mac */
16094 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
16097 leid_type = 0; /* ipv4 */
16100 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
16103 leid_type = 1; /* ipv6 */
16106 else if (unformat (input, "leid %U", unformat_ethernet_address,
16109 leid_type = 2; /* mac */
16111 else if (unformat (input, "vni %d", &vni))
16117 errmsg ("parse error '%U'", format_unformat_error, input);
16122 if ((u8) ~ 0 == reid_type)
16124 errmsg ("missing params!");
16128 if (leid_type != reid_type)
16130 errmsg ("remote and local EIDs are of different types!");
16134 M (ONE_ADD_DEL_ADJACENCY, mp);
16135 mp->is_add = is_add;
16136 mp->vni = htonl (vni);
16137 mp->leid_len = leid_len;
16138 mp->reid_len = reid_len;
16139 mp->eid_type = reid_type;
16141 switch (mp->eid_type)
16144 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16145 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16148 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16149 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16152 clib_memcpy (mp->leid, leid_mac, 6);
16153 clib_memcpy (mp->reid, reid_mac, 6);
16156 errmsg ("unknown EID type %d!", mp->eid_type);
16163 /* Wait for a reply... */
16168 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16171 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16173 u32 *mode = va_arg (*args, u32 *);
16175 if (unformat (input, "lisp"))
16177 else if (unformat (input, "vxlan"))
16186 api_gpe_get_encap_mode (vat_main_t * vam)
16188 vl_api_gpe_get_encap_mode_t *mp;
16191 /* Construct the API message */
16192 M (GPE_GET_ENCAP_MODE, mp);
16197 /* Wait for a reply... */
16203 api_gpe_set_encap_mode (vat_main_t * vam)
16205 unformat_input_t *input = vam->input;
16206 vl_api_gpe_set_encap_mode_t *mp;
16210 /* Parse args required to build the message */
16211 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16213 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16219 /* Construct the API message */
16220 M (GPE_SET_ENCAP_MODE, mp);
16227 /* Wait for a reply... */
16233 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16235 unformat_input_t *input = vam->input;
16236 vl_api_gpe_add_del_iface_t *mp;
16237 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16238 u32 dp_table = 0, vni = 0;
16241 /* Parse args required to build the message */
16242 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16244 if (unformat (input, "up"))
16249 else if (unformat (input, "down"))
16254 else if (unformat (input, "table_id %d", &dp_table))
16258 else if (unformat (input, "bd_id %d", &dp_table))
16263 else if (unformat (input, "vni %d", &vni))
16271 if (action_set == 0)
16273 errmsg ("Action not set");
16276 if (dp_table_set == 0 || vni_set == 0)
16278 errmsg ("vni and dp_table must be set");
16282 /* Construct the API message */
16283 M (GPE_ADD_DEL_IFACE, mp);
16285 mp->is_add = is_add;
16286 mp->dp_table = clib_host_to_net_u32 (dp_table);
16288 mp->vni = clib_host_to_net_u32 (vni);
16293 /* Wait for a reply... */
16299 api_one_map_register_fallback_threshold (vat_main_t * vam)
16301 unformat_input_t *input = vam->input;
16302 vl_api_one_map_register_fallback_threshold_t *mp;
16307 /* Parse args required to build the message */
16308 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16310 if (unformat (input, "%u", &value))
16314 clib_warning ("parse error '%U'", format_unformat_error, input);
16321 errmsg ("fallback threshold value is missing!");
16325 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16326 mp->value = clib_host_to_net_u32 (value);
16331 /* Wait for a reply... */
16337 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16339 vl_api_show_one_map_register_fallback_threshold_t *mp;
16342 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16347 /* Wait for a reply... */
16353 api_one_map_register_set_ttl (vat_main_t * vam)
16355 unformat_input_t *input = vam->input;
16356 vl_api_one_map_register_set_ttl_t *mp;
16361 /* Parse args required to build the message */
16362 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16364 if (unformat (input, "%u", &ttl))
16368 clib_warning ("parse error '%U'", format_unformat_error, input);
16375 errmsg ("TTL value missing!");
16379 M (ONE_MAP_REGISTER_SET_TTL, mp);
16380 mp->ttl = clib_host_to_net_u32 (ttl);
16385 /* Wait for a reply... */
16391 api_show_one_map_register_ttl (vat_main_t * vam)
16393 vl_api_show_one_map_register_ttl_t *mp;
16396 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16401 /* Wait for a reply... */
16407 * Add/del map request itr rlocs from ONE control plane and updates
16409 * @param vam vpp API test context
16410 * @return return code
16413 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16415 unformat_input_t *input = vam->input;
16416 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16417 u8 *locator_set_name = 0;
16418 u8 locator_set_name_set = 0;
16422 /* Parse args required to build the message */
16423 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16425 if (unformat (input, "del"))
16429 else if (unformat (input, "%_%v%_", &locator_set_name))
16431 locator_set_name_set = 1;
16435 clib_warning ("parse error '%U'", format_unformat_error, input);
16440 if (is_add && !locator_set_name_set)
16442 errmsg ("itr-rloc is not set!");
16446 if (is_add && vec_len (locator_set_name) > 64)
16448 errmsg ("itr-rloc locator-set name too long");
16449 vec_free (locator_set_name);
16453 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16454 mp->is_add = is_add;
16457 clib_memcpy (mp->locator_set_name, locator_set_name,
16458 vec_len (locator_set_name));
16462 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16464 vec_free (locator_set_name);
16469 /* Wait for a reply... */
16474 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16477 api_one_locator_dump (vat_main_t * vam)
16479 unformat_input_t *input = vam->input;
16480 vl_api_one_locator_dump_t *mp;
16481 vl_api_control_ping_t *mp_ping;
16482 u8 is_index_set = 0, is_name_set = 0;
16487 /* Parse args required to build the message */
16488 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16490 if (unformat (input, "ls_name %_%v%_", &ls_name))
16494 else if (unformat (input, "ls_index %d", &ls_index))
16500 errmsg ("parse error '%U'", format_unformat_error, input);
16505 if (!is_index_set && !is_name_set)
16507 errmsg ("error: expected one of index or name!");
16511 if (is_index_set && is_name_set)
16513 errmsg ("error: only one param expected!");
16517 if (vec_len (ls_name) > 62)
16519 errmsg ("error: locator set name too long!");
16523 if (!vam->json_output)
16525 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16528 M (ONE_LOCATOR_DUMP, mp);
16529 mp->is_index_set = is_index_set;
16532 mp->ls_index = clib_host_to_net_u32 (ls_index);
16535 vec_add1 (ls_name, 0);
16536 strncpy ((char *) mp->ls_name, (char *) ls_name,
16537 sizeof (mp->ls_name) - 1);
16543 /* Use a control ping for synchronization */
16544 M (CONTROL_PING, mp_ping);
16547 /* Wait for a reply... */
16552 #define api_lisp_locator_dump api_one_locator_dump
16555 api_one_locator_set_dump (vat_main_t * vam)
16557 vl_api_one_locator_set_dump_t *mp;
16558 vl_api_control_ping_t *mp_ping;
16559 unformat_input_t *input = vam->input;
16563 /* Parse args required to build the message */
16564 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16566 if (unformat (input, "local"))
16570 else if (unformat (input, "remote"))
16576 errmsg ("parse error '%U'", format_unformat_error, input);
16581 if (!vam->json_output)
16583 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16586 M (ONE_LOCATOR_SET_DUMP, mp);
16588 mp->filter = filter;
16593 /* Use a control ping for synchronization */
16594 M (CONTROL_PING, mp_ping);
16597 /* Wait for a reply... */
16602 #define api_lisp_locator_set_dump api_one_locator_set_dump
16605 api_one_eid_table_map_dump (vat_main_t * vam)
16609 unformat_input_t *input = vam->input;
16610 vl_api_one_eid_table_map_dump_t *mp;
16611 vl_api_control_ping_t *mp_ping;
16614 /* Parse args required to build the message */
16615 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16617 if (unformat (input, "l2"))
16622 else if (unformat (input, "l3"))
16629 errmsg ("parse error '%U'", format_unformat_error, input);
16636 errmsg ("expected one of 'l2' or 'l3' parameter!");
16640 if (!vam->json_output)
16642 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16645 M (ONE_EID_TABLE_MAP_DUMP, mp);
16651 /* Use a control ping for synchronization */
16652 M (CONTROL_PING, mp_ping);
16655 /* Wait for a reply... */
16660 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16663 api_one_eid_table_vni_dump (vat_main_t * vam)
16665 vl_api_one_eid_table_vni_dump_t *mp;
16666 vl_api_control_ping_t *mp_ping;
16669 if (!vam->json_output)
16671 print (vam->ofp, "VNI");
16674 M (ONE_EID_TABLE_VNI_DUMP, mp);
16679 /* Use a control ping for synchronization */
16680 M (CONTROL_PING, mp_ping);
16683 /* Wait for a reply... */
16688 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16691 api_one_eid_table_dump (vat_main_t * vam)
16693 unformat_input_t *i = vam->input;
16694 vl_api_one_eid_table_dump_t *mp;
16695 vl_api_control_ping_t *mp_ping;
16696 struct in_addr ip4;
16697 struct in6_addr ip6;
16699 u8 eid_type = ~0, eid_set = 0;
16700 u32 prefix_length = ~0, t, vni = 0;
16703 lisp_nsh_api_t nsh;
16705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16707 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16713 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16719 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16724 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16729 else if (unformat (i, "vni %d", &t))
16733 else if (unformat (i, "local"))
16737 else if (unformat (i, "remote"))
16743 errmsg ("parse error '%U'", format_unformat_error, i);
16748 if (!vam->json_output)
16750 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16751 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16754 M (ONE_EID_TABLE_DUMP, mp);
16756 mp->filter = filter;
16760 mp->vni = htonl (vni);
16761 mp->eid_type = eid_type;
16765 mp->prefix_length = prefix_length;
16766 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16769 mp->prefix_length = prefix_length;
16770 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16773 clib_memcpy (mp->eid, mac, sizeof (mac));
16776 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16779 errmsg ("unknown EID type %d!", eid_type);
16787 /* Use a control ping for synchronization */
16788 M (CONTROL_PING, mp_ping);
16791 /* Wait for a reply... */
16796 #define api_lisp_eid_table_dump api_one_eid_table_dump
16799 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16801 unformat_input_t *i = vam->input;
16802 vl_api_gpe_fwd_entries_get_t *mp;
16807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16809 if (unformat (i, "vni %d", &vni))
16815 errmsg ("parse error '%U'", format_unformat_error, i);
16822 errmsg ("vni not set!");
16826 if (!vam->json_output)
16828 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16832 M (GPE_FWD_ENTRIES_GET, mp);
16833 mp->vni = clib_host_to_net_u32 (vni);
16838 /* Wait for a reply... */
16843 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16844 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16845 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16846 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16847 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16848 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16849 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16850 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16853 api_one_adjacencies_get (vat_main_t * vam)
16855 unformat_input_t *i = vam->input;
16856 vl_api_one_adjacencies_get_t *mp;
16861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16863 if (unformat (i, "vni %d", &vni))
16869 errmsg ("parse error '%U'", format_unformat_error, i);
16876 errmsg ("vni not set!");
16880 if (!vam->json_output)
16882 print (vam->ofp, "%s %40s", "leid", "reid");
16885 M (ONE_ADJACENCIES_GET, mp);
16886 mp->vni = clib_host_to_net_u32 (vni);
16891 /* Wait for a reply... */
16896 #define api_lisp_adjacencies_get api_one_adjacencies_get
16899 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16901 unformat_input_t *i = vam->input;
16902 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16904 u8 ip_family_set = 0, is_ip4 = 1;
16906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16908 if (unformat (i, "ip4"))
16913 else if (unformat (i, "ip6"))
16920 errmsg ("parse error '%U'", format_unformat_error, i);
16925 if (!ip_family_set)
16927 errmsg ("ip family not set!");
16931 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16932 mp->is_ip4 = is_ip4;
16937 /* Wait for a reply... */
16943 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16945 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16948 if (!vam->json_output)
16950 print (vam->ofp, "VNIs");
16953 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16958 /* Wait for a reply... */
16964 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16966 unformat_input_t *i = vam->input;
16967 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16969 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16970 struct in_addr ip4;
16971 struct in6_addr ip6;
16972 u32 table_id = 0, nh_sw_if_index = ~0;
16974 memset (&ip4, 0, sizeof (ip4));
16975 memset (&ip6, 0, sizeof (ip6));
16977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16979 if (unformat (i, "del"))
16981 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16982 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16987 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16988 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16993 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16997 nh_sw_if_index = ~0;
16999 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
17003 nh_sw_if_index = ~0;
17005 else if (unformat (i, "table %d", &table_id))
17009 errmsg ("parse error '%U'", format_unformat_error, i);
17016 errmsg ("nh addr not set!");
17020 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
17021 mp->is_add = is_add;
17022 mp->table_id = clib_host_to_net_u32 (table_id);
17023 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
17024 mp->is_ip4 = is_ip4;
17026 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
17028 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
17033 /* Wait for a reply... */
17039 api_one_map_server_dump (vat_main_t * vam)
17041 vl_api_one_map_server_dump_t *mp;
17042 vl_api_control_ping_t *mp_ping;
17045 if (!vam->json_output)
17047 print (vam->ofp, "%=20s", "Map server");
17050 M (ONE_MAP_SERVER_DUMP, mp);
17054 /* Use a control ping for synchronization */
17055 M (CONTROL_PING, mp_ping);
17058 /* Wait for a reply... */
17063 #define api_lisp_map_server_dump api_one_map_server_dump
17066 api_one_map_resolver_dump (vat_main_t * vam)
17068 vl_api_one_map_resolver_dump_t *mp;
17069 vl_api_control_ping_t *mp_ping;
17072 if (!vam->json_output)
17074 print (vam->ofp, "%=20s", "Map resolver");
17077 M (ONE_MAP_RESOLVER_DUMP, mp);
17081 /* Use a control ping for synchronization */
17082 M (CONTROL_PING, mp_ping);
17085 /* Wait for a reply... */
17090 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17093 api_one_stats_flush (vat_main_t * vam)
17095 vl_api_one_stats_flush_t *mp;
17098 M (ONE_STATS_FLUSH, mp);
17105 api_one_stats_dump (vat_main_t * vam)
17107 vl_api_one_stats_dump_t *mp;
17108 vl_api_control_ping_t *mp_ping;
17111 M (ONE_STATS_DUMP, mp);
17115 /* Use a control ping for synchronization */
17116 M (CONTROL_PING, mp_ping);
17119 /* Wait for a reply... */
17125 api_show_one_status (vat_main_t * vam)
17127 vl_api_show_one_status_t *mp;
17130 if (!vam->json_output)
17132 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17135 M (SHOW_ONE_STATUS, mp);
17138 /* Wait for a reply... */
17143 #define api_show_lisp_status api_show_one_status
17146 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17148 vl_api_gpe_fwd_entry_path_dump_t *mp;
17149 vl_api_control_ping_t *mp_ping;
17150 unformat_input_t *i = vam->input;
17151 u32 fwd_entry_index = ~0;
17154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17156 if (unformat (i, "index %d", &fwd_entry_index))
17162 if (~0 == fwd_entry_index)
17164 errmsg ("no index specified!");
17168 if (!vam->json_output)
17170 print (vam->ofp, "first line");
17173 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17177 /* Use a control ping for synchronization */
17178 M (CONTROL_PING, mp_ping);
17181 /* Wait for a reply... */
17187 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17189 vl_api_one_get_map_request_itr_rlocs_t *mp;
17192 if (!vam->json_output)
17194 print (vam->ofp, "%=20s", "itr-rlocs:");
17197 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17200 /* Wait for a reply... */
17205 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17208 api_af_packet_create (vat_main_t * vam)
17210 unformat_input_t *i = vam->input;
17211 vl_api_af_packet_create_t *mp;
17212 u8 *host_if_name = 0;
17214 u8 random_hw_addr = 1;
17217 memset (hw_addr, 0, sizeof (hw_addr));
17219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17221 if (unformat (i, "name %s", &host_if_name))
17222 vec_add1 (host_if_name, 0);
17223 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17224 random_hw_addr = 0;
17229 if (!vec_len (host_if_name))
17231 errmsg ("host-interface name must be specified");
17235 if (vec_len (host_if_name) > 64)
17237 errmsg ("host-interface name too long");
17241 M (AF_PACKET_CREATE, mp);
17243 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17244 clib_memcpy (mp->hw_addr, hw_addr, 6);
17245 mp->use_random_hw_addr = random_hw_addr;
17246 vec_free (host_if_name);
17254 fprintf (vam->ofp ? vam->ofp : stderr,
17255 " new sw_if_index = %d\n", vam->sw_if_index);
17262 api_af_packet_delete (vat_main_t * vam)
17264 unformat_input_t *i = vam->input;
17265 vl_api_af_packet_delete_t *mp;
17266 u8 *host_if_name = 0;
17269 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17271 if (unformat (i, "name %s", &host_if_name))
17272 vec_add1 (host_if_name, 0);
17277 if (!vec_len (host_if_name))
17279 errmsg ("host-interface name must be specified");
17283 if (vec_len (host_if_name) > 64)
17285 errmsg ("host-interface name too long");
17289 M (AF_PACKET_DELETE, mp);
17291 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17292 vec_free (host_if_name);
17300 api_policer_add_del (vat_main_t * vam)
17302 unformat_input_t *i = vam->input;
17303 vl_api_policer_add_del_t *mp;
17313 u8 color_aware = 0;
17314 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17317 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17318 conform_action.dscp = 0;
17319 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17320 exceed_action.dscp = 0;
17321 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17322 violate_action.dscp = 0;
17324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17326 if (unformat (i, "del"))
17328 else if (unformat (i, "name %s", &name))
17329 vec_add1 (name, 0);
17330 else if (unformat (i, "cir %u", &cir))
17332 else if (unformat (i, "eir %u", &eir))
17334 else if (unformat (i, "cb %u", &cb))
17336 else if (unformat (i, "eb %u", &eb))
17338 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17341 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17344 else if (unformat (i, "type %U", unformat_policer_type, &type))
17346 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17349 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17352 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17355 else if (unformat (i, "color-aware"))
17361 if (!vec_len (name))
17363 errmsg ("policer name must be specified");
17367 if (vec_len (name) > 64)
17369 errmsg ("policer name too long");
17373 M (POLICER_ADD_DEL, mp);
17375 clib_memcpy (mp->name, name, vec_len (name));
17377 mp->is_add = is_add;
17382 mp->rate_type = rate_type;
17383 mp->round_type = round_type;
17385 mp->conform_action_type = conform_action.action_type;
17386 mp->conform_dscp = conform_action.dscp;
17387 mp->exceed_action_type = exceed_action.action_type;
17388 mp->exceed_dscp = exceed_action.dscp;
17389 mp->violate_action_type = violate_action.action_type;
17390 mp->violate_dscp = violate_action.dscp;
17391 mp->color_aware = color_aware;
17399 api_policer_dump (vat_main_t * vam)
17401 unformat_input_t *i = vam->input;
17402 vl_api_policer_dump_t *mp;
17403 vl_api_control_ping_t *mp_ping;
17404 u8 *match_name = 0;
17405 u8 match_name_valid = 0;
17408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17410 if (unformat (i, "name %s", &match_name))
17412 vec_add1 (match_name, 0);
17413 match_name_valid = 1;
17419 M (POLICER_DUMP, mp);
17420 mp->match_name_valid = match_name_valid;
17421 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17422 vec_free (match_name);
17426 /* Use a control ping for synchronization */
17427 M (CONTROL_PING, mp_ping);
17430 /* Wait for a reply... */
17436 api_policer_classify_set_interface (vat_main_t * vam)
17438 unformat_input_t *i = vam->input;
17439 vl_api_policer_classify_set_interface_t *mp;
17441 int sw_if_index_set;
17442 u32 ip4_table_index = ~0;
17443 u32 ip6_table_index = ~0;
17444 u32 l2_table_index = ~0;
17448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17450 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17451 sw_if_index_set = 1;
17452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17453 sw_if_index_set = 1;
17454 else if (unformat (i, "del"))
17456 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17458 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17460 else if (unformat (i, "l2-table %d", &l2_table_index))
17464 clib_warning ("parse error '%U'", format_unformat_error, i);
17469 if (sw_if_index_set == 0)
17471 errmsg ("missing interface name or sw_if_index");
17475 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17477 mp->sw_if_index = ntohl (sw_if_index);
17478 mp->ip4_table_index = ntohl (ip4_table_index);
17479 mp->ip6_table_index = ntohl (ip6_table_index);
17480 mp->l2_table_index = ntohl (l2_table_index);
17481 mp->is_add = is_add;
17489 api_policer_classify_dump (vat_main_t * vam)
17491 unformat_input_t *i = vam->input;
17492 vl_api_policer_classify_dump_t *mp;
17493 vl_api_control_ping_t *mp_ping;
17494 u8 type = POLICER_CLASSIFY_N_TABLES;
17497 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17501 errmsg ("classify table type must be specified");
17505 if (!vam->json_output)
17507 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17510 M (POLICER_CLASSIFY_DUMP, mp);
17515 /* Use a control ping for synchronization */
17516 M (CONTROL_PING, mp_ping);
17519 /* Wait for a reply... */
17525 api_netmap_create (vat_main_t * vam)
17527 unformat_input_t *i = vam->input;
17528 vl_api_netmap_create_t *mp;
17531 u8 random_hw_addr = 1;
17536 memset (hw_addr, 0, sizeof (hw_addr));
17538 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17540 if (unformat (i, "name %s", &if_name))
17541 vec_add1 (if_name, 0);
17542 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17543 random_hw_addr = 0;
17544 else if (unformat (i, "pipe"))
17546 else if (unformat (i, "master"))
17548 else if (unformat (i, "slave"))
17554 if (!vec_len (if_name))
17556 errmsg ("interface name must be specified");
17560 if (vec_len (if_name) > 64)
17562 errmsg ("interface name too long");
17566 M (NETMAP_CREATE, mp);
17568 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17569 clib_memcpy (mp->hw_addr, hw_addr, 6);
17570 mp->use_random_hw_addr = random_hw_addr;
17571 mp->is_pipe = is_pipe;
17572 mp->is_master = is_master;
17573 vec_free (if_name);
17581 api_netmap_delete (vat_main_t * vam)
17583 unformat_input_t *i = vam->input;
17584 vl_api_netmap_delete_t *mp;
17588 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17590 if (unformat (i, "name %s", &if_name))
17591 vec_add1 (if_name, 0);
17596 if (!vec_len (if_name))
17598 errmsg ("interface name must be specified");
17602 if (vec_len (if_name) > 64)
17604 errmsg ("interface name too long");
17608 M (NETMAP_DELETE, mp);
17610 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17611 vec_free (if_name);
17619 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
17621 if (fp->afi == IP46_TYPE_IP6)
17623 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17624 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17625 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17626 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17627 format_ip6_address, fp->next_hop);
17628 else if (fp->afi == IP46_TYPE_IP4)
17630 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17631 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17632 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17633 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17634 format_ip4_address, fp->next_hop);
17638 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17639 vl_api_fib_path2_t * fp)
17641 struct in_addr ip4;
17642 struct in6_addr ip6;
17644 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17645 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17646 vat_json_object_add_uint (node, "is_local", fp->is_local);
17647 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
17648 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
17649 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
17650 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
17651 if (fp->afi == IP46_TYPE_IP4)
17653 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
17654 vat_json_object_add_ip4 (node, "next_hop", ip4);
17656 else if (fp->afi == IP46_TYPE_IP6)
17658 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
17659 vat_json_object_add_ip6 (node, "next_hop", ip6);
17664 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17666 vat_main_t *vam = &vat_main;
17667 int count = ntohl (mp->mt_count);
17668 vl_api_fib_path2_t *fp;
17671 print (vam->ofp, "[%d]: sw_if_index %d via:",
17672 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
17674 for (i = 0; i < count; i++)
17676 vl_api_mpls_fib_path_print (vam, fp);
17680 print (vam->ofp, "");
17683 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17684 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17687 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17689 vat_main_t *vam = &vat_main;
17690 vat_json_node_t *node = NULL;
17691 int count = ntohl (mp->mt_count);
17692 vl_api_fib_path2_t *fp;
17695 if (VAT_JSON_ARRAY != vam->json_tree.type)
17697 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17698 vat_json_init_array (&vam->json_tree);
17700 node = vat_json_array_add (&vam->json_tree);
17702 vat_json_init_object (node);
17703 vat_json_object_add_uint (node, "tunnel_index",
17704 ntohl (mp->mt_tunnel_index));
17705 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
17707 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
17710 for (i = 0; i < count; i++)
17712 vl_api_mpls_fib_path_json_print (node, fp);
17718 api_mpls_tunnel_dump (vat_main_t * vam)
17720 vl_api_mpls_tunnel_dump_t *mp;
17721 vl_api_control_ping_t *mp_ping;
17725 /* Parse args required to build the message */
17726 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
17728 if (!unformat (vam->input, "tunnel_index %d", &index))
17735 print (vam->ofp, " tunnel_index %d", index);
17737 M (MPLS_TUNNEL_DUMP, mp);
17738 mp->tunnel_index = htonl (index);
17741 /* Use a control ping for synchronization */
17742 M (CONTROL_PING, mp_ping);
17749 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
17750 #define vl_api_mpls_fib_details_t_print vl_noop_handler
17754 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
17756 vat_main_t *vam = &vat_main;
17757 int count = ntohl (mp->count);
17758 vl_api_fib_path2_t *fp;
17762 "table-id %d, label %u, ess_bit %u",
17763 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
17765 for (i = 0; i < count; i++)
17767 vl_api_mpls_fib_path_print (vam, fp);
17772 static void vl_api_mpls_fib_details_t_handler_json
17773 (vl_api_mpls_fib_details_t * mp)
17775 vat_main_t *vam = &vat_main;
17776 int count = ntohl (mp->count);
17777 vat_json_node_t *node = NULL;
17778 vl_api_fib_path2_t *fp;
17781 if (VAT_JSON_ARRAY != vam->json_tree.type)
17783 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17784 vat_json_init_array (&vam->json_tree);
17786 node = vat_json_array_add (&vam->json_tree);
17788 vat_json_init_object (node);
17789 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
17790 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
17791 vat_json_object_add_uint (node, "label", ntohl (mp->label));
17792 vat_json_object_add_uint (node, "path_count", count);
17794 for (i = 0; i < count; i++)
17796 vl_api_mpls_fib_path_json_print (node, fp);
17802 api_mpls_fib_dump (vat_main_t * vam)
17804 vl_api_mpls_fib_dump_t *mp;
17805 vl_api_control_ping_t *mp_ping;
17808 M (MPLS_FIB_DUMP, mp);
17811 /* Use a control ping for synchronization */
17812 M (CONTROL_PING, mp_ping);
17819 #define vl_api_ip_fib_details_t_endian vl_noop_handler
17820 #define vl_api_ip_fib_details_t_print vl_noop_handler
17823 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
17825 vat_main_t *vam = &vat_main;
17826 int count = ntohl (mp->count);
17827 vl_api_fib_path_t *fp;
17831 "table-id %d, prefix %U/%d",
17832 ntohl (mp->table_id), format_ip4_address, mp->address,
17833 mp->address_length);
17835 for (i = 0; i < count; i++)
17837 if (fp->afi == IP46_TYPE_IP6)
17839 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17840 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17841 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17842 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17843 format_ip6_address, fp->next_hop);
17844 else if (fp->afi == IP46_TYPE_IP4)
17846 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17847 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17848 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17849 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17850 format_ip4_address, fp->next_hop);
17855 static void vl_api_ip_fib_details_t_handler_json
17856 (vl_api_ip_fib_details_t * mp)
17858 vat_main_t *vam = &vat_main;
17859 int count = ntohl (mp->count);
17860 vat_json_node_t *node = NULL;
17861 struct in_addr ip4;
17862 struct in6_addr ip6;
17863 vl_api_fib_path_t *fp;
17866 if (VAT_JSON_ARRAY != vam->json_tree.type)
17868 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17869 vat_json_init_array (&vam->json_tree);
17871 node = vat_json_array_add (&vam->json_tree);
17873 vat_json_init_object (node);
17874 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
17875 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
17876 vat_json_object_add_ip4 (node, "prefix", ip4);
17877 vat_json_object_add_uint (node, "mask_length", mp->address_length);
17878 vat_json_object_add_uint (node, "path_count", count);
17880 for (i = 0; i < count; i++)
17882 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17883 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17884 vat_json_object_add_uint (node, "is_local", fp->is_local);
17885 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
17886 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
17887 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
17888 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
17889 if (fp->afi == IP46_TYPE_IP4)
17891 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
17892 vat_json_object_add_ip4 (node, "next_hop", ip4);
17894 else if (fp->afi == IP46_TYPE_IP6)
17896 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
17897 vat_json_object_add_ip6 (node, "next_hop", ip6);
17903 api_ip_fib_dump (vat_main_t * vam)
17905 vl_api_ip_fib_dump_t *mp;
17906 vl_api_control_ping_t *mp_ping;
17909 M (IP_FIB_DUMP, mp);
17912 /* Use a control ping for synchronization */
17913 M (CONTROL_PING, mp_ping);
17921 api_ip_mfib_dump (vat_main_t * vam)
17923 vl_api_ip_mfib_dump_t *mp;
17924 vl_api_control_ping_t *mp_ping;
17927 M (IP_MFIB_DUMP, mp);
17930 /* Use a control ping for synchronization */
17931 M (CONTROL_PING, mp_ping);
17938 static void vl_api_ip_neighbor_details_t_handler
17939 (vl_api_ip_neighbor_details_t * mp)
17941 vat_main_t *vam = &vat_main;
17943 print (vam->ofp, "%c %U %U",
17944 (mp->is_static) ? 'S' : 'D',
17945 format_ethernet_address, &mp->mac_address,
17946 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
17950 static void vl_api_ip_neighbor_details_t_handler_json
17951 (vl_api_ip_neighbor_details_t * mp)
17954 vat_main_t *vam = &vat_main;
17955 vat_json_node_t *node;
17956 struct in_addr ip4;
17957 struct in6_addr ip6;
17959 if (VAT_JSON_ARRAY != vam->json_tree.type)
17961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17962 vat_json_init_array (&vam->json_tree);
17964 node = vat_json_array_add (&vam->json_tree);
17966 vat_json_init_object (node);
17967 vat_json_object_add_string_copy (node, "flag",
17968 (mp->is_static) ? (u8 *) "static" : (u8 *)
17971 vat_json_object_add_string_copy (node, "link_layer",
17972 format (0, "%U", format_ethernet_address,
17973 &mp->mac_address));
17977 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
17978 vat_json_object_add_ip6 (node, "ip_address", ip6);
17982 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
17983 vat_json_object_add_ip4 (node, "ip_address", ip4);
17988 api_ip_neighbor_dump (vat_main_t * vam)
17990 unformat_input_t *i = vam->input;
17991 vl_api_ip_neighbor_dump_t *mp;
17992 vl_api_control_ping_t *mp_ping;
17994 u32 sw_if_index = ~0;
17997 /* Parse args required to build the message */
17998 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18000 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18002 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18004 else if (unformat (i, "ip6"))
18010 if (sw_if_index == ~0)
18012 errmsg ("missing interface name or sw_if_index");
18016 M (IP_NEIGHBOR_DUMP, mp);
18017 mp->is_ipv6 = (u8) is_ipv6;
18018 mp->sw_if_index = ntohl (sw_if_index);
18021 /* Use a control ping for synchronization */
18022 M (CONTROL_PING, mp_ping);
18029 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
18030 #define vl_api_ip6_fib_details_t_print vl_noop_handler
18033 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
18035 vat_main_t *vam = &vat_main;
18036 int count = ntohl (mp->count);
18037 vl_api_fib_path_t *fp;
18041 "table-id %d, prefix %U/%d",
18042 ntohl (mp->table_id), format_ip6_address, mp->address,
18043 mp->address_length);
18045 for (i = 0; i < count; i++)
18047 if (fp->afi == IP46_TYPE_IP6)
18049 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
18050 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
18051 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
18052 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
18053 format_ip6_address, fp->next_hop);
18054 else if (fp->afi == IP46_TYPE_IP4)
18056 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
18057 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
18058 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
18059 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
18060 format_ip4_address, fp->next_hop);
18065 static void vl_api_ip6_fib_details_t_handler_json
18066 (vl_api_ip6_fib_details_t * mp)
18068 vat_main_t *vam = &vat_main;
18069 int count = ntohl (mp->count);
18070 vat_json_node_t *node = NULL;
18071 struct in_addr ip4;
18072 struct in6_addr ip6;
18073 vl_api_fib_path_t *fp;
18076 if (VAT_JSON_ARRAY != vam->json_tree.type)
18078 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18079 vat_json_init_array (&vam->json_tree);
18081 node = vat_json_array_add (&vam->json_tree);
18083 vat_json_init_object (node);
18084 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
18085 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
18086 vat_json_object_add_ip6 (node, "prefix", ip6);
18087 vat_json_object_add_uint (node, "mask_length", mp->address_length);
18088 vat_json_object_add_uint (node, "path_count", count);
18090 for (i = 0; i < count; i++)
18092 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18093 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18094 vat_json_object_add_uint (node, "is_local", fp->is_local);
18095 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
18096 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
18097 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
18098 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
18099 if (fp->afi == IP46_TYPE_IP4)
18101 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
18102 vat_json_object_add_ip4 (node, "next_hop", ip4);
18104 else if (fp->afi == IP46_TYPE_IP6)
18106 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
18107 vat_json_object_add_ip6 (node, "next_hop", ip6);
18113 api_ip6_fib_dump (vat_main_t * vam)
18115 vl_api_ip6_fib_dump_t *mp;
18116 vl_api_control_ping_t *mp_ping;
18119 M (IP6_FIB_DUMP, mp);
18122 /* Use a control ping for synchronization */
18123 M (CONTROL_PING, mp_ping);
18131 api_ip6_mfib_dump (vat_main_t * vam)
18133 vl_api_ip6_mfib_dump_t *mp;
18134 vl_api_control_ping_t *mp_ping;
18137 M (IP6_MFIB_DUMP, mp);
18140 /* Use a control ping for synchronization */
18141 M (CONTROL_PING, mp_ping);
18149 api_classify_table_ids (vat_main_t * vam)
18151 vl_api_classify_table_ids_t *mp;
18154 /* Construct the API message */
18155 M (CLASSIFY_TABLE_IDS, mp);
18164 api_classify_table_by_interface (vat_main_t * vam)
18166 unformat_input_t *input = vam->input;
18167 vl_api_classify_table_by_interface_t *mp;
18169 u32 sw_if_index = ~0;
18171 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18173 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18175 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18180 if (sw_if_index == ~0)
18182 errmsg ("missing interface name or sw_if_index");
18186 /* Construct the API message */
18187 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18189 mp->sw_if_index = ntohl (sw_if_index);
18197 api_classify_table_info (vat_main_t * vam)
18199 unformat_input_t *input = vam->input;
18200 vl_api_classify_table_info_t *mp;
18204 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18206 if (unformat (input, "table_id %d", &table_id))
18211 if (table_id == ~0)
18213 errmsg ("missing table id");
18217 /* Construct the API message */
18218 M (CLASSIFY_TABLE_INFO, mp);
18220 mp->table_id = ntohl (table_id);
18228 api_classify_session_dump (vat_main_t * vam)
18230 unformat_input_t *input = vam->input;
18231 vl_api_classify_session_dump_t *mp;
18232 vl_api_control_ping_t *mp_ping;
18236 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18238 if (unformat (input, "table_id %d", &table_id))
18243 if (table_id == ~0)
18245 errmsg ("missing table id");
18249 /* Construct the API message */
18250 M (CLASSIFY_SESSION_DUMP, mp);
18252 mp->table_id = ntohl (table_id);
18255 /* Use a control ping for synchronization */
18256 M (CONTROL_PING, mp_ping);
18264 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18266 vat_main_t *vam = &vat_main;
18268 print (vam->ofp, "collector_address %U, collector_port %d, "
18269 "src_address %U, vrf_id %d, path_mtu %u, "
18270 "template_interval %u, udp_checksum %d",
18271 format_ip4_address, mp->collector_address,
18272 ntohs (mp->collector_port),
18273 format_ip4_address, mp->src_address,
18274 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18275 ntohl (mp->template_interval), mp->udp_checksum);
18278 vam->result_ready = 1;
18282 vl_api_ipfix_exporter_details_t_handler_json
18283 (vl_api_ipfix_exporter_details_t * mp)
18285 vat_main_t *vam = &vat_main;
18286 vat_json_node_t node;
18287 struct in_addr collector_address;
18288 struct in_addr src_address;
18290 vat_json_init_object (&node);
18291 clib_memcpy (&collector_address, &mp->collector_address,
18292 sizeof (collector_address));
18293 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18294 vat_json_object_add_uint (&node, "collector_port",
18295 ntohs (mp->collector_port));
18296 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18297 vat_json_object_add_ip4 (&node, "src_address", src_address);
18298 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18299 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18300 vat_json_object_add_uint (&node, "template_interval",
18301 ntohl (mp->template_interval));
18302 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18304 vat_json_print (vam->ofp, &node);
18305 vat_json_free (&node);
18307 vam->result_ready = 1;
18311 api_ipfix_exporter_dump (vat_main_t * vam)
18313 vl_api_ipfix_exporter_dump_t *mp;
18316 /* Construct the API message */
18317 M (IPFIX_EXPORTER_DUMP, mp);
18326 api_ipfix_classify_stream_dump (vat_main_t * vam)
18328 vl_api_ipfix_classify_stream_dump_t *mp;
18331 /* Construct the API message */
18332 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18343 vl_api_ipfix_classify_stream_details_t_handler
18344 (vl_api_ipfix_classify_stream_details_t * mp)
18346 vat_main_t *vam = &vat_main;
18347 print (vam->ofp, "domain_id %d, src_port %d",
18348 ntohl (mp->domain_id), ntohs (mp->src_port));
18350 vam->result_ready = 1;
18354 vl_api_ipfix_classify_stream_details_t_handler_json
18355 (vl_api_ipfix_classify_stream_details_t * mp)
18357 vat_main_t *vam = &vat_main;
18358 vat_json_node_t node;
18360 vat_json_init_object (&node);
18361 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18362 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18364 vat_json_print (vam->ofp, &node);
18365 vat_json_free (&node);
18367 vam->result_ready = 1;
18371 api_ipfix_classify_table_dump (vat_main_t * vam)
18373 vl_api_ipfix_classify_table_dump_t *mp;
18374 vl_api_control_ping_t *mp_ping;
18377 if (!vam->json_output)
18379 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18380 "transport_protocol");
18383 /* Construct the API message */
18384 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18389 /* Use a control ping for synchronization */
18390 M (CONTROL_PING, mp_ping);
18398 vl_api_ipfix_classify_table_details_t_handler
18399 (vl_api_ipfix_classify_table_details_t * mp)
18401 vat_main_t *vam = &vat_main;
18402 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18403 mp->transport_protocol);
18407 vl_api_ipfix_classify_table_details_t_handler_json
18408 (vl_api_ipfix_classify_table_details_t * mp)
18410 vat_json_node_t *node = NULL;
18411 vat_main_t *vam = &vat_main;
18413 if (VAT_JSON_ARRAY != vam->json_tree.type)
18415 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18416 vat_json_init_array (&vam->json_tree);
18419 node = vat_json_array_add (&vam->json_tree);
18420 vat_json_init_object (node);
18422 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18423 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18424 vat_json_object_add_uint (node, "transport_protocol",
18425 mp->transport_protocol);
18429 api_sw_interface_span_enable_disable (vat_main_t * vam)
18431 unformat_input_t *i = vam->input;
18432 vl_api_sw_interface_span_enable_disable_t *mp;
18433 u32 src_sw_if_index = ~0;
18434 u32 dst_sw_if_index = ~0;
18439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18442 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18444 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18448 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18450 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18452 else if (unformat (i, "disable"))
18454 else if (unformat (i, "rx"))
18456 else if (unformat (i, "tx"))
18458 else if (unformat (i, "both"))
18460 else if (unformat (i, "l2"))
18466 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18468 mp->sw_if_index_from = htonl (src_sw_if_index);
18469 mp->sw_if_index_to = htonl (dst_sw_if_index);
18479 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18482 vat_main_t *vam = &vat_main;
18483 u8 *sw_if_from_name = 0;
18484 u8 *sw_if_to_name = 0;
18485 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18486 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18487 char *states[] = { "none", "rx", "tx", "both" };
18491 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18493 if ((u32) p->value[0] == sw_if_index_from)
18495 sw_if_from_name = (u8 *)(p->key);
18499 if ((u32) p->value[0] == sw_if_index_to)
18501 sw_if_to_name = (u8 *)(p->key);
18502 if (sw_if_from_name)
18507 print (vam->ofp, "%20s => %20s (%s)",
18508 sw_if_from_name, sw_if_to_name, states[mp->state]);
18512 vl_api_sw_interface_span_details_t_handler_json
18513 (vl_api_sw_interface_span_details_t * mp)
18515 vat_main_t *vam = &vat_main;
18516 vat_json_node_t *node = NULL;
18517 u8 *sw_if_from_name = 0;
18518 u8 *sw_if_to_name = 0;
18519 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18520 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18524 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18526 if ((u32) p->value[0] == sw_if_index_from)
18528 sw_if_from_name = (u8 *)(p->key);
18532 if ((u32) p->value[0] == sw_if_index_to)
18534 sw_if_to_name = (u8 *)(p->key);
18535 if (sw_if_from_name)
18541 if (VAT_JSON_ARRAY != vam->json_tree.type)
18543 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18544 vat_json_init_array (&vam->json_tree);
18546 node = vat_json_array_add (&vam->json_tree);
18548 vat_json_init_object (node);
18549 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18550 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18551 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18552 if (0 != sw_if_to_name)
18554 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18556 vat_json_object_add_uint (node, "state", mp->state);
18560 api_sw_interface_span_dump (vat_main_t * vam)
18562 unformat_input_t *input = vam->input;
18563 vl_api_sw_interface_span_dump_t *mp;
18564 vl_api_control_ping_t *mp_ping;
18568 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18570 if (unformat (input, "l2"))
18576 M (SW_INTERFACE_SPAN_DUMP, mp);
18580 /* Use a control ping for synchronization */
18581 M (CONTROL_PING, mp_ping);
18589 api_pg_create_interface (vat_main_t * vam)
18591 unformat_input_t *input = vam->input;
18592 vl_api_pg_create_interface_t *mp;
18596 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18598 if (unformat (input, "if_id %d", &if_id))
18605 errmsg ("missing pg interface index");
18609 /* Construct the API message */
18610 M (PG_CREATE_INTERFACE, mp);
18612 mp->interface_id = ntohl (if_id);
18620 api_pg_capture (vat_main_t * vam)
18622 unformat_input_t *input = vam->input;
18623 vl_api_pg_capture_t *mp;
18628 u8 pcap_file_set = 0;
18631 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18633 if (unformat (input, "if_id %d", &if_id))
18635 else if (unformat (input, "pcap %s", &pcap_file))
18637 else if (unformat (input, "count %d", &count))
18639 else if (unformat (input, "disable"))
18646 errmsg ("missing pg interface index");
18649 if (pcap_file_set > 0)
18651 if (vec_len (pcap_file) > 255)
18653 errmsg ("pcap file name is too long");
18658 u32 name_len = vec_len (pcap_file);
18659 /* Construct the API message */
18660 M (PG_CAPTURE, mp);
18662 mp->interface_id = ntohl (if_id);
18663 mp->is_enabled = enable;
18664 mp->count = ntohl (count);
18665 mp->pcap_name_length = ntohl (name_len);
18666 if (pcap_file_set != 0)
18668 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18670 vec_free (pcap_file);
18678 api_pg_enable_disable (vat_main_t * vam)
18680 unformat_input_t *input = vam->input;
18681 vl_api_pg_enable_disable_t *mp;
18684 u8 stream_name_set = 0;
18685 u8 *stream_name = 0;
18687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18689 if (unformat (input, "stream %s", &stream_name))
18690 stream_name_set = 1;
18691 else if (unformat (input, "disable"))
18697 if (stream_name_set > 0)
18699 if (vec_len (stream_name) > 255)
18701 errmsg ("stream name too long");
18706 u32 name_len = vec_len (stream_name);
18707 /* Construct the API message */
18708 M (PG_ENABLE_DISABLE, mp);
18710 mp->is_enabled = enable;
18711 if (stream_name_set != 0)
18713 mp->stream_name_length = ntohl (name_len);
18714 clib_memcpy (mp->stream_name, stream_name, name_len);
18716 vec_free (stream_name);
18724 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18726 unformat_input_t *input = vam->input;
18727 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18729 u16 *low_ports = 0;
18730 u16 *high_ports = 0;
18733 ip4_address_t ip4_addr;
18734 ip6_address_t ip6_addr;
18743 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18745 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
18751 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
18756 else if (unformat (input, "vrf %d", &vrf_id))
18758 else if (unformat (input, "del"))
18760 else if (unformat (input, "port %d", &tmp))
18762 if (tmp == 0 || tmp > 65535)
18764 errmsg ("port %d out of range", tmp);
18768 this_hi = this_low + 1;
18769 vec_add1 (low_ports, this_low);
18770 vec_add1 (high_ports, this_hi);
18772 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18774 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18776 errmsg ("incorrect range parameters");
18780 /* Note: in debug CLI +1 is added to high before
18781 passing to real fn that does "the work"
18782 (ip_source_and_port_range_check_add_del).
18783 This fn is a wrapper around the binary API fn a
18784 control plane will call, which expects this increment
18785 to have occurred. Hence letting the binary API control
18786 plane fn do the increment for consistency between VAT
18787 and other control planes.
18790 vec_add1 (low_ports, this_low);
18791 vec_add1 (high_ports, this_hi);
18797 if (prefix_set == 0)
18799 errmsg ("<address>/<mask> not specified");
18805 errmsg ("VRF ID required, not specified");
18812 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18816 if (vec_len (low_ports) == 0)
18818 errmsg ("At least one port or port range required");
18822 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18824 mp->is_add = is_add;
18829 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
18834 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
18837 mp->mask_length = length;
18838 mp->number_of_ranges = vec_len (low_ports);
18840 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18841 vec_free (low_ports);
18843 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18844 vec_free (high_ports);
18846 mp->vrf_id = ntohl (vrf_id);
18854 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18856 unformat_input_t *input = vam->input;
18857 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18858 u32 sw_if_index = ~0;
18860 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18861 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18865 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18867 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18869 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18871 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18873 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18875 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18877 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18879 else if (unformat (input, "del"))
18885 if (sw_if_index == ~0)
18887 errmsg ("Interface required but not specified");
18893 errmsg ("VRF ID required but not specified");
18897 if (tcp_out_vrf_id == 0
18898 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18901 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18905 /* Construct the API message */
18906 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18908 mp->sw_if_index = ntohl (sw_if_index);
18909 mp->is_add = is_add;
18910 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18911 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18912 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18913 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18918 /* Wait for a reply... */
18924 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
18926 unformat_input_t *i = vam->input;
18927 vl_api_ipsec_gre_add_del_tunnel_t *mp;
18928 u32 local_sa_id = 0;
18929 u32 remote_sa_id = 0;
18930 ip4_address_t src_address;
18931 ip4_address_t dst_address;
18935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18937 if (unformat (i, "local_sa %d", &local_sa_id))
18939 else if (unformat (i, "remote_sa %d", &remote_sa_id))
18941 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
18943 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
18945 else if (unformat (i, "del"))
18949 clib_warning ("parse error '%U'", format_unformat_error, i);
18954 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
18956 mp->local_sa_id = ntohl (local_sa_id);
18957 mp->remote_sa_id = ntohl (remote_sa_id);
18958 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
18959 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
18960 mp->is_add = is_add;
18968 api_punt (vat_main_t * vam)
18970 unformat_input_t *i = vam->input;
18978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18980 if (unformat (i, "ip %d", &ipv))
18982 else if (unformat (i, "protocol %d", &protocol))
18984 else if (unformat (i, "port %d", &port))
18986 else if (unformat (i, "del"))
18990 clib_warning ("parse error '%U'", format_unformat_error, i);
18997 mp->is_add = (u8) is_add;
18998 mp->ipv = (u8) ipv;
18999 mp->l4_protocol = (u8) protocol;
19000 mp->l4_port = htons ((u16) port);
19007 static void vl_api_ipsec_gre_tunnel_details_t_handler
19008 (vl_api_ipsec_gre_tunnel_details_t * mp)
19010 vat_main_t *vam = &vat_main;
19012 print (vam->ofp, "%11d%15U%15U%14d%14d",
19013 ntohl (mp->sw_if_index),
19014 format_ip4_address, &mp->src_address,
19015 format_ip4_address, &mp->dst_address,
19016 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
19019 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
19020 (vl_api_ipsec_gre_tunnel_details_t * mp)
19022 vat_main_t *vam = &vat_main;
19023 vat_json_node_t *node = NULL;
19024 struct in_addr ip4;
19026 if (VAT_JSON_ARRAY != vam->json_tree.type)
19028 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19029 vat_json_init_array (&vam->json_tree);
19031 node = vat_json_array_add (&vam->json_tree);
19033 vat_json_init_object (node);
19034 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
19035 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
19036 vat_json_object_add_ip4 (node, "src_address", ip4);
19037 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
19038 vat_json_object_add_ip4 (node, "dst_address", ip4);
19039 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
19040 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
19044 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
19046 unformat_input_t *i = vam->input;
19047 vl_api_ipsec_gre_tunnel_dump_t *mp;
19048 vl_api_control_ping_t *mp_ping;
19050 u8 sw_if_index_set = 0;
19053 /* Parse args required to build the message */
19054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19056 if (unformat (i, "sw_if_index %d", &sw_if_index))
19057 sw_if_index_set = 1;
19062 if (sw_if_index_set == 0)
19067 if (!vam->json_output)
19069 print (vam->ofp, "%11s%15s%15s%14s%14s",
19070 "sw_if_index", "src_address", "dst_address",
19071 "local_sa_id", "remote_sa_id");
19074 /* Get list of gre-tunnel interfaces */
19075 M (IPSEC_GRE_TUNNEL_DUMP, mp);
19077 mp->sw_if_index = htonl (sw_if_index);
19081 /* Use a control ping for synchronization */
19082 M (CONTROL_PING, mp_ping);
19090 api_delete_subif (vat_main_t * vam)
19092 unformat_input_t *i = vam->input;
19093 vl_api_delete_subif_t *mp;
19094 u32 sw_if_index = ~0;
19097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19099 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19101 if (unformat (i, "sw_if_index %d", &sw_if_index))
19107 if (sw_if_index == ~0)
19109 errmsg ("missing sw_if_index");
19113 /* Construct the API message */
19114 M (DELETE_SUBIF, mp);
19115 mp->sw_if_index = ntohl (sw_if_index);
19122 #define foreach_pbb_vtr_op \
19123 _("disable", L2_VTR_DISABLED) \
19124 _("pop", L2_VTR_POP_2) \
19125 _("push", L2_VTR_PUSH_2)
19128 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
19130 unformat_input_t *i = vam->input;
19131 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
19132 u32 sw_if_index = ~0, vtr_op = ~0;
19133 u16 outer_tag = ~0;
19134 u8 dmac[6], smac[6];
19135 u8 dmac_set = 0, smac_set = 0;
19141 /* Shut up coverity */
19142 memset (dmac, 0, sizeof (dmac));
19143 memset (smac, 0, sizeof (smac));
19145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19147 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19149 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19151 else if (unformat (i, "vtr_op %d", &vtr_op))
19153 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
19156 else if (unformat (i, "translate_pbb_stag"))
19158 if (unformat (i, "%d", &tmp))
19160 vtr_op = L2_VTR_TRANSLATE_2_1;
19166 ("translate_pbb_stag operation requires outer tag definition");
19170 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
19172 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
19174 else if (unformat (i, "sid %d", &sid))
19176 else if (unformat (i, "vlanid %d", &tmp))
19180 clib_warning ("parse error '%U'", format_unformat_error, i);
19185 if ((sw_if_index == ~0) || (vtr_op == ~0))
19187 errmsg ("missing sw_if_index or vtr operation");
19190 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19191 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19194 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19198 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19199 mp->sw_if_index = ntohl (sw_if_index);
19200 mp->vtr_op = ntohl (vtr_op);
19201 mp->outer_tag = ntohs (outer_tag);
19202 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19203 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19204 mp->b_vlanid = ntohs (vlanid);
19205 mp->i_sid = ntohl (sid);
19213 api_flow_classify_set_interface (vat_main_t * vam)
19215 unformat_input_t *i = vam->input;
19216 vl_api_flow_classify_set_interface_t *mp;
19218 int sw_if_index_set;
19219 u32 ip4_table_index = ~0;
19220 u32 ip6_table_index = ~0;
19224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19226 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19227 sw_if_index_set = 1;
19228 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19229 sw_if_index_set = 1;
19230 else if (unformat (i, "del"))
19232 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19234 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19238 clib_warning ("parse error '%U'", format_unformat_error, i);
19243 if (sw_if_index_set == 0)
19245 errmsg ("missing interface name or sw_if_index");
19249 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19251 mp->sw_if_index = ntohl (sw_if_index);
19252 mp->ip4_table_index = ntohl (ip4_table_index);
19253 mp->ip6_table_index = ntohl (ip6_table_index);
19254 mp->is_add = is_add;
19262 api_flow_classify_dump (vat_main_t * vam)
19264 unformat_input_t *i = vam->input;
19265 vl_api_flow_classify_dump_t *mp;
19266 vl_api_control_ping_t *mp_ping;
19267 u8 type = FLOW_CLASSIFY_N_TABLES;
19270 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19274 errmsg ("classify table type must be specified");
19278 if (!vam->json_output)
19280 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19283 M (FLOW_CLASSIFY_DUMP, mp);
19288 /* Use a control ping for synchronization */
19289 M (CONTROL_PING, mp_ping);
19292 /* Wait for a reply... */
19298 api_feature_enable_disable (vat_main_t * vam)
19300 unformat_input_t *i = vam->input;
19301 vl_api_feature_enable_disable_t *mp;
19303 u8 *feature_name = 0;
19304 u32 sw_if_index = ~0;
19308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19310 if (unformat (i, "arc_name %s", &arc_name))
19312 else if (unformat (i, "feature_name %s", &feature_name))
19315 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19317 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19319 else if (unformat (i, "disable"))
19327 errmsg ("missing arc name");
19330 if (vec_len (arc_name) > 63)
19332 errmsg ("arc name too long");
19335 if (feature_name == 0)
19337 errmsg ("missing feature name");
19340 if (vec_len (feature_name) > 63)
19342 errmsg ("feature name too long");
19345 if (sw_if_index == ~0)
19347 errmsg ("missing interface name or sw_if_index");
19351 /* Construct the API message */
19352 M (FEATURE_ENABLE_DISABLE, mp);
19353 mp->sw_if_index = ntohl (sw_if_index);
19354 mp->enable = enable;
19355 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19356 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19357 vec_free (arc_name);
19358 vec_free (feature_name);
19366 api_sw_interface_tag_add_del (vat_main_t * vam)
19368 unformat_input_t *i = vam->input;
19369 vl_api_sw_interface_tag_add_del_t *mp;
19370 u32 sw_if_index = ~0;
19375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19377 if (unformat (i, "tag %s", &tag))
19379 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19381 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19383 else if (unformat (i, "del"))
19389 if (sw_if_index == ~0)
19391 errmsg ("missing interface name or sw_if_index");
19395 if (enable && (tag == 0))
19397 errmsg ("no tag specified");
19401 /* Construct the API message */
19402 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19403 mp->sw_if_index = ntohl (sw_if_index);
19404 mp->is_add = enable;
19406 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19414 static void vl_api_l2_xconnect_details_t_handler
19415 (vl_api_l2_xconnect_details_t * mp)
19417 vat_main_t *vam = &vat_main;
19419 print (vam->ofp, "%15d%15d",
19420 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19423 static void vl_api_l2_xconnect_details_t_handler_json
19424 (vl_api_l2_xconnect_details_t * mp)
19426 vat_main_t *vam = &vat_main;
19427 vat_json_node_t *node = NULL;
19429 if (VAT_JSON_ARRAY != vam->json_tree.type)
19431 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19432 vat_json_init_array (&vam->json_tree);
19434 node = vat_json_array_add (&vam->json_tree);
19436 vat_json_init_object (node);
19437 vat_json_object_add_uint (node, "rx_sw_if_index",
19438 ntohl (mp->rx_sw_if_index));
19439 vat_json_object_add_uint (node, "tx_sw_if_index",
19440 ntohl (mp->tx_sw_if_index));
19444 api_l2_xconnect_dump (vat_main_t * vam)
19446 vl_api_l2_xconnect_dump_t *mp;
19447 vl_api_control_ping_t *mp_ping;
19450 if (!vam->json_output)
19452 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19455 M (L2_XCONNECT_DUMP, mp);
19459 /* Use a control ping for synchronization */
19460 M (CONTROL_PING, mp_ping);
19468 api_sw_interface_set_mtu (vat_main_t * vam)
19470 unformat_input_t *i = vam->input;
19471 vl_api_sw_interface_set_mtu_t *mp;
19472 u32 sw_if_index = ~0;
19476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19478 if (unformat (i, "mtu %d", &mtu))
19480 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19482 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19488 if (sw_if_index == ~0)
19490 errmsg ("missing interface name or sw_if_index");
19496 errmsg ("no mtu specified");
19500 /* Construct the API message */
19501 M (SW_INTERFACE_SET_MTU, mp);
19502 mp->sw_if_index = ntohl (sw_if_index);
19503 mp->mtu = ntohs ((u16) mtu);
19511 api_p2p_ethernet_add (vat_main_t * vam)
19513 unformat_input_t *i = vam->input;
19514 vl_api_p2p_ethernet_add_t *mp;
19515 u32 parent_if_index = ~0;
19521 memset (remote_mac, 0, sizeof (remote_mac));
19522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19524 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19526 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19530 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19532 else if (unformat (i, "sub_id %d", &sub_id))
19536 clib_warning ("parse error '%U'", format_unformat_error, i);
19541 if (parent_if_index == ~0)
19543 errmsg ("missing interface name or sw_if_index");
19548 errmsg ("missing remote mac address");
19553 errmsg ("missing sub-interface id");
19557 M (P2P_ETHERNET_ADD, mp);
19558 mp->parent_if_index = ntohl (parent_if_index);
19559 mp->subif_id = ntohl (sub_id);
19560 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19568 api_p2p_ethernet_del (vat_main_t * vam)
19570 unformat_input_t *i = vam->input;
19571 vl_api_p2p_ethernet_del_t *mp;
19572 u32 parent_if_index = ~0;
19577 memset (remote_mac, 0, sizeof (remote_mac));
19578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19580 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19582 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19586 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19590 clib_warning ("parse error '%U'", format_unformat_error, i);
19595 if (parent_if_index == ~0)
19597 errmsg ("missing interface name or sw_if_index");
19602 errmsg ("missing remote mac address");
19606 M (P2P_ETHERNET_DEL, mp);
19607 mp->parent_if_index = ntohl (parent_if_index);
19608 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19616 api_lldp_config (vat_main_t * vam)
19618 unformat_input_t *i = vam->input;
19619 vl_api_lldp_config_t *mp;
19621 int tx_interval = 0;
19622 u8 *sys_name = NULL;
19625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19627 if (unformat (i, "system-name %s", &sys_name))
19629 else if (unformat (i, "tx-hold %d", &tx_hold))
19631 else if (unformat (i, "tx-interval %d", &tx_interval))
19635 clib_warning ("parse error '%U'", format_unformat_error, i);
19640 vec_add1 (sys_name, 0);
19642 M (LLDP_CONFIG, mp);
19643 mp->tx_hold = htonl (tx_hold);
19644 mp->tx_interval = htonl (tx_interval);
19645 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19646 vec_free (sys_name);
19654 api_sw_interface_set_lldp (vat_main_t * vam)
19656 unformat_input_t *i = vam->input;
19657 vl_api_sw_interface_set_lldp_t *mp;
19658 u32 sw_if_index = ~0;
19660 u8 *port_desc = NULL;
19663 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19665 if (unformat (i, "disable"))
19668 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19670 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19672 else if (unformat (i, "port-desc %s", &port_desc))
19678 if (sw_if_index == ~0)
19680 errmsg ("missing interface name or sw_if_index");
19684 /* Construct the API message */
19685 vec_add1 (port_desc, 0);
19686 M (SW_INTERFACE_SET_LLDP, mp);
19687 mp->sw_if_index = ntohl (sw_if_index);
19688 mp->enable = enable;
19689 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19690 vec_free (port_desc);
19698 q_or_quit (vat_main_t * vam)
19700 #if VPP_API_TEST_BUILTIN == 0
19701 longjmp (vam->jump_buf, 1);
19703 return 0; /* not so much */
19707 q (vat_main_t * vam)
19709 return q_or_quit (vam);
19713 quit (vat_main_t * vam)
19715 return q_or_quit (vam);
19719 comment (vat_main_t * vam)
19725 cmd_cmp (void *a1, void *a2)
19730 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
19734 help (vat_main_t * vam)
19739 unformat_input_t *i = vam->input;
19742 if (unformat (i, "%s", &name))
19746 vec_add1 (name, 0);
19748 hs = hash_get_mem (vam->help_by_name, name);
19750 print (vam->ofp, "usage: %s %s", name, hs[0]);
19752 print (vam->ofp, "No such msg / command '%s'", name);
19757 print (vam->ofp, "Help is available for the following:");
19760 hash_foreach_pair (p, vam->function_by_name,
19762 vec_add1 (cmds, (u8 *)(p->key));
19766 vec_sort_with_function (cmds, cmd_cmp);
19768 for (j = 0; j < vec_len (cmds); j++)
19769 print (vam->ofp, "%s", cmds[j]);
19776 set (vat_main_t * vam)
19778 u8 *name = 0, *value = 0;
19779 unformat_input_t *i = vam->input;
19781 if (unformat (i, "%s", &name))
19783 /* The input buffer is a vector, not a string. */
19784 value = vec_dup (i->buffer);
19785 vec_delete (value, i->index, 0);
19786 /* Almost certainly has a trailing newline */
19787 if (value[vec_len (value) - 1] == '\n')
19788 value[vec_len (value) - 1] = 0;
19789 /* Make sure it's a proper string, one way or the other */
19790 vec_add1 (value, 0);
19791 (void) clib_macro_set_value (&vam->macro_main,
19792 (char *) name, (char *) value);
19795 errmsg ("usage: set <name> <value>");
19803 unset (vat_main_t * vam)
19807 if (unformat (vam->input, "%s", &name))
19808 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
19809 errmsg ("unset: %s wasn't set", name);
19822 macro_sort_cmp (void *a1, void *a2)
19824 macro_sort_t *s1 = a1;
19825 macro_sort_t *s2 = a2;
19827 return strcmp ((char *) (s1->name), (char *) (s2->name));
19831 dump_macro_table (vat_main_t * vam)
19833 macro_sort_t *sort_me = 0, *sm;
19838 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
19840 vec_add2 (sort_me, sm, 1);
19841 sm->name = (u8 *)(p->key);
19842 sm->value = (u8 *) (p->value[0]);
19846 vec_sort_with_function (sort_me, macro_sort_cmp);
19848 if (vec_len (sort_me))
19849 print (vam->ofp, "%-15s%s", "Name", "Value");
19851 print (vam->ofp, "The macro table is empty...");
19853 for (i = 0; i < vec_len (sort_me); i++)
19854 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
19859 dump_node_table (vat_main_t * vam)
19862 vlib_node_t *node, *next_node;
19864 if (vec_len (vam->graph_nodes) == 0)
19866 print (vam->ofp, "Node table empty, issue get_node_graph...");
19870 for (i = 0; i < vec_len (vam->graph_nodes); i++)
19872 node = vam->graph_nodes[i];
19873 print (vam->ofp, "[%d] %s", i, node->name);
19874 for (j = 0; j < vec_len (node->next_nodes); j++)
19876 if (node->next_nodes[j] != ~0)
19878 next_node = vam->graph_nodes[node->next_nodes[j]];
19879 print (vam->ofp, " [%d] %s", j, next_node->name);
19887 value_sort_cmp (void *a1, void *a2)
19889 name_sort_t *n1 = a1;
19890 name_sort_t *n2 = a2;
19892 if (n1->value < n2->value)
19894 if (n1->value > n2->value)
19901 dump_msg_api_table (vat_main_t * vam)
19903 api_main_t *am = &api_main;
19904 name_sort_t *nses = 0, *ns;
19909 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
19911 vec_add2 (nses, ns, 1);
19912 ns->name = (u8 *)(hp->key);
19913 ns->value = (u32) hp->value[0];
19917 vec_sort_with_function (nses, value_sort_cmp);
19919 for (i = 0; i < vec_len (nses); i++)
19920 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
19926 get_msg_id (vat_main_t * vam)
19931 if (unformat (vam->input, "%s", &name_and_crc))
19933 message_index = vl_api_get_msg_index (name_and_crc);
19934 if (message_index == ~0)
19936 print (vam->ofp, " '%s' not found", name_and_crc);
19939 print (vam->ofp, " '%s' has message index %d",
19940 name_and_crc, message_index);
19943 errmsg ("name_and_crc required...");
19948 search_node_table (vat_main_t * vam)
19950 unformat_input_t *line_input = vam->input;
19953 vlib_node_t *node, *next_node;
19956 if (vam->graph_node_index_by_name == 0)
19958 print (vam->ofp, "Node table empty, issue get_node_graph...");
19962 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
19964 if (unformat (line_input, "%s", &node_to_find))
19966 vec_add1 (node_to_find, 0);
19967 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
19970 print (vam->ofp, "%s not found...", node_to_find);
19973 node = vam->graph_nodes[p[0]];
19974 print (vam->ofp, "[%d] %s", p[0], node->name);
19975 for (j = 0; j < vec_len (node->next_nodes); j++)
19977 if (node->next_nodes[j] != ~0)
19979 next_node = vam->graph_nodes[node->next_nodes[j]];
19980 print (vam->ofp, " [%d] %s", j, next_node->name);
19987 clib_warning ("parse error '%U'", format_unformat_error,
19993 vec_free (node_to_find);
20002 script (vat_main_t * vam)
20004 #if (VPP_API_TEST_BUILTIN==0)
20006 char *save_current_file;
20007 unformat_input_t save_input;
20008 jmp_buf save_jump_buf;
20009 u32 save_line_number;
20011 FILE *new_fp, *save_ifp;
20013 if (unformat (vam->input, "%s", &s))
20015 new_fp = fopen ((char *) s, "r");
20018 errmsg ("Couldn't open script file %s", s);
20025 errmsg ("Missing script name");
20029 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20030 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20031 save_ifp = vam->ifp;
20032 save_line_number = vam->input_line_number;
20033 save_current_file = (char *) vam->current_file;
20035 vam->input_line_number = 0;
20037 vam->current_file = s;
20040 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
20041 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20042 vam->ifp = save_ifp;
20043 vam->input_line_number = save_line_number;
20044 vam->current_file = (u8 *) save_current_file;
20049 clib_warning ("use the exec command...");
20055 echo (vat_main_t * vam)
20057 print (vam->ofp, "%v", vam->input->buffer);
20061 /* List of API message constructors, CLI names map to api_xxx */
20062 #define foreach_vpe_api_msg \
20063 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20064 _(sw_interface_dump,"") \
20065 _(sw_interface_set_flags, \
20066 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20067 _(sw_interface_add_del_address, \
20068 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20069 _(sw_interface_set_table, \
20070 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20071 _(sw_interface_set_mpls_enable, \
20072 "<intfc> | sw_if_index [disable | dis]") \
20073 _(sw_interface_set_vpath, \
20074 "<intfc> | sw_if_index <id> enable | disable") \
20075 _(sw_interface_set_vxlan_bypass, \
20076 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20077 _(sw_interface_set_l2_xconnect, \
20078 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20079 "enable | disable") \
20080 _(sw_interface_set_l2_bridge, \
20081 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20082 "[shg <split-horizon-group>] [bvi]\n" \
20083 "enable | disable") \
20084 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20085 _(bridge_domain_add_del, \
20086 "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] [del]\n") \
20087 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20089 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20090 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20091 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20093 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20095 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20097 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
20099 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
20101 "<vpp-if-name> | sw_if_index <id>") \
20102 _(sw_interface_tap_dump, "") \
20103 _(ip_table_add_del, \
20104 "table-id <n> [ipv6]\n") \
20105 _(ip_add_del_route, \
20106 "<addr>/<mask> via <addr> [table-id <n>]\n" \
20107 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
20108 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
20109 "[multipath] [count <n>]") \
20110 _(ip_mroute_add_del, \
20111 "<src> <grp>/<mask> [table-id <n>]\n" \
20112 "[<intfc> | sw_if_index <id>] [local] [del]") \
20113 _(mpls_table_add_del, \
20114 "table-id <n>\n") \
20115 _(mpls_route_add_del, \
20116 "<label> <eos> via <addr> [table-id <n>]\n" \
20117 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
20118 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
20119 "[multipath] [count <n>]") \
20120 _(mpls_ip_bind_unbind, \
20121 "<label> <addr/len>") \
20122 _(mpls_tunnel_add_del, \
20123 " via <addr> [table-id <n>]\n" \
20124 "sw_if_index <id>] [l2] [del]") \
20125 _(proxy_arp_add_del, \
20126 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
20127 _(proxy_arp_intfc_enable_disable, \
20128 "<intfc> | sw_if_index <id> enable | disable") \
20129 _(sw_interface_set_unnumbered, \
20130 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20131 _(ip_neighbor_add_del, \
20132 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
20133 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
20134 _(reset_vrf, "vrf <id> [ipv6]") \
20135 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20136 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20137 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20138 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20139 "[outer_vlan_id_any][inner_vlan_id_any]") \
20140 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
20141 _(reset_fib, "vrf <n> [ipv6]") \
20142 _(dhcp_proxy_config, \
20143 "svr <v46-address> src <v46-address>\n" \
20144 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
20145 _(dhcp_proxy_set_vss, \
20146 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
20147 _(dhcp_proxy_dump, "ip6") \
20148 _(dhcp_client_config, \
20149 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
20150 _(set_ip_flow_hash, \
20151 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20152 _(sw_interface_ip6_enable_disable, \
20153 "<intfc> | sw_if_index <id> enable | disable") \
20154 _(sw_interface_ip6_set_link_local_address, \
20155 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
20156 _(ip6nd_proxy_add_del, \
20157 "<intfc> | sw_if_index <id> <ip6-address>") \
20158 _(ip6nd_proxy_dump, "") \
20159 _(sw_interface_ip6nd_ra_prefix, \
20160 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
20161 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
20162 "[nolink] [isno]") \
20163 _(sw_interface_ip6nd_ra_config, \
20164 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
20165 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
20166 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
20167 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
20168 _(l2_patch_add_del, \
20169 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20170 "enable | disable") \
20171 _(sr_localsid_add_del, \
20172 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20173 "fib-table <num> (end.psp) sw_if_index <num>") \
20174 _(classify_add_del_table, \
20175 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20176 " [del] [del-chain] mask <mask-value>\n" \
20177 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20178 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20179 _(classify_add_del_session, \
20180 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20181 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20182 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20183 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20184 _(classify_set_interface_ip_table, \
20185 "<intfc> | sw_if_index <nn> table <nn>") \
20186 _(classify_set_interface_l2_tables, \
20187 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20188 " [other-table <nn>]") \
20189 _(get_node_index, "node <node-name") \
20190 _(add_node_next, "node <node-name> next <next-node-name>") \
20191 _(l2tpv3_create_tunnel, \
20192 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20193 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20194 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20195 _(l2tpv3_set_tunnel_cookies, \
20196 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20197 "[new_remote_cookie <nn>]\n") \
20198 _(l2tpv3_interface_enable_disable, \
20199 "<intfc> | sw_if_index <nn> enable | disable") \
20200 _(l2tpv3_set_lookup_key, \
20201 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20202 _(sw_if_l2tpv3_tunnel_dump, "") \
20203 _(vxlan_add_del_tunnel, \
20204 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20205 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20206 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20207 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20208 _(gre_add_del_tunnel, \
20209 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
20210 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20211 _(l2_fib_clear_table, "") \
20212 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20213 _(l2_interface_vlan_tag_rewrite, \
20214 "<intfc> | sw_if_index <nn> \n" \
20215 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20216 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20217 _(create_vhost_user_if, \
20218 "socket <filename> [server] [renumber <dev_instance>] " \
20219 "[mac <mac_address>]") \
20220 _(modify_vhost_user_if, \
20221 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20222 "[server] [renumber <dev_instance>]") \
20223 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20224 _(sw_interface_vhost_user_dump, "") \
20225 _(show_version, "") \
20226 _(vxlan_gpe_add_del_tunnel, \
20227 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20228 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20229 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20230 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20231 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20232 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20233 _(interface_name_renumber, \
20234 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20235 _(input_acl_set_interface, \
20236 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20237 " [l2-table <nn>] [del]") \
20238 _(want_ip4_arp_events, "address <ip4-address> [del]") \
20239 _(want_ip6_nd_events, "address <ip6-address> [del]") \
20240 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20241 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20242 _(ip_dump, "ipv4 | ipv6") \
20243 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20244 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20246 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20247 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20248 " integ_alg <alg> integ_key <hex>") \
20249 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
20250 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20251 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20252 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20253 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
20254 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20255 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20256 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20257 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
20258 _(ikev2_profile_add_del, "name <profile_name> [del]") \
20259 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
20260 "(auth_data 0x<data> | auth_data <data>)") \
20261 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
20262 "(id_data 0x<data> | id_data <data>) (local|remote)") \
20263 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
20264 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
20265 "(local|remote)") \
20266 _(ikev2_set_local_key, "file <absolute_file_path>") \
20267 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
20268 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
20269 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
20270 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
20271 _(ikev2_initiate_sa_init, "<profile_name>") \
20272 _(ikev2_initiate_del_ike_sa, "<ispi>") \
20273 _(ikev2_initiate_del_child_sa, "<ispi>") \
20274 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
20275 _(delete_loopback,"sw_if_index <nn>") \
20276 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20277 _(map_add_domain, \
20278 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
20279 "ip6-src <ip6addr> " \
20280 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
20281 _(map_del_domain, "index <n>") \
20282 _(map_add_del_rule, \
20283 "index <n> psid <n> dst <ip6addr> [del]") \
20284 _(map_domain_dump, "") \
20285 _(map_rule_dump, "index <map-domain>") \
20286 _(want_interface_events, "enable|disable") \
20287 _(want_stats,"enable|disable") \
20288 _(get_first_msg_id, "client <name>") \
20289 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20290 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20291 "fib-id <nn> [ip4][ip6][default]") \
20292 _(get_node_graph, " ") \
20293 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20294 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20295 _(ioam_disable, "") \
20296 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20297 " sw_if_index <sw_if_index> p <priority> " \
20298 "w <weight>] [del]") \
20299 _(one_add_del_locator, "locator-set <locator_name> " \
20300 "iface <intf> | sw_if_index <sw_if_index> " \
20301 "p <priority> w <weight> [del]") \
20302 _(one_add_del_local_eid,"vni <vni> eid " \
20303 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20304 "locator-set <locator_name> [del]" \
20305 "[key-id sha1|sha256 secret-key <secret-key>]")\
20306 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20307 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20308 _(one_enable_disable, "enable|disable") \
20309 _(one_map_register_enable_disable, "enable|disable") \
20310 _(one_map_register_fallback_threshold, "<value>") \
20311 _(one_rloc_probe_enable_disable, "enable|disable") \
20312 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20314 "rloc <locator> p <prio> " \
20315 "w <weight> [rloc <loc> ... ] " \
20316 "action <action> [del-all]") \
20317 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20319 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20320 _(one_use_petr, "ip-address> | disable") \
20321 _(one_map_request_mode, "src-dst|dst-only") \
20322 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20323 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20324 _(one_locator_set_dump, "[local | remote]") \
20325 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20326 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20327 "[local] | [remote]") \
20328 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20329 _(one_l2_arp_bd_get, "") \
20330 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20331 _(one_stats_enable_disable, "enable|disalbe") \
20332 _(show_one_stats_enable_disable, "") \
20333 _(one_eid_table_vni_dump, "") \
20334 _(one_eid_table_map_dump, "l2|l3") \
20335 _(one_map_resolver_dump, "") \
20336 _(one_map_server_dump, "") \
20337 _(one_adjacencies_get, "vni <vni>") \
20338 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20339 _(show_one_rloc_probe_state, "") \
20340 _(show_one_map_register_state, "") \
20341 _(show_one_status, "") \
20342 _(one_stats_dump, "") \
20343 _(one_stats_flush, "") \
20344 _(one_get_map_request_itr_rlocs, "") \
20345 _(one_map_register_set_ttl, "<ttl>") \
20346 _(show_one_nsh_mapping, "") \
20347 _(show_one_pitr, "") \
20348 _(show_one_use_petr, "") \
20349 _(show_one_map_request_mode, "") \
20350 _(show_one_map_register_ttl, "") \
20351 _(show_one_map_register_fallback_threshold, "") \
20352 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20353 " sw_if_index <sw_if_index> p <priority> " \
20354 "w <weight>] [del]") \
20355 _(lisp_add_del_locator, "locator-set <locator_name> " \
20356 "iface <intf> | sw_if_index <sw_if_index> " \
20357 "p <priority> w <weight> [del]") \
20358 _(lisp_add_del_local_eid,"vni <vni> eid " \
20359 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20360 "locator-set <locator_name> [del]" \
20361 "[key-id sha1|sha256 secret-key <secret-key>]") \
20362 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20363 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20364 _(lisp_enable_disable, "enable|disable") \
20365 _(lisp_map_register_enable_disable, "enable|disable") \
20366 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20367 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20369 "rloc <locator> p <prio> " \
20370 "w <weight> [rloc <loc> ... ] " \
20371 "action <action> [del-all]") \
20372 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20374 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20375 _(lisp_use_petr, "<ip-address> | disable") \
20376 _(lisp_map_request_mode, "src-dst|dst-only") \
20377 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20378 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20379 _(lisp_locator_set_dump, "[local | remote]") \
20380 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20381 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20382 "[local] | [remote]") \
20383 _(lisp_eid_table_vni_dump, "") \
20384 _(lisp_eid_table_map_dump, "l2|l3") \
20385 _(lisp_map_resolver_dump, "") \
20386 _(lisp_map_server_dump, "") \
20387 _(lisp_adjacencies_get, "vni <vni>") \
20388 _(gpe_fwd_entry_vnis_get, "") \
20389 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20390 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20391 "[table <table-id>]") \
20392 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20393 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20394 _(gpe_set_encap_mode, "lisp|vxlan") \
20395 _(gpe_get_encap_mode, "") \
20396 _(lisp_gpe_add_del_iface, "up|down") \
20397 _(lisp_gpe_enable_disable, "enable|disable") \
20398 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20399 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20400 _(show_lisp_rloc_probe_state, "") \
20401 _(show_lisp_map_register_state, "") \
20402 _(show_lisp_status, "") \
20403 _(lisp_get_map_request_itr_rlocs, "") \
20404 _(show_lisp_pitr, "") \
20405 _(show_lisp_use_petr, "") \
20406 _(show_lisp_map_request_mode, "") \
20407 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20408 _(af_packet_delete, "name <host interface name>") \
20409 _(policer_add_del, "name <policer name> <params> [del]") \
20410 _(policer_dump, "[name <policer name>]") \
20411 _(policer_classify_set_interface, \
20412 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20413 " [l2-table <nn>] [del]") \
20414 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20415 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
20416 "[master|slave]") \
20417 _(netmap_delete, "name <interface name>") \
20418 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20419 _(mpls_fib_dump, "") \
20420 _(classify_table_ids, "") \
20421 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20422 _(classify_table_info, "table_id <nn>") \
20423 _(classify_session_dump, "table_id <nn>") \
20424 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20425 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20426 "[template_interval <nn>] [udp_checksum]") \
20427 _(ipfix_exporter_dump, "") \
20428 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20429 _(ipfix_classify_stream_dump, "") \
20430 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20431 _(ipfix_classify_table_dump, "") \
20432 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20433 _(sw_interface_span_dump, "[l2]") \
20434 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20435 _(pg_create_interface, "if_id <nn>") \
20436 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20437 _(pg_enable_disable, "[stream <id>] disable") \
20438 _(ip_source_and_port_range_check_add_del, \
20439 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20440 _(ip_source_and_port_range_check_interface_add_del, \
20441 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20442 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20443 _(ipsec_gre_add_del_tunnel, \
20444 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
20445 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
20446 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20447 _(l2_interface_pbb_tag_rewrite, \
20448 "<intfc> | sw_if_index <nn> \n" \
20449 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
20450 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
20451 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
20452 _(flow_classify_set_interface, \
20453 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
20454 _(flow_classify_dump, "type [ip4|ip6]") \
20455 _(ip_fib_dump, "") \
20456 _(ip_mfib_dump, "") \
20457 _(ip6_fib_dump, "") \
20458 _(ip6_mfib_dump, "") \
20459 _(feature_enable_disable, "arc_name <arc_name> " \
20460 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
20461 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
20463 _(l2_xconnect_dump, "") \
20464 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
20465 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
20466 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
20467 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
20468 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
20469 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
20470 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>] [disable]")
20472 /* List of command functions, CLI names map directly to functions */
20473 #define foreach_cli_function \
20474 _(comment, "usage: comment <ignore-rest-of-line>") \
20475 _(dump_interface_table, "usage: dump_interface_table") \
20476 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
20477 _(dump_ipv4_table, "usage: dump_ipv4_table") \
20478 _(dump_ipv6_table, "usage: dump_ipv6_table") \
20479 _(dump_stats_table, "usage: dump_stats_table") \
20480 _(dump_macro_table, "usage: dump_macro_table ") \
20481 _(dump_node_table, "usage: dump_node_table") \
20482 _(dump_msg_api_table, "usage: dump_msg_api_table") \
20483 _(get_msg_id, "usage: get_msg_id name_and_crc") \
20484 _(echo, "usage: echo <message>") \
20485 _(exec, "usage: exec <vpe-debug-CLI-command>") \
20486 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
20487 _(help, "usage: help") \
20488 _(q, "usage: quit") \
20489 _(quit, "usage: quit") \
20490 _(search_node_table, "usage: search_node_table <name>...") \
20491 _(set, "usage: set <variable-name> <value>") \
20492 _(script, "usage: script <file-name>") \
20493 _(unset, "usage: unset <variable-name>")
20495 static void vl_api_##n##_t_handler_uni \
20496 (vl_api_##n##_t * mp) \
20498 vat_main_t * vam = &vat_main; \
20499 if (vam->json_output) { \
20500 vl_api_##n##_t_handler_json(mp); \
20502 vl_api_##n##_t_handler(mp); \
20505 foreach_vpe_api_reply_msg;
20506 #if VPP_API_TEST_BUILTIN == 0
20507 foreach_standalone_reply_msg;
20512 vat_api_hookup (vat_main_t * vam)
20515 vl_msg_api_set_handlers(VL_API_##N, #n, \
20516 vl_api_##n##_t_handler_uni, \
20518 vl_api_##n##_t_endian, \
20519 vl_api_##n##_t_print, \
20520 sizeof(vl_api_##n##_t), 1);
20521 foreach_vpe_api_reply_msg;
20522 #if VPP_API_TEST_BUILTIN == 0
20523 foreach_standalone_reply_msg;
20527 #if (VPP_API_TEST_BUILTIN==0)
20528 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
20530 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
20532 vam->function_by_name = hash_create_string (0, sizeof (uword));
20534 vam->help_by_name = hash_create_string (0, sizeof (uword));
20537 /* API messages we can send */
20538 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
20539 foreach_vpe_api_msg;
20543 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
20544 foreach_vpe_api_msg;
20547 /* CLI functions */
20548 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
20549 foreach_cli_function;
20553 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
20554 foreach_cli_function;
20558 #if VPP_API_TEST_BUILTIN
20559 static clib_error_t *
20560 vat_api_hookup_shim (vlib_main_t * vm)
20562 vat_api_hookup (&vat_main);
20566 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
20570 * fd.io coding-style-patch-verification: ON
20573 * eval: (c-set-style "gnu")