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_mroute_add_del_reply) \
4619 _(mpls_route_add_del_reply) \
4620 _(mpls_ip_bind_unbind_reply) \
4621 _(proxy_arp_add_del_reply) \
4622 _(proxy_arp_intfc_enable_disable_reply) \
4623 _(sw_interface_set_unnumbered_reply) \
4624 _(ip_neighbor_add_del_reply) \
4625 _(reset_vrf_reply) \
4626 _(oam_add_del_reply) \
4627 _(reset_fib_reply) \
4628 _(dhcp_proxy_config_reply) \
4629 _(dhcp_proxy_set_vss_reply) \
4630 _(dhcp_client_config_reply) \
4631 _(set_ip_flow_hash_reply) \
4632 _(sw_interface_ip6_enable_disable_reply) \
4633 _(sw_interface_ip6_set_link_local_address_reply) \
4634 _(ip6nd_proxy_add_del_reply) \
4635 _(sw_interface_ip6nd_ra_prefix_reply) \
4636 _(sw_interface_ip6nd_ra_config_reply) \
4637 _(set_arp_neighbor_limit_reply) \
4638 _(l2_patch_add_del_reply) \
4639 _(sr_policy_add_reply) \
4640 _(sr_policy_mod_reply) \
4641 _(sr_policy_del_reply) \
4642 _(sr_localsid_add_del_reply) \
4643 _(sr_steering_add_del_reply) \
4644 _(classify_add_del_session_reply) \
4645 _(classify_set_interface_ip_table_reply) \
4646 _(classify_set_interface_l2_tables_reply) \
4647 _(l2tpv3_set_tunnel_cookies_reply) \
4648 _(l2tpv3_interface_enable_disable_reply) \
4649 _(l2tpv3_set_lookup_key_reply) \
4650 _(l2_fib_clear_table_reply) \
4651 _(l2_interface_efp_filter_reply) \
4652 _(l2_interface_vlan_tag_rewrite_reply) \
4653 _(modify_vhost_user_if_reply) \
4654 _(delete_vhost_user_if_reply) \
4655 _(want_ip4_arp_events_reply) \
4656 _(want_ip6_nd_events_reply) \
4657 _(want_l2_macs_events_reply) \
4658 _(input_acl_set_interface_reply) \
4659 _(ipsec_spd_add_del_reply) \
4660 _(ipsec_interface_add_del_spd_reply) \
4661 _(ipsec_spd_add_del_entry_reply) \
4662 _(ipsec_sad_add_del_entry_reply) \
4663 _(ipsec_sa_set_key_reply) \
4664 _(ipsec_tunnel_if_add_del_reply) \
4665 _(ikev2_profile_add_del_reply) \
4666 _(ikev2_profile_set_auth_reply) \
4667 _(ikev2_profile_set_id_reply) \
4668 _(ikev2_profile_set_ts_reply) \
4669 _(ikev2_set_local_key_reply) \
4670 _(ikev2_set_responder_reply) \
4671 _(ikev2_set_ike_transforms_reply) \
4672 _(ikev2_set_esp_transforms_reply) \
4673 _(ikev2_set_sa_lifetime_reply) \
4674 _(ikev2_initiate_sa_init_reply) \
4675 _(ikev2_initiate_del_ike_sa_reply) \
4676 _(ikev2_initiate_del_child_sa_reply) \
4677 _(ikev2_initiate_rekey_child_sa_reply) \
4678 _(delete_loopback_reply) \
4679 _(bd_ip_mac_add_del_reply) \
4680 _(map_del_domain_reply) \
4681 _(map_add_del_rule_reply) \
4682 _(want_interface_events_reply) \
4683 _(want_stats_reply) \
4684 _(cop_interface_enable_disable_reply) \
4685 _(cop_whitelist_enable_disable_reply) \
4686 _(sw_interface_clear_stats_reply) \
4687 _(ioam_enable_reply) \
4688 _(ioam_disable_reply) \
4689 _(one_add_del_locator_reply) \
4690 _(one_add_del_local_eid_reply) \
4691 _(one_add_del_remote_mapping_reply) \
4692 _(one_add_del_adjacency_reply) \
4693 _(one_add_del_map_resolver_reply) \
4694 _(one_add_del_map_server_reply) \
4695 _(one_enable_disable_reply) \
4696 _(one_rloc_probe_enable_disable_reply) \
4697 _(one_map_register_enable_disable_reply) \
4698 _(one_map_register_set_ttl_reply) \
4699 _(one_map_register_fallback_threshold_reply) \
4700 _(one_pitr_set_locator_set_reply) \
4701 _(one_map_request_mode_reply) \
4702 _(one_add_del_map_request_itr_rlocs_reply) \
4703 _(one_eid_table_add_del_map_reply) \
4704 _(one_use_petr_reply) \
4705 _(one_stats_enable_disable_reply) \
4706 _(one_add_del_l2_arp_entry_reply) \
4707 _(one_stats_flush_reply) \
4708 _(gpe_enable_disable_reply) \
4709 _(gpe_set_encap_mode_reply) \
4710 _(gpe_add_del_iface_reply) \
4711 _(gpe_add_del_native_fwd_rpath_reply) \
4712 _(af_packet_delete_reply) \
4713 _(policer_classify_set_interface_reply) \
4714 _(netmap_create_reply) \
4715 _(netmap_delete_reply) \
4716 _(set_ipfix_exporter_reply) \
4717 _(set_ipfix_classify_stream_reply) \
4718 _(ipfix_classify_table_add_del_reply) \
4719 _(flow_classify_set_interface_reply) \
4720 _(sw_interface_span_enable_disable_reply) \
4721 _(pg_capture_reply) \
4722 _(pg_enable_disable_reply) \
4723 _(ip_source_and_port_range_check_add_del_reply) \
4724 _(ip_source_and_port_range_check_interface_add_del_reply)\
4725 _(delete_subif_reply) \
4726 _(l2_interface_pbb_tag_rewrite_reply) \
4728 _(feature_enable_disable_reply) \
4729 _(sw_interface_tag_add_del_reply) \
4730 _(sw_interface_set_mtu_reply) \
4731 _(p2p_ethernet_add_reply) \
4732 _(p2p_ethernet_del_reply) \
4733 _(lldp_config_reply) \
4734 _(sw_interface_set_lldp_reply)
4737 static void vl_api_##n##_t_handler \
4738 (vl_api_##n##_t * mp) \
4740 vat_main_t * vam = &vat_main; \
4741 i32 retval = ntohl(mp->retval); \
4742 if (vam->async_mode) { \
4743 vam->async_errors += (retval < 0); \
4745 vam->retval = retval; \
4746 vam->result_ready = 1; \
4749 foreach_standard_reply_retval_handler;
4753 static void vl_api_##n##_t_handler_json \
4754 (vl_api_##n##_t * mp) \
4756 vat_main_t * vam = &vat_main; \
4757 vat_json_node_t node; \
4758 vat_json_init_object(&node); \
4759 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
4760 vat_json_print(vam->ofp, &node); \
4761 vam->retval = ntohl(mp->retval); \
4762 vam->result_ready = 1; \
4764 foreach_standard_reply_retval_handler;
4768 * Table of message reply handlers, must include boilerplate handlers
4772 #define foreach_vpe_api_reply_msg \
4773 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4774 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
4775 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4776 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4777 _(CONTROL_PING_REPLY, control_ping_reply) \
4778 _(CLI_REPLY, cli_reply) \
4779 _(CLI_INBAND_REPLY, cli_inband_reply) \
4780 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4781 sw_interface_add_del_address_reply) \
4782 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4783 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4784 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4785 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4786 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
4787 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4788 sw_interface_set_l2_xconnect_reply) \
4789 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4790 sw_interface_set_l2_bridge_reply) \
4791 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4792 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4793 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
4794 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4795 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
4796 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
4797 _(L2_FLAGS_REPLY, l2_flags_reply) \
4798 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4799 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4800 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4801 _(TAP_DELETE_REPLY, tap_delete_reply) \
4802 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4803 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4804 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4805 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4806 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4807 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4808 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4809 proxy_arp_intfc_enable_disable_reply) \
4810 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4811 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4812 sw_interface_set_unnumbered_reply) \
4813 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4814 _(RESET_VRF_REPLY, reset_vrf_reply) \
4815 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4816 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4817 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4818 _(RESET_FIB_REPLY, reset_fib_reply) \
4819 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4820 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4821 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4822 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4823 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4824 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4825 sw_interface_ip6_enable_disable_reply) \
4826 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4827 sw_interface_ip6_set_link_local_address_reply) \
4828 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
4829 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
4830 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4831 sw_interface_ip6nd_ra_prefix_reply) \
4832 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4833 sw_interface_ip6nd_ra_config_reply) \
4834 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4835 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4836 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
4837 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
4838 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
4839 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
4840 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
4841 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4842 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4843 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4844 classify_set_interface_ip_table_reply) \
4845 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4846 classify_set_interface_l2_tables_reply) \
4847 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4848 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4849 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4850 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4851 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4852 l2tpv3_interface_enable_disable_reply) \
4853 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4854 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4855 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4856 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4857 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4858 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4859 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4860 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4861 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4862 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4863 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4864 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4865 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4866 _(SHOW_VERSION_REPLY, show_version_reply) \
4867 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
4868 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4869 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4870 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4871 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4872 _(IP4_ARP_EVENT, ip4_arp_event) \
4873 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4874 _(IP6_ND_EVENT, ip6_nd_event) \
4875 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
4876 _(L2_MACS_EVENT, l2_macs_event) \
4877 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4878 _(IP_ADDRESS_DETAILS, ip_address_details) \
4879 _(IP_DETAILS, ip_details) \
4880 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4881 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4882 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4883 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4884 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4885 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
4886 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4887 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4888 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4889 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4890 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4891 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4892 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4893 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4894 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4895 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4896 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4897 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4898 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4899 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4900 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4901 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4902 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4903 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4904 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4905 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4906 _(MAP_RULE_DETAILS, map_rule_details) \
4907 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4908 _(WANT_STATS_REPLY, want_stats_reply) \
4909 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4910 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4911 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4912 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4913 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4914 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4915 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4916 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4917 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4918 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4919 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4920 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4921 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4922 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4923 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4924 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4925 one_map_register_enable_disable_reply) \
4926 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
4927 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
4928 one_map_register_fallback_threshold_reply) \
4929 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4930 one_rloc_probe_enable_disable_reply) \
4931 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4932 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
4933 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4934 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4935 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4936 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4937 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4938 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4939 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4940 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4941 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4942 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4943 _(ONE_STATS_DETAILS, one_stats_details) \
4944 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
4945 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
4946 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
4947 show_one_stats_enable_disable_reply) \
4948 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
4949 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
4950 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
4951 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4952 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4953 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4954 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4955 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4956 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
4957 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4958 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
4959 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
4960 gpe_add_del_native_fwd_rpath_reply) \
4961 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4962 gpe_fwd_entry_path_details) \
4963 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4964 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4965 one_add_del_map_request_itr_rlocs_reply) \
4966 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4967 one_get_map_request_itr_rlocs_reply) \
4968 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
4969 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4970 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
4971 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4972 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4973 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4974 show_one_map_register_state_reply) \
4975 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
4976 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
4977 show_one_map_register_fallback_threshold_reply) \
4978 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4979 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4980 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4981 _(POLICER_DETAILS, policer_details) \
4982 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4983 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4984 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4985 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4986 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4987 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4988 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4989 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4990 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4991 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4992 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4993 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4994 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4995 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4996 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4997 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4998 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4999 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5000 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5001 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5002 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5003 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5004 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5005 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5006 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5007 ip_source_and_port_range_check_add_del_reply) \
5008 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5009 ip_source_and_port_range_check_interface_add_del_reply) \
5010 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5011 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5012 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5013 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5014 _(PUNT_REPLY, punt_reply) \
5015 _(IP_FIB_DETAILS, ip_fib_details) \
5016 _(IP6_FIB_DETAILS, ip6_fib_details) \
5017 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5018 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5019 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5020 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5021 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5022 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5023 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5024 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5025 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5026 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply)
5028 #define foreach_standalone_reply_msg \
5029 _(SW_INTERFACE_EVENT, sw_interface_event) \
5030 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5031 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5032 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5033 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5034 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5035 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
5044 #define STR_VTR_OP_CASE(op) \
5045 case L2_VTR_ ## op: \
5049 str_vtr_op (u32 vtr_op)
5053 STR_VTR_OP_CASE (DISABLED);
5054 STR_VTR_OP_CASE (PUSH_1);
5055 STR_VTR_OP_CASE (PUSH_2);
5056 STR_VTR_OP_CASE (POP_1);
5057 STR_VTR_OP_CASE (POP_2);
5058 STR_VTR_OP_CASE (TRANSLATE_1_1);
5059 STR_VTR_OP_CASE (TRANSLATE_1_2);
5060 STR_VTR_OP_CASE (TRANSLATE_2_1);
5061 STR_VTR_OP_CASE (TRANSLATE_2_2);
5068 dump_sub_interface_table (vat_main_t * vam)
5070 const sw_interface_subif_t *sub = NULL;
5072 if (vam->json_output)
5075 ("JSON output supported only for VPE API calls and dump_stats_table");
5080 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5081 "Interface", "sw_if_index",
5082 "sub id", "dot1ad", "tags", "outer id",
5083 "inner id", "exact", "default", "outer any", "inner any");
5085 vec_foreach (sub, vam->sw_if_subif_table)
5088 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5089 sub->interface_name,
5091 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5092 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5093 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5094 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5095 if (sub->vtr_op != L2_VTR_DISABLED)
5098 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5099 "tag1: %d tag2: %d ]",
5100 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5101 sub->vtr_tag1, sub->vtr_tag2);
5109 name_sort_cmp (void *a1, void *a2)
5111 name_sort_t *n1 = a1;
5112 name_sort_t *n2 = a2;
5114 return strcmp ((char *) n1->name, (char *) n2->name);
5118 dump_interface_table (vat_main_t * vam)
5121 name_sort_t *nses = 0, *ns;
5123 if (vam->json_output)
5126 ("JSON output supported only for VPE API calls and dump_stats_table");
5131 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5133 vec_add2 (nses, ns, 1);
5134 ns->name = (u8 *)(p->key);
5135 ns->value = (u32) p->value[0];
5139 vec_sort_with_function (nses, name_sort_cmp);
5141 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5142 vec_foreach (ns, nses)
5144 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5151 dump_ip_table (vat_main_t * vam, int is_ipv6)
5153 const ip_details_t *det = NULL;
5154 const ip_address_details_t *address = NULL;
5157 print (vam->ofp, "%-12s", "sw_if_index");
5159 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5166 print (vam->ofp, "%-12d", i);
5167 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5172 vec_foreach (address, det->addr)
5176 is_ipv6 ? format_ip6_address : format_ip4_address,
5177 address->ip, address->prefix_length);
5185 dump_ipv4_table (vat_main_t * vam)
5187 if (vam->json_output)
5190 ("JSON output supported only for VPE API calls and dump_stats_table");
5194 return dump_ip_table (vam, 0);
5198 dump_ipv6_table (vat_main_t * vam)
5200 if (vam->json_output)
5203 ("JSON output supported only for VPE API calls and dump_stats_table");
5207 return dump_ip_table (vam, 1);
5211 counter_type_to_str (u8 counter_type, u8 is_combined)
5215 switch (counter_type)
5217 case VNET_INTERFACE_COUNTER_DROP:
5219 case VNET_INTERFACE_COUNTER_PUNT:
5221 case VNET_INTERFACE_COUNTER_IP4:
5223 case VNET_INTERFACE_COUNTER_IP6:
5225 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5227 case VNET_INTERFACE_COUNTER_RX_MISS:
5229 case VNET_INTERFACE_COUNTER_RX_ERROR:
5231 case VNET_INTERFACE_COUNTER_TX_ERROR:
5234 return "INVALID-COUNTER-TYPE";
5239 switch (counter_type)
5241 case VNET_INTERFACE_COUNTER_RX:
5243 case VNET_INTERFACE_COUNTER_TX:
5246 return "INVALID-COUNTER-TYPE";
5252 dump_stats_table (vat_main_t * vam)
5254 vat_json_node_t node;
5255 vat_json_node_t *msg_array;
5256 vat_json_node_t *msg;
5257 vat_json_node_t *counter_array;
5258 vat_json_node_t *counter;
5259 interface_counter_t c;
5261 ip4_fib_counter_t *c4;
5262 ip6_fib_counter_t *c6;
5263 ip4_nbr_counter_t *n4;
5264 ip6_nbr_counter_t *n6;
5267 if (!vam->json_output)
5269 clib_warning ("dump_stats_table supported only in JSON format");
5273 vat_json_init_object (&node);
5275 /* interface counters */
5276 msg_array = vat_json_object_add (&node, "interface_counters");
5277 vat_json_init_array (msg_array);
5278 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5280 msg = vat_json_array_add (msg_array);
5281 vat_json_init_object (msg);
5282 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5283 (u8 *) counter_type_to_str (i, 0));
5284 vat_json_object_add_int (msg, "is_combined", 0);
5285 counter_array = vat_json_object_add (msg, "data");
5286 vat_json_init_array (counter_array);
5287 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5289 packets = vam->simple_interface_counters[i][j];
5290 vat_json_array_add_uint (counter_array, packets);
5293 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5295 msg = vat_json_array_add (msg_array);
5296 vat_json_init_object (msg);
5297 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5298 (u8 *) counter_type_to_str (i, 1));
5299 vat_json_object_add_int (msg, "is_combined", 1);
5300 counter_array = vat_json_object_add (msg, "data");
5301 vat_json_init_array (counter_array);
5302 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5304 c = vam->combined_interface_counters[i][j];
5305 counter = vat_json_array_add (counter_array);
5306 vat_json_init_object (counter);
5307 vat_json_object_add_uint (counter, "packets", c.packets);
5308 vat_json_object_add_uint (counter, "bytes", c.bytes);
5312 /* ip4 fib counters */
5313 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5314 vat_json_init_array (msg_array);
5315 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5317 msg = vat_json_array_add (msg_array);
5318 vat_json_init_object (msg);
5319 vat_json_object_add_uint (msg, "vrf_id",
5320 vam->ip4_fib_counters_vrf_id_by_index[i]);
5321 counter_array = vat_json_object_add (msg, "c");
5322 vat_json_init_array (counter_array);
5323 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
5325 counter = vat_json_array_add (counter_array);
5326 vat_json_init_object (counter);
5327 c4 = &vam->ip4_fib_counters[i][j];
5328 vat_json_object_add_ip4 (counter, "address", c4->address);
5329 vat_json_object_add_uint (counter, "address_length",
5330 c4->address_length);
5331 vat_json_object_add_uint (counter, "packets", c4->packets);
5332 vat_json_object_add_uint (counter, "bytes", c4->bytes);
5336 /* ip6 fib counters */
5337 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
5338 vat_json_init_array (msg_array);
5339 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
5341 msg = vat_json_array_add (msg_array);
5342 vat_json_init_object (msg);
5343 vat_json_object_add_uint (msg, "vrf_id",
5344 vam->ip6_fib_counters_vrf_id_by_index[i]);
5345 counter_array = vat_json_object_add (msg, "c");
5346 vat_json_init_array (counter_array);
5347 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
5349 counter = vat_json_array_add (counter_array);
5350 vat_json_init_object (counter);
5351 c6 = &vam->ip6_fib_counters[i][j];
5352 vat_json_object_add_ip6 (counter, "address", c6->address);
5353 vat_json_object_add_uint (counter, "address_length",
5354 c6->address_length);
5355 vat_json_object_add_uint (counter, "packets", c6->packets);
5356 vat_json_object_add_uint (counter, "bytes", c6->bytes);
5360 /* ip4 nbr counters */
5361 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
5362 vat_json_init_array (msg_array);
5363 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
5365 msg = vat_json_array_add (msg_array);
5366 vat_json_init_object (msg);
5367 vat_json_object_add_uint (msg, "sw_if_index", i);
5368 counter_array = vat_json_object_add (msg, "c");
5369 vat_json_init_array (counter_array);
5370 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
5372 counter = vat_json_array_add (counter_array);
5373 vat_json_init_object (counter);
5374 n4 = &vam->ip4_nbr_counters[i][j];
5375 vat_json_object_add_ip4 (counter, "address", n4->address);
5376 vat_json_object_add_uint (counter, "link-type", n4->linkt);
5377 vat_json_object_add_uint (counter, "packets", n4->packets);
5378 vat_json_object_add_uint (counter, "bytes", n4->bytes);
5382 /* ip6 nbr counters */
5383 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
5384 vat_json_init_array (msg_array);
5385 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
5387 msg = vat_json_array_add (msg_array);
5388 vat_json_init_object (msg);
5389 vat_json_object_add_uint (msg, "sw_if_index", i);
5390 counter_array = vat_json_object_add (msg, "c");
5391 vat_json_init_array (counter_array);
5392 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
5394 counter = vat_json_array_add (counter_array);
5395 vat_json_init_object (counter);
5396 n6 = &vam->ip6_nbr_counters[i][j];
5397 vat_json_object_add_ip6 (counter, "address", n6->address);
5398 vat_json_object_add_uint (counter, "packets", n6->packets);
5399 vat_json_object_add_uint (counter, "bytes", n6->bytes);
5403 vat_json_print (vam->ofp, &node);
5404 vat_json_free (&node);
5410 exec (vat_main_t * vam)
5412 api_main_t *am = &api_main;
5417 unformat_input_t *i = vam->input;
5419 if (vec_len (i->buffer) == 0)
5422 if (vam->exec_mode == 0 && unformat (i, "mode"))
5427 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5437 * Copy cmd into shared memory.
5438 * In order for the CLI command to work, it
5439 * must be a vector ending in \n, not a C-string ending
5442 pthread_mutex_lock (&am->vlib_rp->mutex);
5443 oldheap = svm_push_data_heap (am->vlib_rp);
5445 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
5446 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
5448 svm_pop_heap (oldheap);
5449 pthread_mutex_unlock (&am->vlib_rp->mutex);
5451 mp->cmd_in_shmem = pointer_to_uword (cmd);
5453 timeout = vat_time_now (vam) + 10.0;
5455 while (vat_time_now (vam) < timeout)
5457 if (vam->result_ready == 1)
5460 if (vam->shmem_result != NULL)
5461 print (vam->ofp, "%s", vam->shmem_result);
5462 pthread_mutex_lock (&am->vlib_rp->mutex);
5463 oldheap = svm_push_data_heap (am->vlib_rp);
5465 free_me = (u8 *) vam->shmem_result;
5468 svm_pop_heap (oldheap);
5469 pthread_mutex_unlock (&am->vlib_rp->mutex);
5477 * Future replacement of exec() that passes CLI buffers directly in
5478 * the API messages instead of an additional shared memory area.
5481 exec_inband (vat_main_t * vam)
5483 vl_api_cli_inband_t *mp;
5484 unformat_input_t *i = vam->input;
5487 if (vec_len (i->buffer) == 0)
5490 if (vam->exec_mode == 0 && unformat (i, "mode"))
5495 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5502 * In order for the CLI command to work, it
5503 * must be a vector ending in \n, not a C-string ending
5506 u32 len = vec_len (vam->input->buffer);
5507 M2 (CLI_INBAND, mp, len);
5508 clib_memcpy (mp->cmd, vam->input->buffer, len);
5509 mp->length = htonl (len);
5512 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
5517 api_create_loopback (vat_main_t * vam)
5519 unformat_input_t *i = vam->input;
5520 vl_api_create_loopback_t *mp;
5521 vl_api_create_loopback_instance_t *mp_lbi;
5524 u8 is_specified = 0;
5525 u32 user_instance = 0;
5528 memset (mac_address, 0, sizeof (mac_address));
5530 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5532 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5534 if (unformat (i, "instance %d", &user_instance))
5542 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5543 mp_lbi->is_specified = is_specified;
5545 mp_lbi->user_instance = htonl (user_instance);
5547 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5552 /* Construct the API message */
5553 M (CREATE_LOOPBACK, mp);
5555 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5564 api_delete_loopback (vat_main_t * vam)
5566 unformat_input_t *i = vam->input;
5567 vl_api_delete_loopback_t *mp;
5568 u32 sw_if_index = ~0;
5571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5573 if (unformat (i, "sw_if_index %d", &sw_if_index))
5579 if (sw_if_index == ~0)
5581 errmsg ("missing sw_if_index");
5585 /* Construct the API message */
5586 M (DELETE_LOOPBACK, mp);
5587 mp->sw_if_index = ntohl (sw_if_index);
5595 api_want_stats (vat_main_t * vam)
5597 unformat_input_t *i = vam->input;
5598 vl_api_want_stats_t *mp;
5602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5604 if (unformat (i, "enable"))
5606 else if (unformat (i, "disable"))
5614 errmsg ("missing enable|disable");
5619 mp->enable_disable = enable;
5627 api_want_interface_events (vat_main_t * vam)
5629 unformat_input_t *i = vam->input;
5630 vl_api_want_interface_events_t *mp;
5634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5636 if (unformat (i, "enable"))
5638 else if (unformat (i, "disable"))
5646 errmsg ("missing enable|disable");
5650 M (WANT_INTERFACE_EVENTS, mp);
5651 mp->enable_disable = enable;
5653 vam->interface_event_display = enable;
5661 /* Note: non-static, called once to set up the initial intfc table */
5663 api_sw_interface_dump (vat_main_t * vam)
5665 vl_api_sw_interface_dump_t *mp;
5666 vl_api_control_ping_t *mp_ping;
5668 name_sort_t *nses = 0, *ns;
5669 sw_interface_subif_t *sub = NULL;
5672 /* Toss the old name table */
5674 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5676 vec_add2 (nses, ns, 1);
5677 ns->name = (u8 *)(p->key);
5678 ns->value = (u32) p->value[0];
5682 hash_free (vam->sw_if_index_by_interface_name);
5684 vec_foreach (ns, nses) vec_free (ns->name);
5688 vec_foreach (sub, vam->sw_if_subif_table)
5690 vec_free (sub->interface_name);
5692 vec_free (vam->sw_if_subif_table);
5694 /* recreate the interface name hash table */
5695 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5697 /* Get list of ethernets */
5698 M (SW_INTERFACE_DUMP, mp);
5699 mp->name_filter_valid = 1;
5700 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
5703 /* and local / loopback interfaces */
5704 M (SW_INTERFACE_DUMP, mp);
5705 mp->name_filter_valid = 1;
5706 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
5709 /* and packet-generator interfaces */
5710 M (SW_INTERFACE_DUMP, mp);
5711 mp->name_filter_valid = 1;
5712 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
5715 /* and vxlan-gpe tunnel interfaces */
5716 M (SW_INTERFACE_DUMP, mp);
5717 mp->name_filter_valid = 1;
5718 strncpy ((char *) mp->name_filter, "vxlan_gpe",
5719 sizeof (mp->name_filter) - 1);
5722 /* and vxlan tunnel interfaces */
5723 M (SW_INTERFACE_DUMP, mp);
5724 mp->name_filter_valid = 1;
5725 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
5728 /* and host (af_packet) interfaces */
5729 M (SW_INTERFACE_DUMP, mp);
5730 mp->name_filter_valid = 1;
5731 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
5734 /* and l2tpv3 tunnel interfaces */
5735 M (SW_INTERFACE_DUMP, mp);
5736 mp->name_filter_valid = 1;
5737 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
5738 sizeof (mp->name_filter) - 1);
5741 /* and GRE tunnel interfaces */
5742 M (SW_INTERFACE_DUMP, mp);
5743 mp->name_filter_valid = 1;
5744 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
5747 /* and LISP-GPE interfaces */
5748 M (SW_INTERFACE_DUMP, mp);
5749 mp->name_filter_valid = 1;
5750 strncpy ((char *) mp->name_filter, "lisp_gpe",
5751 sizeof (mp->name_filter) - 1);
5754 /* and IPSEC tunnel interfaces */
5755 M (SW_INTERFACE_DUMP, mp);
5756 mp->name_filter_valid = 1;
5757 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
5760 /* Use a control ping for synchronization */
5761 M (CONTROL_PING, mp_ping);
5769 api_sw_interface_set_flags (vat_main_t * vam)
5771 unformat_input_t *i = vam->input;
5772 vl_api_sw_interface_set_flags_t *mp;
5774 u8 sw_if_index_set = 0;
5778 /* Parse args required to build the message */
5779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5781 if (unformat (i, "admin-up"))
5783 else if (unformat (i, "admin-down"))
5786 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5787 sw_if_index_set = 1;
5788 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5789 sw_if_index_set = 1;
5794 if (sw_if_index_set == 0)
5796 errmsg ("missing interface name or sw_if_index");
5800 /* Construct the API message */
5801 M (SW_INTERFACE_SET_FLAGS, mp);
5802 mp->sw_if_index = ntohl (sw_if_index);
5803 mp->admin_up_down = admin_up;
5808 /* Wait for a reply, return the good/bad news... */
5814 api_sw_interface_clear_stats (vat_main_t * vam)
5816 unformat_input_t *i = vam->input;
5817 vl_api_sw_interface_clear_stats_t *mp;
5819 u8 sw_if_index_set = 0;
5822 /* Parse args required to build the message */
5823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5825 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5826 sw_if_index_set = 1;
5827 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5828 sw_if_index_set = 1;
5833 /* Construct the API message */
5834 M (SW_INTERFACE_CLEAR_STATS, mp);
5836 if (sw_if_index_set == 1)
5837 mp->sw_if_index = ntohl (sw_if_index);
5839 mp->sw_if_index = ~0;
5844 /* Wait for a reply, return the good/bad news... */
5850 api_sw_interface_add_del_address (vat_main_t * vam)
5852 unformat_input_t *i = vam->input;
5853 vl_api_sw_interface_add_del_address_t *mp;
5855 u8 sw_if_index_set = 0;
5856 u8 is_add = 1, del_all = 0;
5857 u32 address_length = 0;
5858 u8 v4_address_set = 0;
5859 u8 v6_address_set = 0;
5860 ip4_address_t v4address;
5861 ip6_address_t v6address;
5864 /* Parse args required to build the message */
5865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5867 if (unformat (i, "del-all"))
5869 else if (unformat (i, "del"))
5872 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5873 sw_if_index_set = 1;
5874 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5875 sw_if_index_set = 1;
5876 else if (unformat (i, "%U/%d",
5877 unformat_ip4_address, &v4address, &address_length))
5879 else if (unformat (i, "%U/%d",
5880 unformat_ip6_address, &v6address, &address_length))
5886 if (sw_if_index_set == 0)
5888 errmsg ("missing interface name or sw_if_index");
5891 if (v4_address_set && v6_address_set)
5893 errmsg ("both v4 and v6 addresses set");
5896 if (!v4_address_set && !v6_address_set && !del_all)
5898 errmsg ("no addresses set");
5902 /* Construct the API message */
5903 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5905 mp->sw_if_index = ntohl (sw_if_index);
5906 mp->is_add = is_add;
5907 mp->del_all = del_all;
5911 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5915 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5917 mp->address_length = address_length;
5922 /* Wait for a reply, return good/bad news */
5928 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5930 unformat_input_t *i = vam->input;
5931 vl_api_sw_interface_set_mpls_enable_t *mp;
5933 u8 sw_if_index_set = 0;
5937 /* Parse args required to build the message */
5938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5940 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5941 sw_if_index_set = 1;
5942 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5943 sw_if_index_set = 1;
5944 else if (unformat (i, "disable"))
5946 else if (unformat (i, "dis"))
5952 if (sw_if_index_set == 0)
5954 errmsg ("missing interface name or sw_if_index");
5958 /* Construct the API message */
5959 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5961 mp->sw_if_index = ntohl (sw_if_index);
5962 mp->enable = enable;
5967 /* Wait for a reply... */
5973 api_sw_interface_set_table (vat_main_t * vam)
5975 unformat_input_t *i = vam->input;
5976 vl_api_sw_interface_set_table_t *mp;
5977 u32 sw_if_index, vrf_id = 0;
5978 u8 sw_if_index_set = 0;
5982 /* Parse args required to build the message */
5983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5985 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5986 sw_if_index_set = 1;
5987 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5988 sw_if_index_set = 1;
5989 else if (unformat (i, "vrf %d", &vrf_id))
5991 else if (unformat (i, "ipv6"))
5997 if (sw_if_index_set == 0)
5999 errmsg ("missing interface name or sw_if_index");
6003 /* Construct the API message */
6004 M (SW_INTERFACE_SET_TABLE, mp);
6006 mp->sw_if_index = ntohl (sw_if_index);
6007 mp->is_ipv6 = is_ipv6;
6008 mp->vrf_id = ntohl (vrf_id);
6013 /* Wait for a reply... */
6018 static void vl_api_sw_interface_get_table_reply_t_handler
6019 (vl_api_sw_interface_get_table_reply_t * mp)
6021 vat_main_t *vam = &vat_main;
6023 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6025 vam->retval = ntohl (mp->retval);
6026 vam->result_ready = 1;
6030 static void vl_api_sw_interface_get_table_reply_t_handler_json
6031 (vl_api_sw_interface_get_table_reply_t * mp)
6033 vat_main_t *vam = &vat_main;
6034 vat_json_node_t node;
6036 vat_json_init_object (&node);
6037 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6038 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6040 vat_json_print (vam->ofp, &node);
6041 vat_json_free (&node);
6043 vam->retval = ntohl (mp->retval);
6044 vam->result_ready = 1;
6048 api_sw_interface_get_table (vat_main_t * vam)
6050 unformat_input_t *i = vam->input;
6051 vl_api_sw_interface_get_table_t *mp;
6053 u8 sw_if_index_set = 0;
6057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6059 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6060 sw_if_index_set = 1;
6061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6062 sw_if_index_set = 1;
6063 else if (unformat (i, "ipv6"))
6069 if (sw_if_index_set == 0)
6071 errmsg ("missing interface name or sw_if_index");
6075 M (SW_INTERFACE_GET_TABLE, mp);
6076 mp->sw_if_index = htonl (sw_if_index);
6077 mp->is_ipv6 = is_ipv6;
6085 api_sw_interface_set_vpath (vat_main_t * vam)
6087 unformat_input_t *i = vam->input;
6088 vl_api_sw_interface_set_vpath_t *mp;
6089 u32 sw_if_index = 0;
6090 u8 sw_if_index_set = 0;
6094 /* Parse args required to build the message */
6095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6098 sw_if_index_set = 1;
6099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6100 sw_if_index_set = 1;
6101 else if (unformat (i, "enable"))
6103 else if (unformat (i, "disable"))
6109 if (sw_if_index_set == 0)
6111 errmsg ("missing interface name or sw_if_index");
6115 /* Construct the API message */
6116 M (SW_INTERFACE_SET_VPATH, mp);
6118 mp->sw_if_index = ntohl (sw_if_index);
6119 mp->enable = is_enable;
6124 /* Wait for a reply... */
6130 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6132 unformat_input_t *i = vam->input;
6133 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6134 u32 sw_if_index = 0;
6135 u8 sw_if_index_set = 0;
6140 /* Parse args required to build the message */
6141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6143 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6144 sw_if_index_set = 1;
6145 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6146 sw_if_index_set = 1;
6147 else if (unformat (i, "enable"))
6149 else if (unformat (i, "disable"))
6151 else if (unformat (i, "ip4"))
6153 else if (unformat (i, "ip6"))
6159 if (sw_if_index_set == 0)
6161 errmsg ("missing interface name or sw_if_index");
6165 /* Construct the API message */
6166 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6168 mp->sw_if_index = ntohl (sw_if_index);
6169 mp->enable = is_enable;
6170 mp->is_ipv6 = is_ipv6;
6175 /* Wait for a reply... */
6182 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6184 unformat_input_t *i = vam->input;
6185 vl_api_sw_interface_set_l2_xconnect_t *mp;
6187 u8 rx_sw_if_index_set = 0;
6189 u8 tx_sw_if_index_set = 0;
6193 /* Parse args required to build the message */
6194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6196 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6197 rx_sw_if_index_set = 1;
6198 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6199 tx_sw_if_index_set = 1;
6200 else if (unformat (i, "rx"))
6202 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6204 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6206 rx_sw_if_index_set = 1;
6211 else if (unformat (i, "tx"))
6213 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6215 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6217 tx_sw_if_index_set = 1;
6222 else if (unformat (i, "enable"))
6224 else if (unformat (i, "disable"))
6230 if (rx_sw_if_index_set == 0)
6232 errmsg ("missing rx interface name or rx_sw_if_index");
6236 if (enable && (tx_sw_if_index_set == 0))
6238 errmsg ("missing tx interface name or tx_sw_if_index");
6242 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6244 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6245 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6246 mp->enable = enable;
6254 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6256 unformat_input_t *i = vam->input;
6257 vl_api_sw_interface_set_l2_bridge_t *mp;
6259 u8 rx_sw_if_index_set = 0;
6267 /* Parse args required to build the message */
6268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6270 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6271 rx_sw_if_index_set = 1;
6272 else if (unformat (i, "bd_id %d", &bd_id))
6276 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6277 rx_sw_if_index_set = 1;
6278 else if (unformat (i, "shg %d", &shg))
6280 else if (unformat (i, "bvi"))
6282 else if (unformat (i, "enable"))
6284 else if (unformat (i, "disable"))
6290 if (rx_sw_if_index_set == 0)
6292 errmsg ("missing rx interface name or sw_if_index");
6296 if (enable && (bd_id_set == 0))
6298 errmsg ("missing bridge domain");
6302 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6304 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6305 mp->bd_id = ntohl (bd_id);
6308 mp->enable = enable;
6316 api_bridge_domain_dump (vat_main_t * vam)
6318 unformat_input_t *i = vam->input;
6319 vl_api_bridge_domain_dump_t *mp;
6320 vl_api_control_ping_t *mp_ping;
6324 /* Parse args required to build the message */
6325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6327 if (unformat (i, "bd_id %d", &bd_id))
6333 M (BRIDGE_DOMAIN_DUMP, mp);
6334 mp->bd_id = ntohl (bd_id);
6337 /* Use a control ping for synchronization */
6338 M (CONTROL_PING, mp_ping);
6346 api_bridge_domain_add_del (vat_main_t * vam)
6348 unformat_input_t *i = vam->input;
6349 vl_api_bridge_domain_add_del_t *mp;
6352 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6356 /* Parse args required to build the message */
6357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6359 if (unformat (i, "bd_id %d", &bd_id))
6361 else if (unformat (i, "flood %d", &flood))
6363 else if (unformat (i, "uu-flood %d", &uu_flood))
6365 else if (unformat (i, "forward %d", &forward))
6367 else if (unformat (i, "learn %d", &learn))
6369 else if (unformat (i, "arp-term %d", &arp_term))
6371 else if (unformat (i, "mac-age %d", &mac_age))
6373 else if (unformat (i, "del"))
6376 flood = uu_flood = forward = learn = 0;
6384 errmsg ("missing bridge domain");
6390 errmsg ("mac age must be less than 256 ");
6394 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6396 mp->bd_id = ntohl (bd_id);
6398 mp->uu_flood = uu_flood;
6399 mp->forward = forward;
6401 mp->arp_term = arp_term;
6402 mp->is_add = is_add;
6403 mp->mac_age = (u8) mac_age;
6411 api_l2fib_flush_bd (vat_main_t * vam)
6413 unformat_input_t *i = vam->input;
6414 vl_api_l2fib_flush_bd_t *mp;
6418 /* Parse args required to build the message */
6419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6421 if (unformat (i, "bd_id %d", &bd_id));
6428 errmsg ("missing bridge domain");
6432 M (L2FIB_FLUSH_BD, mp);
6434 mp->bd_id = htonl (bd_id);
6442 api_l2fib_flush_int (vat_main_t * vam)
6444 unformat_input_t *i = vam->input;
6445 vl_api_l2fib_flush_int_t *mp;
6446 u32 sw_if_index = ~0;
6449 /* Parse args required to build the message */
6450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6452 if (unformat (i, "sw_if_index %d", &sw_if_index));
6454 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6459 if (sw_if_index == ~0)
6461 errmsg ("missing interface name or sw_if_index");
6465 M (L2FIB_FLUSH_INT, mp);
6467 mp->sw_if_index = ntohl (sw_if_index);
6475 api_l2fib_add_del (vat_main_t * vam)
6477 unformat_input_t *i = vam->input;
6478 vl_api_l2fib_add_del_t *mp;
6484 u32 sw_if_index = ~0;
6485 u8 sw_if_index_set = 0;
6494 /* Parse args required to build the message */
6495 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6497 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
6499 else if (unformat (i, "bd_id %d", &bd_id))
6501 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6502 sw_if_index_set = 1;
6503 else if (unformat (i, "sw_if"))
6505 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6508 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6509 sw_if_index_set = 1;
6514 else if (unformat (i, "static"))
6516 else if (unformat (i, "filter"))
6521 else if (unformat (i, "bvi"))
6526 else if (unformat (i, "del"))
6528 else if (unformat (i, "count %d", &count))
6536 errmsg ("missing mac address");
6542 errmsg ("missing bridge domain");
6546 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6548 errmsg ("missing interface name or sw_if_index");
6554 /* Turn on async mode */
6555 vam->async_mode = 1;
6556 vam->async_errors = 0;
6557 before = vat_time_now (vam);
6560 for (j = 0; j < count; j++)
6562 M (L2FIB_ADD_DEL, mp);
6565 mp->bd_id = ntohl (bd_id);
6566 mp->is_add = is_add;
6570 mp->sw_if_index = ntohl (sw_if_index);
6571 mp->static_mac = static_mac;
6572 mp->filter_mac = filter_mac;
6573 mp->bvi_mac = bvi_mac;
6575 increment_mac_address (&mac);
6582 vl_api_control_ping_t *mp_ping;
6585 /* Shut off async mode */
6586 vam->async_mode = 0;
6588 M (CONTROL_PING, mp_ping);
6591 timeout = vat_time_now (vam) + 1.0;
6592 while (vat_time_now (vam) < timeout)
6593 if (vam->result_ready == 1)
6598 if (vam->retval == -99)
6601 if (vam->async_errors > 0)
6603 errmsg ("%d asynchronous errors", vam->async_errors);
6606 vam->async_errors = 0;
6607 after = vat_time_now (vam);
6609 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6610 count, after - before, count / (after - before));
6616 /* Wait for a reply... */
6620 /* Return the good/bad news */
6621 return (vam->retval);
6625 api_bridge_domain_set_mac_age (vat_main_t * vam)
6627 unformat_input_t *i = vam->input;
6628 vl_api_bridge_domain_set_mac_age_t *mp;
6633 /* Parse args required to build the message */
6634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6636 if (unformat (i, "bd_id %d", &bd_id));
6637 else if (unformat (i, "mac-age %d", &mac_age));
6644 errmsg ("missing bridge domain");
6650 errmsg ("mac age must be less than 256 ");
6654 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6656 mp->bd_id = htonl (bd_id);
6657 mp->mac_age = (u8) mac_age;
6665 api_l2_flags (vat_main_t * vam)
6667 unformat_input_t *i = vam->input;
6668 vl_api_l2_flags_t *mp;
6671 u8 sw_if_index_set = 0;
6675 /* Parse args required to build the message */
6676 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6678 if (unformat (i, "sw_if_index %d", &sw_if_index))
6679 sw_if_index_set = 1;
6680 else if (unformat (i, "sw_if"))
6682 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6685 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6686 sw_if_index_set = 1;
6691 else if (unformat (i, "learn"))
6693 else if (unformat (i, "forward"))
6695 else if (unformat (i, "flood"))
6697 else if (unformat (i, "uu-flood"))
6698 flags |= L2_UU_FLOOD;
6699 else if (unformat (i, "arp-term"))
6700 flags |= L2_ARP_TERM;
6701 else if (unformat (i, "off"))
6703 else if (unformat (i, "disable"))
6709 if (sw_if_index_set == 0)
6711 errmsg ("missing interface name or sw_if_index");
6717 mp->sw_if_index = ntohl (sw_if_index);
6718 mp->feature_bitmap = ntohl (flags);
6719 mp->is_set = is_set;
6727 api_bridge_flags (vat_main_t * vam)
6729 unformat_input_t *i = vam->input;
6730 vl_api_bridge_flags_t *mp;
6737 /* Parse args required to build the message */
6738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6740 if (unformat (i, "bd_id %d", &bd_id))
6742 else if (unformat (i, "learn"))
6744 else if (unformat (i, "forward"))
6746 else if (unformat (i, "flood"))
6748 else if (unformat (i, "uu-flood"))
6749 flags |= L2_UU_FLOOD;
6750 else if (unformat (i, "arp-term"))
6751 flags |= L2_ARP_TERM;
6752 else if (unformat (i, "off"))
6754 else if (unformat (i, "disable"))
6762 errmsg ("missing bridge domain");
6766 M (BRIDGE_FLAGS, mp);
6768 mp->bd_id = ntohl (bd_id);
6769 mp->feature_bitmap = ntohl (flags);
6770 mp->is_set = is_set;
6778 api_bd_ip_mac_add_del (vat_main_t * vam)
6780 unformat_input_t *i = vam->input;
6781 vl_api_bd_ip_mac_add_del_t *mp;
6788 ip4_address_t v4addr;
6789 ip6_address_t v6addr;
6794 /* Parse args required to build the message */
6795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6797 if (unformat (i, "bd_id %d", &bd_id))
6801 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6805 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6810 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6814 else if (unformat (i, "del"))
6822 errmsg ("missing bridge domain");
6825 else if (ip_set == 0)
6827 errmsg ("missing IP address");
6830 else if (mac_set == 0)
6832 errmsg ("missing MAC address");
6836 M (BD_IP_MAC_ADD_DEL, mp);
6838 mp->bd_id = ntohl (bd_id);
6839 mp->is_ipv6 = is_ipv6;
6840 mp->is_add = is_add;
6842 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6844 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6845 clib_memcpy (mp->mac_address, macaddr, 6);
6852 api_tap_connect (vat_main_t * vam)
6854 unformat_input_t *i = vam->input;
6855 vl_api_tap_connect_t *mp;
6861 ip4_address_t ip4_address;
6863 int ip4_address_set = 0;
6864 ip6_address_t ip6_address;
6866 int ip6_address_set = 0;
6869 memset (mac_address, 0, sizeof (mac_address));
6871 /* Parse args required to build the message */
6872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6874 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6878 else if (unformat (i, "random-mac"))
6880 else if (unformat (i, "tapname %s", &tap_name))
6882 else if (unformat (i, "tag %s", &tag))
6884 else if (unformat (i, "address %U/%d",
6885 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6886 ip4_address_set = 1;
6887 else if (unformat (i, "address %U/%d",
6888 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6889 ip6_address_set = 1;
6896 errmsg ("missing tap name");
6899 if (vec_len (tap_name) > 63)
6901 errmsg ("tap name too long");
6904 vec_add1 (tap_name, 0);
6906 if (vec_len (tag) > 63)
6908 errmsg ("tag too long");
6912 /* Construct the API message */
6913 M (TAP_CONNECT, mp);
6915 mp->use_random_mac = random_mac;
6916 clib_memcpy (mp->mac_address, mac_address, 6);
6917 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6919 clib_memcpy (mp->tag, tag, vec_len (tag));
6921 if (ip4_address_set)
6923 mp->ip4_address_set = 1;
6924 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6925 mp->ip4_mask_width = ip4_mask_width;
6927 if (ip6_address_set)
6929 mp->ip6_address_set = 1;
6930 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6931 mp->ip6_mask_width = ip6_mask_width;
6934 vec_free (tap_name);
6940 /* Wait for a reply... */
6946 api_tap_modify (vat_main_t * vam)
6948 unformat_input_t *i = vam->input;
6949 vl_api_tap_modify_t *mp;
6954 u32 sw_if_index = ~0;
6955 u8 sw_if_index_set = 0;
6958 memset (mac_address, 0, sizeof (mac_address));
6960 /* Parse args required to build the message */
6961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6963 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6964 sw_if_index_set = 1;
6965 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6966 sw_if_index_set = 1;
6967 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6971 else if (unformat (i, "random-mac"))
6973 else if (unformat (i, "tapname %s", &tap_name))
6979 if (sw_if_index_set == 0)
6981 errmsg ("missing vpp interface name");
6986 errmsg ("missing tap name");
6989 if (vec_len (tap_name) > 63)
6991 errmsg ("tap name too long");
6993 vec_add1 (tap_name, 0);
6995 /* Construct the API message */
6998 mp->use_random_mac = random_mac;
6999 mp->sw_if_index = ntohl (sw_if_index);
7000 clib_memcpy (mp->mac_address, mac_address, 6);
7001 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7002 vec_free (tap_name);
7007 /* Wait for a reply... */
7013 api_tap_delete (vat_main_t * vam)
7015 unformat_input_t *i = vam->input;
7016 vl_api_tap_delete_t *mp;
7017 u32 sw_if_index = ~0;
7018 u8 sw_if_index_set = 0;
7021 /* Parse args required to build the message */
7022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7024 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7025 sw_if_index_set = 1;
7026 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7027 sw_if_index_set = 1;
7032 if (sw_if_index_set == 0)
7034 errmsg ("missing vpp interface name");
7038 /* Construct the API message */
7041 mp->sw_if_index = ntohl (sw_if_index);
7046 /* Wait for a reply... */
7052 api_ip_add_del_route (vat_main_t * vam)
7054 unformat_input_t *i = vam->input;
7055 vl_api_ip_add_del_route_t *mp;
7056 u32 sw_if_index = ~0, vrf_id = 0;
7058 u8 is_local = 0, is_drop = 0;
7059 u8 is_unreach = 0, is_prohibit = 0;
7060 u8 create_vrf_if_needed = 0;
7062 u32 next_hop_weight = 1;
7064 u8 is_multipath = 0;
7066 u8 address_length_set = 0;
7067 u32 next_hop_table_id = 0;
7068 u32 resolve_attempts = 0;
7069 u32 dst_address_length = 0;
7070 u8 next_hop_set = 0;
7071 ip4_address_t v4_dst_address, v4_next_hop_address;
7072 ip6_address_t v6_dst_address, v6_next_hop_address;
7076 u32 random_add_del = 0;
7077 u32 *random_vector = 0;
7079 u32 random_seed = 0xdeaddabe;
7080 u32 classify_table_index = ~0;
7082 u8 resolve_host = 0, resolve_attached = 0;
7083 mpls_label_t *next_hop_out_label_stack = NULL;
7084 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7085 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7087 /* Parse args required to build the message */
7088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7090 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7094 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
7099 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
7104 else if (unformat (i, "/%d", &dst_address_length))
7106 address_length_set = 1;
7109 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
7110 &v4_next_hop_address))
7114 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
7115 &v6_next_hop_address))
7119 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
7121 else if (unformat (i, "weight %d", &next_hop_weight))
7123 else if (unformat (i, "drop"))
7127 else if (unformat (i, "null-send-unreach"))
7131 else if (unformat (i, "null-send-prohibit"))
7135 else if (unformat (i, "local"))
7139 else if (unformat (i, "classify %d", &classify_table_index))
7143 else if (unformat (i, "del"))
7145 else if (unformat (i, "add"))
7147 else if (unformat (i, "not-last"))
7149 else if (unformat (i, "resolve-via-host"))
7151 else if (unformat (i, "resolve-via-attached"))
7152 resolve_attached = 1;
7153 else if (unformat (i, "multipath"))
7155 else if (unformat (i, "vrf %d", &vrf_id))
7157 else if (unformat (i, "create-vrf"))
7158 create_vrf_if_needed = 1;
7159 else if (unformat (i, "count %d", &count))
7161 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
7163 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7165 else if (unformat (i, "out-label %d", &next_hop_out_label))
7166 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7167 else if (unformat (i, "via-label %d", &next_hop_via_label))
7169 else if (unformat (i, "random"))
7171 else if (unformat (i, "seed %d", &random_seed))
7175 clib_warning ("parse error '%U'", format_unformat_error, i);
7180 if (!next_hop_set && !is_drop && !is_local &&
7181 !is_classify && !is_unreach && !is_prohibit &&
7182 MPLS_LABEL_INVALID == next_hop_via_label)
7185 ("next hop / local / drop / unreach / prohibit / classify not set");
7189 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
7191 errmsg ("next hop and next-hop via label set");
7194 if (address_set == 0)
7196 errmsg ("missing addresses");
7200 if (address_length_set == 0)
7202 errmsg ("missing address length");
7206 /* Generate a pile of unique, random routes */
7209 u32 this_random_address;
7210 random_hash = hash_create (count, sizeof (uword));
7212 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
7213 for (j = 0; j <= count; j++)
7217 this_random_address = random_u32 (&random_seed);
7218 this_random_address =
7219 clib_host_to_net_u32 (this_random_address);
7221 while (hash_get (random_hash, this_random_address));
7222 vec_add1 (random_vector, this_random_address);
7223 hash_set (random_hash, this_random_address, 1);
7225 hash_free (random_hash);
7226 v4_dst_address.as_u32 = random_vector[0];
7231 /* Turn on async mode */
7232 vam->async_mode = 1;
7233 vam->async_errors = 0;
7234 before = vat_time_now (vam);
7237 for (j = 0; j < count; j++)
7239 /* Construct the API message */
7240 M2 (IP_ADD_DEL_ROUTE, mp,
7241 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7243 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7244 mp->table_id = ntohl (vrf_id);
7245 mp->create_vrf_if_needed = create_vrf_if_needed;
7247 mp->is_add = is_add;
7248 mp->is_drop = is_drop;
7249 mp->is_unreach = is_unreach;
7250 mp->is_prohibit = is_prohibit;
7251 mp->is_ipv6 = is_ipv6;
7252 mp->is_local = is_local;
7253 mp->is_classify = is_classify;
7254 mp->is_multipath = is_multipath;
7255 mp->is_resolve_host = resolve_host;
7256 mp->is_resolve_attached = resolve_attached;
7257 mp->not_last = not_last;
7258 mp->next_hop_weight = next_hop_weight;
7259 mp->dst_address_length = dst_address_length;
7260 mp->next_hop_table_id = ntohl (next_hop_table_id);
7261 mp->classify_table_index = ntohl (classify_table_index);
7262 mp->next_hop_via_label = ntohl (next_hop_via_label);
7263 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7264 if (0 != mp->next_hop_n_out_labels)
7266 memcpy (mp->next_hop_out_label_stack,
7267 next_hop_out_label_stack,
7268 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7269 vec_free (next_hop_out_label_stack);
7274 clib_memcpy (mp->dst_address, &v6_dst_address,
7275 sizeof (v6_dst_address));
7277 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
7278 sizeof (v6_next_hop_address));
7279 increment_v6_address (&v6_dst_address);
7283 clib_memcpy (mp->dst_address, &v4_dst_address,
7284 sizeof (v4_dst_address));
7286 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
7287 sizeof (v4_next_hop_address));
7289 v4_dst_address.as_u32 = random_vector[j + 1];
7291 increment_v4_address (&v4_dst_address);
7295 /* If we receive SIGTERM, stop now... */
7300 /* When testing multiple add/del ops, use a control-ping to sync */
7303 vl_api_control_ping_t *mp_ping;
7307 /* Shut off async mode */
7308 vam->async_mode = 0;
7310 M (CONTROL_PING, mp_ping);
7313 timeout = vat_time_now (vam) + 1.0;
7314 while (vat_time_now (vam) < timeout)
7315 if (vam->result_ready == 1)
7320 if (vam->retval == -99)
7323 if (vam->async_errors > 0)
7325 errmsg ("%d asynchronous errors", vam->async_errors);
7328 vam->async_errors = 0;
7329 after = vat_time_now (vam);
7331 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7335 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7336 count, after - before, count / (after - before));
7342 /* Wait for a reply... */
7347 /* Return the good/bad news */
7348 return (vam->retval);
7352 api_ip_mroute_add_del (vat_main_t * vam)
7354 unformat_input_t *i = vam->input;
7355 vl_api_ip_mroute_add_del_t *mp;
7356 u32 sw_if_index = ~0, vrf_id = 0;
7359 u8 create_vrf_if_needed = 0;
7362 u32 grp_address_length = 0;
7363 ip4_address_t v4_grp_address, v4_src_address;
7364 ip6_address_t v6_grp_address, v6_src_address;
7365 mfib_itf_flags_t iflags = 0;
7366 mfib_entry_flags_t eflags = 0;
7369 /* Parse args required to build the message */
7370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7372 if (unformat (i, "sw_if_index %d", &sw_if_index))
7374 else if (unformat (i, "%U %U",
7375 unformat_ip4_address, &v4_src_address,
7376 unformat_ip4_address, &v4_grp_address))
7378 grp_address_length = 64;
7382 else if (unformat (i, "%U %U",
7383 unformat_ip6_address, &v6_src_address,
7384 unformat_ip6_address, &v6_grp_address))
7386 grp_address_length = 256;
7390 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
7392 memset (&v4_src_address, 0, sizeof (v4_src_address));
7393 grp_address_length = 32;
7397 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
7399 memset (&v6_src_address, 0, sizeof (v6_src_address));
7400 grp_address_length = 128;
7404 else if (unformat (i, "/%d", &grp_address_length))
7406 else if (unformat (i, "local"))
7410 else if (unformat (i, "del"))
7412 else if (unformat (i, "add"))
7414 else if (unformat (i, "vrf %d", &vrf_id))
7416 else if (unformat (i, "create-vrf"))
7417 create_vrf_if_needed = 1;
7418 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
7420 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
7424 clib_warning ("parse error '%U'", format_unformat_error, i);
7429 if (address_set == 0)
7431 errmsg ("missing addresses\n");
7435 /* Construct the API message */
7436 M (IP_MROUTE_ADD_DEL, mp);
7438 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7439 mp->table_id = ntohl (vrf_id);
7440 mp->create_vrf_if_needed = create_vrf_if_needed;
7442 mp->is_add = is_add;
7443 mp->is_ipv6 = is_ipv6;
7444 mp->is_local = is_local;
7445 mp->itf_flags = ntohl (iflags);
7446 mp->entry_flags = ntohl (eflags);
7447 mp->grp_address_length = grp_address_length;
7448 mp->grp_address_length = ntohs (mp->grp_address_length);
7452 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
7453 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
7457 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
7458 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
7464 /* Wait for a reply... */
7470 api_mpls_route_add_del (vat_main_t * vam)
7472 unformat_input_t *i = vam->input;
7473 vl_api_mpls_route_add_del_t *mp;
7474 u32 sw_if_index = ~0, table_id = 0;
7475 u8 create_table_if_needed = 0;
7477 u32 next_hop_weight = 1;
7478 u8 is_multipath = 0;
7479 u32 next_hop_table_id = 0;
7480 u8 next_hop_set = 0;
7481 ip4_address_t v4_next_hop_address = {
7484 ip6_address_t v6_next_hop_address = { {0} };
7488 u32 classify_table_index = ~0;
7490 u8 resolve_host = 0, resolve_attached = 0;
7491 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7492 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7493 mpls_label_t *next_hop_out_label_stack = NULL;
7494 mpls_label_t local_label = MPLS_LABEL_INVALID;
7496 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
7498 /* Parse args required to build the message */
7499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7501 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7503 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7505 else if (unformat (i, "%d", &local_label))
7507 else if (unformat (i, "eos"))
7509 else if (unformat (i, "non-eos"))
7511 else if (unformat (i, "via %U", unformat_ip4_address,
7512 &v4_next_hop_address))
7515 next_hop_proto = DPO_PROTO_IP4;
7517 else if (unformat (i, "via %U", unformat_ip6_address,
7518 &v6_next_hop_address))
7521 next_hop_proto = DPO_PROTO_IP6;
7523 else if (unformat (i, "weight %d", &next_hop_weight))
7525 else if (unformat (i, "create-table"))
7526 create_table_if_needed = 1;
7527 else if (unformat (i, "classify %d", &classify_table_index))
7531 else if (unformat (i, "del"))
7533 else if (unformat (i, "add"))
7535 else if (unformat (i, "resolve-via-host"))
7537 else if (unformat (i, "resolve-via-attached"))
7538 resolve_attached = 1;
7539 else if (unformat (i, "multipath"))
7541 else if (unformat (i, "count %d", &count))
7543 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
7546 next_hop_proto = DPO_PROTO_IP4;
7548 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
7551 next_hop_proto = DPO_PROTO_IP6;
7553 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7555 else if (unformat (i, "via-label %d", &next_hop_via_label))
7557 else if (unformat (i, "out-label %d", &next_hop_out_label))
7558 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7561 clib_warning ("parse error '%U'", format_unformat_error, i);
7566 if (!next_hop_set && !is_classify)
7568 errmsg ("next hop / classify not set");
7572 if (MPLS_LABEL_INVALID == local_label)
7574 errmsg ("missing label");
7580 /* Turn on async mode */
7581 vam->async_mode = 1;
7582 vam->async_errors = 0;
7583 before = vat_time_now (vam);
7586 for (j = 0; j < count; j++)
7588 /* Construct the API message */
7589 M2 (MPLS_ROUTE_ADD_DEL, mp,
7590 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7592 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
7593 mp->mr_table_id = ntohl (table_id);
7594 mp->mr_create_table_if_needed = create_table_if_needed;
7596 mp->mr_is_add = is_add;
7597 mp->mr_next_hop_proto = next_hop_proto;
7598 mp->mr_is_classify = is_classify;
7599 mp->mr_is_multipath = is_multipath;
7600 mp->mr_is_resolve_host = resolve_host;
7601 mp->mr_is_resolve_attached = resolve_attached;
7602 mp->mr_next_hop_weight = next_hop_weight;
7603 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
7604 mp->mr_classify_table_index = ntohl (classify_table_index);
7605 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
7606 mp->mr_label = ntohl (local_label);
7607 mp->mr_eos = is_eos;
7609 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7610 if (0 != mp->mr_next_hop_n_out_labels)
7612 memcpy (mp->mr_next_hop_out_label_stack,
7613 next_hop_out_label_stack,
7614 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7615 vec_free (next_hop_out_label_stack);
7620 if (DPO_PROTO_IP4 == next_hop_proto)
7622 clib_memcpy (mp->mr_next_hop,
7623 &v4_next_hop_address,
7624 sizeof (v4_next_hop_address));
7626 else if (DPO_PROTO_IP6 == next_hop_proto)
7629 clib_memcpy (mp->mr_next_hop,
7630 &v6_next_hop_address,
7631 sizeof (v6_next_hop_address));
7638 /* If we receive SIGTERM, stop now... */
7643 /* When testing multiple add/del ops, use a control-ping to sync */
7646 vl_api_control_ping_t *mp_ping;
7650 /* Shut off async mode */
7651 vam->async_mode = 0;
7653 M (CONTROL_PING, mp_ping);
7656 timeout = vat_time_now (vam) + 1.0;
7657 while (vat_time_now (vam) < timeout)
7658 if (vam->result_ready == 1)
7663 if (vam->retval == -99)
7666 if (vam->async_errors > 0)
7668 errmsg ("%d asynchronous errors", vam->async_errors);
7671 vam->async_errors = 0;
7672 after = vat_time_now (vam);
7674 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7678 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7679 count, after - before, count / (after - before));
7685 /* Wait for a reply... */
7690 /* Return the good/bad news */
7691 return (vam->retval);
7695 api_mpls_ip_bind_unbind (vat_main_t * vam)
7697 unformat_input_t *i = vam->input;
7698 vl_api_mpls_ip_bind_unbind_t *mp;
7699 u32 ip_table_id = 0;
7700 u8 create_table_if_needed = 0;
7703 ip4_address_t v4_address;
7704 ip6_address_t v6_address;
7707 mpls_label_t local_label = MPLS_LABEL_INVALID;
7710 /* Parse args required to build the message */
7711 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7713 if (unformat (i, "%U/%d", unformat_ip4_address,
7714 &v4_address, &address_length))
7719 else if (unformat (i, "%U/%d", unformat_ip6_address,
7720 &v6_address, &address_length))
7725 else if (unformat (i, "%d", &local_label))
7727 else if (unformat (i, "create-table"))
7728 create_table_if_needed = 1;
7729 else if (unformat (i, "table-id %d", &ip_table_id))
7731 else if (unformat (i, "unbind"))
7733 else if (unformat (i, "bind"))
7737 clib_warning ("parse error '%U'", format_unformat_error, i);
7744 errmsg ("IP addres not set");
7748 if (MPLS_LABEL_INVALID == local_label)
7750 errmsg ("missing label");
7754 /* Construct the API message */
7755 M (MPLS_IP_BIND_UNBIND, mp);
7757 mp->mb_create_table_if_needed = create_table_if_needed;
7758 mp->mb_is_bind = is_bind;
7759 mp->mb_is_ip4 = is_ip4;
7760 mp->mb_ip_table_id = ntohl (ip_table_id);
7761 mp->mb_mpls_table_id = 0;
7762 mp->mb_label = ntohl (local_label);
7763 mp->mb_address_length = address_length;
7766 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7768 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7773 /* Wait for a reply... */
7779 api_proxy_arp_add_del (vat_main_t * vam)
7781 unformat_input_t *i = vam->input;
7782 vl_api_proxy_arp_add_del_t *mp;
7785 ip4_address_t lo, hi;
7789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7791 if (unformat (i, "vrf %d", &vrf_id))
7793 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7794 unformat_ip4_address, &hi))
7796 else if (unformat (i, "del"))
7800 clib_warning ("parse error '%U'", format_unformat_error, i);
7807 errmsg ("address range not set");
7811 M (PROXY_ARP_ADD_DEL, mp);
7813 mp->vrf_id = ntohl (vrf_id);
7814 mp->is_add = is_add;
7815 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7816 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7824 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7826 unformat_input_t *i = vam->input;
7827 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7830 u8 sw_if_index_set = 0;
7833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7835 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7836 sw_if_index_set = 1;
7837 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7838 sw_if_index_set = 1;
7839 else if (unformat (i, "enable"))
7841 else if (unformat (i, "disable"))
7845 clib_warning ("parse error '%U'", format_unformat_error, i);
7850 if (sw_if_index_set == 0)
7852 errmsg ("missing interface name or sw_if_index");
7856 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7858 mp->sw_if_index = ntohl (sw_if_index);
7859 mp->enable_disable = enable;
7867 api_mpls_tunnel_add_del (vat_main_t * vam)
7869 unformat_input_t *i = vam->input;
7870 vl_api_mpls_tunnel_add_del_t *mp;
7874 u32 sw_if_index = ~0;
7875 u32 next_hop_sw_if_index = ~0;
7876 u32 next_hop_proto_is_ip4 = 1;
7878 u32 next_hop_table_id = 0;
7879 ip4_address_t v4_next_hop_address = {
7882 ip6_address_t v6_next_hop_address = { {0} };
7883 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7888 if (unformat (i, "add"))
7890 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7892 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7894 else if (unformat (i, "via %U",
7895 unformat_ip4_address, &v4_next_hop_address))
7897 next_hop_proto_is_ip4 = 1;
7899 else if (unformat (i, "via %U",
7900 unformat_ip6_address, &v6_next_hop_address))
7902 next_hop_proto_is_ip4 = 0;
7904 else if (unformat (i, "l2-only"))
7906 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7908 else if (unformat (i, "out-label %d", &next_hop_out_label))
7909 vec_add1 (labels, ntohl (next_hop_out_label));
7912 clib_warning ("parse error '%U'", format_unformat_error, i);
7917 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7919 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7920 mp->mt_sw_if_index = ntohl (sw_if_index);
7921 mp->mt_is_add = is_add;
7922 mp->mt_l2_only = l2_only;
7923 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7924 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7926 mp->mt_next_hop_n_out_labels = vec_len (labels);
7928 if (0 != mp->mt_next_hop_n_out_labels)
7930 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7931 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7935 if (next_hop_proto_is_ip4)
7937 clib_memcpy (mp->mt_next_hop,
7938 &v4_next_hop_address, sizeof (v4_next_hop_address));
7942 clib_memcpy (mp->mt_next_hop,
7943 &v6_next_hop_address, sizeof (v6_next_hop_address));
7952 api_sw_interface_set_unnumbered (vat_main_t * vam)
7954 unformat_input_t *i = vam->input;
7955 vl_api_sw_interface_set_unnumbered_t *mp;
7957 u32 unnum_sw_index = ~0;
7959 u8 sw_if_index_set = 0;
7962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7964 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7965 sw_if_index_set = 1;
7966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7967 sw_if_index_set = 1;
7968 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7970 else if (unformat (i, "del"))
7974 clib_warning ("parse error '%U'", format_unformat_error, i);
7979 if (sw_if_index_set == 0)
7981 errmsg ("missing interface name or sw_if_index");
7985 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7987 mp->sw_if_index = ntohl (sw_if_index);
7988 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7989 mp->is_add = is_add;
7997 api_ip_neighbor_add_del (vat_main_t * vam)
7999 unformat_input_t *i = vam->input;
8000 vl_api_ip_neighbor_add_del_t *mp;
8002 u8 sw_if_index_set = 0;
8005 u8 is_no_fib_entry = 0;
8008 u8 v4_address_set = 0;
8009 u8 v6_address_set = 0;
8010 ip4_address_t v4address;
8011 ip6_address_t v6address;
8014 memset (mac_address, 0, sizeof (mac_address));
8016 /* Parse args required to build the message */
8017 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8019 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8023 else if (unformat (i, "del"))
8026 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8027 sw_if_index_set = 1;
8028 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8029 sw_if_index_set = 1;
8030 else if (unformat (i, "is_static"))
8032 else if (unformat (i, "no-fib-entry"))
8033 is_no_fib_entry = 1;
8034 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
8036 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
8040 clib_warning ("parse error '%U'", format_unformat_error, i);
8045 if (sw_if_index_set == 0)
8047 errmsg ("missing interface name or sw_if_index");
8050 if (v4_address_set && v6_address_set)
8052 errmsg ("both v4 and v6 addresses set");
8055 if (!v4_address_set && !v6_address_set)
8057 errmsg ("no address set");
8061 /* Construct the API message */
8062 M (IP_NEIGHBOR_ADD_DEL, mp);
8064 mp->sw_if_index = ntohl (sw_if_index);
8065 mp->is_add = is_add;
8066 mp->is_static = is_static;
8067 mp->is_no_adj_fib = is_no_fib_entry;
8069 clib_memcpy (mp->mac_address, mac_address, 6);
8073 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
8077 /* mp->is_ipv6 = 0; via memset in M macro above */
8078 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
8084 /* Wait for a reply, return good/bad news */
8090 api_reset_vrf (vat_main_t * vam)
8092 unformat_input_t *i = vam->input;
8093 vl_api_reset_vrf_t *mp;
8099 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8101 if (unformat (i, "vrf %d", &vrf_id))
8103 else if (unformat (i, "ipv6"))
8107 clib_warning ("parse error '%U'", format_unformat_error, i);
8112 if (vrf_id_set == 0)
8114 errmsg ("missing vrf id");
8120 mp->vrf_id = ntohl (vrf_id);
8121 mp->is_ipv6 = is_ipv6;
8129 api_create_vlan_subif (vat_main_t * vam)
8131 unformat_input_t *i = vam->input;
8132 vl_api_create_vlan_subif_t *mp;
8134 u8 sw_if_index_set = 0;
8139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8141 if (unformat (i, "sw_if_index %d", &sw_if_index))
8142 sw_if_index_set = 1;
8144 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8145 sw_if_index_set = 1;
8146 else if (unformat (i, "vlan %d", &vlan_id))
8150 clib_warning ("parse error '%U'", format_unformat_error, i);
8155 if (sw_if_index_set == 0)
8157 errmsg ("missing interface name or sw_if_index");
8161 if (vlan_id_set == 0)
8163 errmsg ("missing vlan_id");
8166 M (CREATE_VLAN_SUBIF, mp);
8168 mp->sw_if_index = ntohl (sw_if_index);
8169 mp->vlan_id = ntohl (vlan_id);
8176 #define foreach_create_subif_bit \
8183 _(outer_vlan_id_any) \
8184 _(inner_vlan_id_any)
8187 api_create_subif (vat_main_t * vam)
8189 unformat_input_t *i = vam->input;
8190 vl_api_create_subif_t *mp;
8192 u8 sw_if_index_set = 0;
8199 u32 exact_match = 0;
8200 u32 default_sub = 0;
8201 u32 outer_vlan_id_any = 0;
8202 u32 inner_vlan_id_any = 0;
8204 u16 outer_vlan_id = 0;
8205 u16 inner_vlan_id = 0;
8208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8210 if (unformat (i, "sw_if_index %d", &sw_if_index))
8211 sw_if_index_set = 1;
8213 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8214 sw_if_index_set = 1;
8215 else if (unformat (i, "sub_id %d", &sub_id))
8217 else if (unformat (i, "outer_vlan_id %d", &tmp))
8218 outer_vlan_id = tmp;
8219 else if (unformat (i, "inner_vlan_id %d", &tmp))
8220 inner_vlan_id = tmp;
8222 #define _(a) else if (unformat (i, #a)) a = 1 ;
8223 foreach_create_subif_bit
8227 clib_warning ("parse error '%U'", format_unformat_error, i);
8232 if (sw_if_index_set == 0)
8234 errmsg ("missing interface name or sw_if_index");
8238 if (sub_id_set == 0)
8240 errmsg ("missing sub_id");
8243 M (CREATE_SUBIF, mp);
8245 mp->sw_if_index = ntohl (sw_if_index);
8246 mp->sub_id = ntohl (sub_id);
8248 #define _(a) mp->a = a;
8249 foreach_create_subif_bit;
8252 mp->outer_vlan_id = ntohs (outer_vlan_id);
8253 mp->inner_vlan_id = ntohs (inner_vlan_id);
8261 api_oam_add_del (vat_main_t * vam)
8263 unformat_input_t *i = vam->input;
8264 vl_api_oam_add_del_t *mp;
8267 ip4_address_t src, dst;
8272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8274 if (unformat (i, "vrf %d", &vrf_id))
8276 else if (unformat (i, "src %U", unformat_ip4_address, &src))
8278 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
8280 else if (unformat (i, "del"))
8284 clib_warning ("parse error '%U'", format_unformat_error, i);
8291 errmsg ("missing src addr");
8297 errmsg ("missing dst addr");
8301 M (OAM_ADD_DEL, mp);
8303 mp->vrf_id = ntohl (vrf_id);
8304 mp->is_add = is_add;
8305 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
8306 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
8314 api_reset_fib (vat_main_t * vam)
8316 unformat_input_t *i = vam->input;
8317 vl_api_reset_fib_t *mp;
8323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8325 if (unformat (i, "vrf %d", &vrf_id))
8327 else if (unformat (i, "ipv6"))
8331 clib_warning ("parse error '%U'", format_unformat_error, i);
8336 if (vrf_id_set == 0)
8338 errmsg ("missing vrf id");
8344 mp->vrf_id = ntohl (vrf_id);
8345 mp->is_ipv6 = is_ipv6;
8353 api_dhcp_proxy_config (vat_main_t * vam)
8355 unformat_input_t *i = vam->input;
8356 vl_api_dhcp_proxy_config_t *mp;
8358 u32 server_vrf_id = 0;
8360 u8 v4_address_set = 0;
8361 u8 v6_address_set = 0;
8362 ip4_address_t v4address;
8363 ip6_address_t v6address;
8364 u8 v4_src_address_set = 0;
8365 u8 v6_src_address_set = 0;
8366 ip4_address_t v4srcaddress;
8367 ip6_address_t v6srcaddress;
8370 /* Parse args required to build the message */
8371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8373 if (unformat (i, "del"))
8375 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
8377 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
8379 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
8381 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
8383 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
8384 v4_src_address_set = 1;
8385 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
8386 v6_src_address_set = 1;
8391 if (v4_address_set && v6_address_set)
8393 errmsg ("both v4 and v6 server addresses set");
8396 if (!v4_address_set && !v6_address_set)
8398 errmsg ("no server addresses set");
8402 if (v4_src_address_set && v6_src_address_set)
8404 errmsg ("both v4 and v6 src addresses set");
8407 if (!v4_src_address_set && !v6_src_address_set)
8409 errmsg ("no src addresses set");
8413 if (!(v4_src_address_set && v4_address_set) &&
8414 !(v6_src_address_set && v6_address_set))
8416 errmsg ("no matching server and src addresses set");
8420 /* Construct the API message */
8421 M (DHCP_PROXY_CONFIG, mp);
8423 mp->is_add = is_add;
8424 mp->rx_vrf_id = ntohl (rx_vrf_id);
8425 mp->server_vrf_id = ntohl (server_vrf_id);
8429 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
8430 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
8434 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
8435 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
8441 /* Wait for a reply, return good/bad news */
8446 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
8447 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
8450 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
8452 vat_main_t *vam = &vat_main;
8453 u32 i, count = mp->count;
8454 vl_api_dhcp_server_t *s;
8458 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
8459 ntohl (mp->rx_vrf_id),
8460 format_ip6_address, mp->dhcp_src_address,
8461 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
8464 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
8465 ntohl (mp->rx_vrf_id),
8466 format_ip4_address, mp->dhcp_src_address,
8467 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
8469 for (i = 0; i < count; i++)
8471 s = &mp->servers[i];
8475 " Server Table-ID %d, Server Address %U",
8476 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
8479 " Server Table-ID %d, Server Address %U",
8480 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
8484 static void vl_api_dhcp_proxy_details_t_handler_json
8485 (vl_api_dhcp_proxy_details_t * mp)
8487 vat_main_t *vam = &vat_main;
8488 vat_json_node_t *node = NULL;
8489 u32 i, count = mp->count;
8491 struct in6_addr ip6;
8492 vl_api_dhcp_server_t *s;
8494 if (VAT_JSON_ARRAY != vam->json_tree.type)
8496 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8497 vat_json_init_array (&vam->json_tree);
8499 node = vat_json_array_add (&vam->json_tree);
8501 vat_json_init_object (node);
8502 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
8503 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
8504 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
8508 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
8509 vat_json_object_add_ip6 (node, "src_address", ip6);
8513 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
8514 vat_json_object_add_ip4 (node, "src_address", ip4);
8517 for (i = 0; i < count; i++)
8519 s = &mp->servers[i];
8521 vat_json_object_add_uint (node, "server-table-id",
8522 ntohl (s->server_vrf_id));
8526 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
8527 vat_json_object_add_ip4 (node, "src_address", ip4);
8531 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
8532 vat_json_object_add_ip6 (node, "server_address", ip6);
8538 api_dhcp_proxy_dump (vat_main_t * vam)
8540 unformat_input_t *i = vam->input;
8541 vl_api_control_ping_t *mp_ping;
8542 vl_api_dhcp_proxy_dump_t *mp;
8546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8548 if (unformat (i, "ipv6"))
8552 clib_warning ("parse error '%U'", format_unformat_error, i);
8557 M (DHCP_PROXY_DUMP, mp);
8559 mp->is_ip6 = is_ipv6;
8562 /* Use a control ping for synchronization */
8563 M (CONTROL_PING, mp_ping);
8571 api_dhcp_proxy_set_vss (vat_main_t * vam)
8573 unformat_input_t *i = vam->input;
8574 vl_api_dhcp_proxy_set_vss_t *mp;
8585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8587 if (unformat (i, "tbl_id %d", &tbl_id))
8589 if (unformat (i, "fib_id %d", &fib_id))
8591 if (unformat (i, "oui %d", &oui))
8593 else if (unformat (i, "ipv6"))
8595 else if (unformat (i, "del"))
8599 clib_warning ("parse error '%U'", format_unformat_error, i);
8604 if (tbl_id_set == 0)
8606 errmsg ("missing tbl id");
8610 if (fib_id_set == 0)
8612 errmsg ("missing fib id");
8617 errmsg ("missing oui");
8621 M (DHCP_PROXY_SET_VSS, mp);
8622 mp->tbl_id = ntohl (tbl_id);
8623 mp->fib_id = ntohl (fib_id);
8624 mp->oui = ntohl (oui);
8625 mp->is_ipv6 = is_ipv6;
8626 mp->is_add = is_add;
8634 api_dhcp_client_config (vat_main_t * vam)
8636 unformat_input_t *i = vam->input;
8637 vl_api_dhcp_client_config_t *mp;
8639 u8 sw_if_index_set = 0;
8642 u8 disable_event = 0;
8645 /* Parse args required to build the message */
8646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8648 if (unformat (i, "del"))
8651 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8652 sw_if_index_set = 1;
8653 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8654 sw_if_index_set = 1;
8655 else if (unformat (i, "hostname %s", &hostname))
8657 else if (unformat (i, "disable_event"))
8663 if (sw_if_index_set == 0)
8665 errmsg ("missing interface name or sw_if_index");
8669 if (vec_len (hostname) > 63)
8671 errmsg ("hostname too long");
8673 vec_add1 (hostname, 0);
8675 /* Construct the API message */
8676 M (DHCP_CLIENT_CONFIG, mp);
8678 mp->sw_if_index = htonl (sw_if_index);
8679 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
8680 vec_free (hostname);
8681 mp->is_add = is_add;
8682 mp->want_dhcp_event = disable_event ? 0 : 1;
8683 mp->pid = htonl (getpid ());
8688 /* Wait for a reply, return good/bad news */
8694 api_set_ip_flow_hash (vat_main_t * vam)
8696 unformat_input_t *i = vam->input;
8697 vl_api_set_ip_flow_hash_t *mp;
8709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8711 if (unformat (i, "vrf %d", &vrf_id))
8713 else if (unformat (i, "ipv6"))
8715 else if (unformat (i, "src"))
8717 else if (unformat (i, "dst"))
8719 else if (unformat (i, "sport"))
8721 else if (unformat (i, "dport"))
8723 else if (unformat (i, "proto"))
8725 else if (unformat (i, "reverse"))
8730 clib_warning ("parse error '%U'", format_unformat_error, i);
8735 if (vrf_id_set == 0)
8737 errmsg ("missing vrf id");
8741 M (SET_IP_FLOW_HASH, mp);
8747 mp->reverse = reverse;
8748 mp->vrf_id = ntohl (vrf_id);
8749 mp->is_ipv6 = is_ipv6;
8757 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
8759 unformat_input_t *i = vam->input;
8760 vl_api_sw_interface_ip6_enable_disable_t *mp;
8762 u8 sw_if_index_set = 0;
8766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8768 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8769 sw_if_index_set = 1;
8770 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8771 sw_if_index_set = 1;
8772 else if (unformat (i, "enable"))
8774 else if (unformat (i, "disable"))
8778 clib_warning ("parse error '%U'", format_unformat_error, i);
8783 if (sw_if_index_set == 0)
8785 errmsg ("missing interface name or sw_if_index");
8789 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8791 mp->sw_if_index = ntohl (sw_if_index);
8792 mp->enable = enable;
8800 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8802 unformat_input_t *i = vam->input;
8803 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8805 u8 sw_if_index_set = 0;
8806 u8 v6_address_set = 0;
8807 ip6_address_t v6address;
8810 /* Parse args required to build the message */
8811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8813 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8814 sw_if_index_set = 1;
8815 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8816 sw_if_index_set = 1;
8817 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8823 if (sw_if_index_set == 0)
8825 errmsg ("missing interface name or sw_if_index");
8828 if (!v6_address_set)
8830 errmsg ("no address set");
8834 /* Construct the API message */
8835 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8837 mp->sw_if_index = ntohl (sw_if_index);
8838 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8843 /* Wait for a reply, return good/bad news */
8849 api_ip6nd_proxy_add_del (vat_main_t * vam)
8851 unformat_input_t *i = vam->input;
8852 vl_api_ip6nd_proxy_add_del_t *mp;
8853 u32 sw_if_index = ~0;
8854 u8 v6_address_set = 0;
8855 ip6_address_t v6address;
8859 /* Parse args required to build the message */
8860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8862 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8864 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8866 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8868 if (unformat (i, "del"))
8872 clib_warning ("parse error '%U'", format_unformat_error, i);
8877 if (sw_if_index == ~0)
8879 errmsg ("missing interface name or sw_if_index");
8882 if (!v6_address_set)
8884 errmsg ("no address set");
8888 /* Construct the API message */
8889 M (IP6ND_PROXY_ADD_DEL, mp);
8891 mp->is_del = is_del;
8892 mp->sw_if_index = ntohl (sw_if_index);
8893 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8898 /* Wait for a reply, return good/bad news */
8904 api_ip6nd_proxy_dump (vat_main_t * vam)
8906 vl_api_ip6nd_proxy_dump_t *mp;
8907 vl_api_control_ping_t *mp_ping;
8910 M (IP6ND_PROXY_DUMP, mp);
8914 /* Use a control ping for synchronization */
8915 M (CONTROL_PING, mp_ping);
8922 static void vl_api_ip6nd_proxy_details_t_handler
8923 (vl_api_ip6nd_proxy_details_t * mp)
8925 vat_main_t *vam = &vat_main;
8927 print (vam->ofp, "host %U sw_if_index %d",
8928 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
8931 static void vl_api_ip6nd_proxy_details_t_handler_json
8932 (vl_api_ip6nd_proxy_details_t * mp)
8934 vat_main_t *vam = &vat_main;
8935 struct in6_addr ip6;
8936 vat_json_node_t *node = NULL;
8938 if (VAT_JSON_ARRAY != vam->json_tree.type)
8940 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8941 vat_json_init_array (&vam->json_tree);
8943 node = vat_json_array_add (&vam->json_tree);
8945 vat_json_init_object (node);
8946 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8948 clib_memcpy (&ip6, mp->address, sizeof (ip6));
8949 vat_json_object_add_ip6 (node, "host", ip6);
8953 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8955 unformat_input_t *i = vam->input;
8956 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8958 u8 sw_if_index_set = 0;
8959 u32 address_length = 0;
8960 u8 v6_address_set = 0;
8961 ip6_address_t v6address;
8963 u8 no_advertise = 0;
8965 u8 no_autoconfig = 0;
8968 u32 val_lifetime = 0;
8969 u32 pref_lifetime = 0;
8972 /* Parse args required to build the message */
8973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8975 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8976 sw_if_index_set = 1;
8977 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8978 sw_if_index_set = 1;
8979 else if (unformat (i, "%U/%d",
8980 unformat_ip6_address, &v6address, &address_length))
8982 else if (unformat (i, "val_life %d", &val_lifetime))
8984 else if (unformat (i, "pref_life %d", &pref_lifetime))
8986 else if (unformat (i, "def"))
8988 else if (unformat (i, "noadv"))
8990 else if (unformat (i, "offl"))
8992 else if (unformat (i, "noauto"))
8994 else if (unformat (i, "nolink"))
8996 else if (unformat (i, "isno"))
9000 clib_warning ("parse error '%U'", format_unformat_error, i);
9005 if (sw_if_index_set == 0)
9007 errmsg ("missing interface name or sw_if_index");
9010 if (!v6_address_set)
9012 errmsg ("no address set");
9016 /* Construct the API message */
9017 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9019 mp->sw_if_index = ntohl (sw_if_index);
9020 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9021 mp->address_length = address_length;
9022 mp->use_default = use_default;
9023 mp->no_advertise = no_advertise;
9024 mp->off_link = off_link;
9025 mp->no_autoconfig = no_autoconfig;
9026 mp->no_onlink = no_onlink;
9028 mp->val_lifetime = ntohl (val_lifetime);
9029 mp->pref_lifetime = ntohl (pref_lifetime);
9034 /* Wait for a reply, return good/bad news */
9040 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9042 unformat_input_t *i = vam->input;
9043 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9045 u8 sw_if_index_set = 0;
9050 u8 send_unicast = 0;
9053 u8 default_router = 0;
9054 u32 max_interval = 0;
9055 u32 min_interval = 0;
9057 u32 initial_count = 0;
9058 u32 initial_interval = 0;
9062 /* Parse args required to build the message */
9063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9065 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9066 sw_if_index_set = 1;
9067 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9068 sw_if_index_set = 1;
9069 else if (unformat (i, "maxint %d", &max_interval))
9071 else if (unformat (i, "minint %d", &min_interval))
9073 else if (unformat (i, "life %d", &lifetime))
9075 else if (unformat (i, "count %d", &initial_count))
9077 else if (unformat (i, "interval %d", &initial_interval))
9079 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9081 else if (unformat (i, "managed"))
9083 else if (unformat (i, "other"))
9085 else if (unformat (i, "ll"))
9087 else if (unformat (i, "send"))
9089 else if (unformat (i, "cease"))
9091 else if (unformat (i, "isno"))
9093 else if (unformat (i, "def"))
9097 clib_warning ("parse error '%U'", format_unformat_error, i);
9102 if (sw_if_index_set == 0)
9104 errmsg ("missing interface name or sw_if_index");
9108 /* Construct the API message */
9109 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9111 mp->sw_if_index = ntohl (sw_if_index);
9112 mp->max_interval = ntohl (max_interval);
9113 mp->min_interval = ntohl (min_interval);
9114 mp->lifetime = ntohl (lifetime);
9115 mp->initial_count = ntohl (initial_count);
9116 mp->initial_interval = ntohl (initial_interval);
9117 mp->suppress = suppress;
9118 mp->managed = managed;
9120 mp->ll_option = ll_option;
9121 mp->send_unicast = send_unicast;
9124 mp->default_router = default_router;
9129 /* Wait for a reply, return good/bad news */
9135 api_set_arp_neighbor_limit (vat_main_t * vam)
9137 unformat_input_t *i = vam->input;
9138 vl_api_set_arp_neighbor_limit_t *mp;
9144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9146 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9148 else if (unformat (i, "ipv6"))
9152 clib_warning ("parse error '%U'", format_unformat_error, i);
9159 errmsg ("missing limit value");
9163 M (SET_ARP_NEIGHBOR_LIMIT, mp);
9165 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
9166 mp->is_ipv6 = is_ipv6;
9174 api_l2_patch_add_del (vat_main_t * vam)
9176 unformat_input_t *i = vam->input;
9177 vl_api_l2_patch_add_del_t *mp;
9179 u8 rx_sw_if_index_set = 0;
9181 u8 tx_sw_if_index_set = 0;
9185 /* Parse args required to build the message */
9186 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9188 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9189 rx_sw_if_index_set = 1;
9190 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9191 tx_sw_if_index_set = 1;
9192 else if (unformat (i, "rx"))
9194 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9196 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9198 rx_sw_if_index_set = 1;
9203 else if (unformat (i, "tx"))
9205 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9207 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9209 tx_sw_if_index_set = 1;
9214 else if (unformat (i, "del"))
9220 if (rx_sw_if_index_set == 0)
9222 errmsg ("missing rx interface name or rx_sw_if_index");
9226 if (tx_sw_if_index_set == 0)
9228 errmsg ("missing tx interface name or tx_sw_if_index");
9232 M (L2_PATCH_ADD_DEL, mp);
9234 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9235 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9236 mp->is_add = is_add;
9244 u8 localsid_addr[16];
9253 api_sr_localsid_add_del (vat_main_t * vam)
9255 unformat_input_t *i = vam->input;
9256 vl_api_sr_localsid_add_del_t *mp;
9259 ip6_address_t localsid;
9263 u32 fib_table = ~(u32) 0;
9264 ip6_address_t next_hop;
9266 bool nexthop_set = 0;
9270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9272 if (unformat (i, "del"))
9274 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9275 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
9277 else if (unformat (i, "behavior %u", &behavior));
9278 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9279 else if (unformat (i, "fib-table %u", &fib_table));
9280 else if (unformat (i, "end.psp %u", &behavior));
9285 M (SR_LOCALSID_ADD_DEL, mp);
9287 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
9289 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
9290 mp->behavior = behavior;
9291 mp->sw_if_index = ntohl (sw_if_index);
9292 mp->fib_table = ntohl (fib_table);
9293 mp->end_psp = end_psp;
9294 mp->is_del = is_del;
9302 api_ioam_enable (vat_main_t * vam)
9304 unformat_input_t *input = vam->input;
9305 vl_api_ioam_enable_t *mp;
9307 int has_trace_option = 0;
9308 int has_pot_option = 0;
9309 int has_seqno_option = 0;
9310 int has_analyse_option = 0;
9313 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9315 if (unformat (input, "trace"))
9316 has_trace_option = 1;
9317 else if (unformat (input, "pot"))
9319 else if (unformat (input, "seqno"))
9320 has_seqno_option = 1;
9321 else if (unformat (input, "analyse"))
9322 has_analyse_option = 1;
9326 M (IOAM_ENABLE, mp);
9327 mp->id = htons (id);
9328 mp->seqno = has_seqno_option;
9329 mp->analyse = has_analyse_option;
9330 mp->pot_enable = has_pot_option;
9331 mp->trace_enable = has_trace_option;
9340 api_ioam_disable (vat_main_t * vam)
9342 vl_api_ioam_disable_t *mp;
9345 M (IOAM_DISABLE, mp);
9351 #define foreach_tcp_proto_field \
9355 #define foreach_udp_proto_field \
9359 #define foreach_ip4_proto_field \
9371 u16 src_port, dst_port;
9374 #if VPP_API_TEST_BUILTIN == 0
9376 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9378 u8 **maskp = va_arg (*args, u8 **);
9380 u8 found_something = 0;
9383 #define _(a) u8 a=0;
9384 foreach_tcp_proto_field;
9387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9390 #define _(a) else if (unformat (input, #a)) a=1;
9391 foreach_tcp_proto_field
9397 #define _(a) found_something += a;
9398 foreach_tcp_proto_field;
9401 if (found_something == 0)
9404 vec_validate (mask, sizeof (*tcp) - 1);
9406 tcp = (tcp_header_t *) mask;
9408 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
9409 foreach_tcp_proto_field;
9417 unformat_udp_mask (unformat_input_t * input, va_list * args)
9419 u8 **maskp = va_arg (*args, u8 **);
9421 u8 found_something = 0;
9424 #define _(a) u8 a=0;
9425 foreach_udp_proto_field;
9428 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9431 #define _(a) else if (unformat (input, #a)) a=1;
9432 foreach_udp_proto_field
9438 #define _(a) found_something += a;
9439 foreach_udp_proto_field;
9442 if (found_something == 0)
9445 vec_validate (mask, sizeof (*udp) - 1);
9447 udp = (udp_header_t *) mask;
9449 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
9450 foreach_udp_proto_field;
9458 unformat_l4_mask (unformat_input_t * input, va_list * args)
9460 u8 **maskp = va_arg (*args, u8 **);
9461 u16 src_port = 0, dst_port = 0;
9462 tcpudp_header_t *tcpudp;
9464 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9466 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9468 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9470 else if (unformat (input, "src_port"))
9472 else if (unformat (input, "dst_port"))
9478 if (!src_port && !dst_port)
9482 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9484 tcpudp = (tcpudp_header_t *) mask;
9485 tcpudp->src_port = src_port;
9486 tcpudp->dst_port = dst_port;
9494 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9496 u8 **maskp = va_arg (*args, u8 **);
9498 u8 found_something = 0;
9501 #define _(a) u8 a=0;
9502 foreach_ip4_proto_field;
9508 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9510 if (unformat (input, "version"))
9512 else if (unformat (input, "hdr_length"))
9514 else if (unformat (input, "src"))
9516 else if (unformat (input, "dst"))
9518 else if (unformat (input, "proto"))
9521 #define _(a) else if (unformat (input, #a)) a=1;
9522 foreach_ip4_proto_field
9528 #define _(a) found_something += a;
9529 foreach_ip4_proto_field;
9532 if (found_something == 0)
9535 vec_validate (mask, sizeof (*ip) - 1);
9537 ip = (ip4_header_t *) mask;
9539 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9540 foreach_ip4_proto_field;
9543 ip->ip_version_and_header_length = 0;
9546 ip->ip_version_and_header_length |= 0xF0;
9549 ip->ip_version_and_header_length |= 0x0F;
9555 #define foreach_ip6_proto_field \
9563 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9565 u8 **maskp = va_arg (*args, u8 **);
9567 u8 found_something = 0;
9569 u32 ip_version_traffic_class_and_flow_label;
9571 #define _(a) u8 a=0;
9572 foreach_ip6_proto_field;
9575 u8 traffic_class = 0;
9578 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9580 if (unformat (input, "version"))
9582 else if (unformat (input, "traffic-class"))
9584 else if (unformat (input, "flow-label"))
9586 else if (unformat (input, "src"))
9588 else if (unformat (input, "dst"))
9590 else if (unformat (input, "proto"))
9593 #define _(a) else if (unformat (input, #a)) a=1;
9594 foreach_ip6_proto_field
9600 #define _(a) found_something += a;
9601 foreach_ip6_proto_field;
9604 if (found_something == 0)
9607 vec_validate (mask, sizeof (*ip) - 1);
9609 ip = (ip6_header_t *) mask;
9611 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9612 foreach_ip6_proto_field;
9615 ip_version_traffic_class_and_flow_label = 0;
9618 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9621 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9624 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9626 ip->ip_version_traffic_class_and_flow_label =
9627 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9634 unformat_l3_mask (unformat_input_t * input, va_list * args)
9636 u8 **maskp = va_arg (*args, u8 **);
9638 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9640 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9642 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9651 unformat_l2_mask (unformat_input_t * input, va_list * args)
9653 u8 **maskp = va_arg (*args, u8 **);
9668 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9670 if (unformat (input, "src"))
9672 else if (unformat (input, "dst"))
9674 else if (unformat (input, "proto"))
9676 else if (unformat (input, "tag1"))
9678 else if (unformat (input, "tag2"))
9680 else if (unformat (input, "ignore-tag1"))
9682 else if (unformat (input, "ignore-tag2"))
9684 else if (unformat (input, "cos1"))
9686 else if (unformat (input, "cos2"))
9688 else if (unformat (input, "dot1q"))
9690 else if (unformat (input, "dot1ad"))
9695 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9696 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9699 if (tag1 || ignore_tag1 || cos1 || dot1q)
9701 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9704 vec_validate (mask, len - 1);
9707 memset (mask, 0xff, 6);
9710 memset (mask + 6, 0xff, 6);
9714 /* inner vlan tag */
9723 mask[21] = mask[20] = 0xff;
9744 mask[16] = mask[17] = 0xff;
9754 mask[12] = mask[13] = 0xff;
9761 unformat_classify_mask (unformat_input_t * input, va_list * args)
9763 u8 **maskp = va_arg (*args, u8 **);
9764 u32 *skipp = va_arg (*args, u32 *);
9765 u32 *matchp = va_arg (*args, u32 *);
9773 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9775 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9777 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9779 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9781 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9795 if (mask || l2 || l3 || l4)
9799 /* "With a free Ethernet header in every package" */
9801 vec_validate (l2, 13);
9805 vec_append (mask, l3);
9810 vec_append (mask, l4);
9815 /* Scan forward looking for the first significant mask octet */
9816 for (i = 0; i < vec_len (mask); i++)
9820 /* compute (skip, match) params */
9821 *skipp = i / sizeof (u32x4);
9822 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9824 /* Pad mask to an even multiple of the vector size */
9825 while (vec_len (mask) % sizeof (u32x4))
9828 match = vec_len (mask) / sizeof (u32x4);
9830 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9832 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9833 if (*tmp || *(tmp + 1))
9838 clib_warning ("BUG: match 0");
9840 _vec_len (mask) = match * sizeof (u32x4);
9850 #endif /* VPP_API_TEST_BUILTIN */
9852 #define foreach_l2_next \
9854 _(ethernet, ETHERNET_INPUT) \
9859 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9861 u32 *miss_next_indexp = va_arg (*args, u32 *);
9866 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9870 if (unformat (input, "%d", &tmp))
9879 *miss_next_indexp = next_index;
9883 #define foreach_ip_next \
9889 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9891 u32 *miss_next_indexp = va_arg (*args, u32 *);
9896 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9900 if (unformat (input, "%d", &tmp))
9909 *miss_next_indexp = next_index;
9913 #define foreach_acl_next \
9917 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9919 u32 *miss_next_indexp = va_arg (*args, u32 *);
9924 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9928 if (unformat (input, "permit"))
9933 else if (unformat (input, "%d", &tmp))
9942 *miss_next_indexp = next_index;
9947 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9949 u32 *r = va_arg (*args, u32 *);
9951 if (unformat (input, "conform-color"))
9952 *r = POLICE_CONFORM;
9953 else if (unformat (input, "exceed-color"))
9962 api_classify_add_del_table (vat_main_t * vam)
9964 unformat_input_t *i = vam->input;
9965 vl_api_classify_add_del_table_t *mp;
9972 u32 table_index = ~0;
9973 u32 next_table_index = ~0;
9974 u32 miss_next_index = ~0;
9975 u32 memory_size = 32 << 20;
9977 u32 current_data_flag = 0;
9978 int current_data_offset = 0;
9981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9983 if (unformat (i, "del"))
9985 else if (unformat (i, "del-chain"))
9990 else if (unformat (i, "buckets %d", &nbuckets))
9992 else if (unformat (i, "memory_size %d", &memory_size))
9994 else if (unformat (i, "skip %d", &skip))
9996 else if (unformat (i, "match %d", &match))
9998 else if (unformat (i, "table %d", &table_index))
10000 else if (unformat (i, "mask %U", unformat_classify_mask,
10001 &mask, &skip, &match))
10003 else if (unformat (i, "next-table %d", &next_table_index))
10005 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10008 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10011 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10014 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10016 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10022 if (is_add && mask == 0)
10024 errmsg ("Mask required");
10028 if (is_add && skip == ~0)
10030 errmsg ("skip count required");
10034 if (is_add && match == ~0)
10036 errmsg ("match count required");
10040 if (!is_add && table_index == ~0)
10042 errmsg ("table index required for delete");
10046 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10048 mp->is_add = is_add;
10049 mp->del_chain = del_chain;
10050 mp->table_index = ntohl (table_index);
10051 mp->nbuckets = ntohl (nbuckets);
10052 mp->memory_size = ntohl (memory_size);
10053 mp->skip_n_vectors = ntohl (skip);
10054 mp->match_n_vectors = ntohl (match);
10055 mp->next_table_index = ntohl (next_table_index);
10056 mp->miss_next_index = ntohl (miss_next_index);
10057 mp->current_data_flag = ntohl (current_data_flag);
10058 mp->current_data_offset = ntohl (current_data_offset);
10059 clib_memcpy (mp->mask, mask, vec_len (mask));
10068 #if VPP_API_TEST_BUILTIN == 0
10070 unformat_l4_match (unformat_input_t * input, va_list * args)
10072 u8 **matchp = va_arg (*args, u8 **);
10074 u8 *proto_header = 0;
10080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10082 if (unformat (input, "src_port %d", &src_port))
10084 else if (unformat (input, "dst_port %d", &dst_port))
10090 h.src_port = clib_host_to_net_u16 (src_port);
10091 h.dst_port = clib_host_to_net_u16 (dst_port);
10092 vec_validate (proto_header, sizeof (h) - 1);
10093 memcpy (proto_header, &h, sizeof (h));
10095 *matchp = proto_header;
10101 unformat_ip4_match (unformat_input_t * input, va_list * args)
10103 u8 **matchp = va_arg (*args, u8 **);
10108 int hdr_length = 0;
10109 u32 hdr_length_val;
10110 int src = 0, dst = 0;
10111 ip4_address_t src_val, dst_val;
10118 int fragment_id = 0;
10119 u32 fragment_id_val;
10125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10127 if (unformat (input, "version %d", &version_val))
10129 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10131 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10133 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10135 else if (unformat (input, "proto %d", &proto_val))
10137 else if (unformat (input, "tos %d", &tos_val))
10139 else if (unformat (input, "length %d", &length_val))
10141 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10143 else if (unformat (input, "ttl %d", &ttl_val))
10145 else if (unformat (input, "checksum %d", &checksum_val))
10151 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10152 + ttl + checksum == 0)
10156 * Aligned because we use the real comparison functions
10158 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10160 ip = (ip4_header_t *) match;
10162 /* These are realistically matched in practice */
10164 ip->src_address.as_u32 = src_val.as_u32;
10167 ip->dst_address.as_u32 = dst_val.as_u32;
10170 ip->protocol = proto_val;
10173 /* These are not, but they're included for completeness */
10175 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10178 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10184 ip->length = clib_host_to_net_u16 (length_val);
10190 ip->checksum = clib_host_to_net_u16 (checksum_val);
10197 unformat_ip6_match (unformat_input_t * input, va_list * args)
10199 u8 **matchp = va_arg (*args, u8 **);
10204 u8 traffic_class = 0;
10205 u32 traffic_class_val = 0;
10208 int src = 0, dst = 0;
10209 ip6_address_t src_val, dst_val;
10212 int payload_length = 0;
10213 u32 payload_length_val;
10216 u32 ip_version_traffic_class_and_flow_label;
10218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10220 if (unformat (input, "version %d", &version_val))
10222 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10224 else if (unformat (input, "flow_label %d", &flow_label_val))
10226 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10228 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10230 else if (unformat (input, "proto %d", &proto_val))
10232 else if (unformat (input, "payload_length %d", &payload_length_val))
10233 payload_length = 1;
10234 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10240 if (version + traffic_class + flow_label + src + dst + proto +
10241 payload_length + hop_limit == 0)
10245 * Aligned because we use the real comparison functions
10247 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10249 ip = (ip6_header_t *) match;
10252 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10255 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10258 ip->protocol = proto_val;
10260 ip_version_traffic_class_and_flow_label = 0;
10263 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10266 ip_version_traffic_class_and_flow_label |=
10267 (traffic_class_val & 0xFF) << 20;
10270 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10272 ip->ip_version_traffic_class_and_flow_label =
10273 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10275 if (payload_length)
10276 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10279 ip->hop_limit = hop_limit_val;
10286 unformat_l3_match (unformat_input_t * input, va_list * args)
10288 u8 **matchp = va_arg (*args, u8 **);
10290 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10292 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10294 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10303 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10305 u8 *tagp = va_arg (*args, u8 *);
10308 if (unformat (input, "%d", &tag))
10310 tagp[0] = (tag >> 8) & 0x0F;
10311 tagp[1] = tag & 0xFF;
10319 unformat_l2_match (unformat_input_t * input, va_list * args)
10321 u8 **matchp = va_arg (*args, u8 **);
10334 u8 ignore_tag1 = 0;
10335 u8 ignore_tag2 = 0;
10341 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10343 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10346 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10348 else if (unformat (input, "proto %U",
10349 unformat_ethernet_type_host_byte_order, &proto_val))
10351 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10353 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10355 else if (unformat (input, "ignore-tag1"))
10357 else if (unformat (input, "ignore-tag2"))
10359 else if (unformat (input, "cos1 %d", &cos1_val))
10361 else if (unformat (input, "cos2 %d", &cos2_val))
10366 if ((src + dst + proto + tag1 + tag2 +
10367 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10370 if (tag1 || ignore_tag1 || cos1)
10372 if (tag2 || ignore_tag2 || cos2)
10375 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10378 clib_memcpy (match, dst_val, 6);
10381 clib_memcpy (match + 6, src_val, 6);
10385 /* inner vlan tag */
10386 match[19] = tag2_val[1];
10387 match[18] = tag2_val[0];
10389 match[18] |= (cos2_val & 0x7) << 5;
10392 match[21] = proto_val & 0xff;
10393 match[20] = proto_val >> 8;
10397 match[15] = tag1_val[1];
10398 match[14] = tag1_val[0];
10401 match[14] |= (cos1_val & 0x7) << 5;
10407 match[15] = tag1_val[1];
10408 match[14] = tag1_val[0];
10411 match[17] = proto_val & 0xff;
10412 match[16] = proto_val >> 8;
10415 match[14] |= (cos1_val & 0x7) << 5;
10421 match[18] |= (cos2_val & 0x7) << 5;
10423 match[14] |= (cos1_val & 0x7) << 5;
10426 match[13] = proto_val & 0xff;
10427 match[12] = proto_val >> 8;
10436 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10438 u8 **matchp = va_arg (*args, u8 **);
10439 u32 skip_n_vectors = va_arg (*args, u32);
10440 u32 match_n_vectors = va_arg (*args, u32);
10447 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10449 if (unformat (input, "hex %U", unformat_hex_string, &match))
10451 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10453 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10455 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10469 if (match || l2 || l3 || l4)
10471 if (l2 || l3 || l4)
10473 /* "Win a free Ethernet header in every packet" */
10475 vec_validate_aligned (l2, 13, sizeof (u32x4));
10479 vec_append_aligned (match, l3, sizeof (u32x4));
10484 vec_append_aligned (match, l4, sizeof (u32x4));
10489 /* Make sure the vector is big enough even if key is all 0's */
10490 vec_validate_aligned
10491 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10494 /* Set size, include skipped vectors */
10495 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10506 api_classify_add_del_session (vat_main_t * vam)
10508 unformat_input_t *i = vam->input;
10509 vl_api_classify_add_del_session_t *mp;
10511 u32 table_index = ~0;
10512 u32 hit_next_index = ~0;
10513 u32 opaque_index = ~0;
10516 u32 skip_n_vectors = 0;
10517 u32 match_n_vectors = 0;
10523 * Warning: you have to supply skip_n and match_n
10524 * because the API client cant simply look at the classify
10528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10530 if (unformat (i, "del"))
10532 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10535 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10538 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10541 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10543 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10545 else if (unformat (i, "opaque-index %d", &opaque_index))
10547 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10549 else if (unformat (i, "match_n %d", &match_n_vectors))
10551 else if (unformat (i, "match %U", api_unformat_classify_match,
10552 &match, skip_n_vectors, match_n_vectors))
10554 else if (unformat (i, "advance %d", &advance))
10556 else if (unformat (i, "table-index %d", &table_index))
10558 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10560 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10562 else if (unformat (i, "action %d", &action))
10564 else if (unformat (i, "metadata %d", &metadata))
10570 if (table_index == ~0)
10572 errmsg ("Table index required");
10576 if (is_add && match == 0)
10578 errmsg ("Match value required");
10582 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10584 mp->is_add = is_add;
10585 mp->table_index = ntohl (table_index);
10586 mp->hit_next_index = ntohl (hit_next_index);
10587 mp->opaque_index = ntohl (opaque_index);
10588 mp->advance = ntohl (advance);
10589 mp->action = action;
10590 mp->metadata = ntohl (metadata);
10591 clib_memcpy (mp->match, match, vec_len (match));
10600 api_classify_set_interface_ip_table (vat_main_t * vam)
10602 unformat_input_t *i = vam->input;
10603 vl_api_classify_set_interface_ip_table_t *mp;
10605 int sw_if_index_set;
10606 u32 table_index = ~0;
10610 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10612 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10613 sw_if_index_set = 1;
10614 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10615 sw_if_index_set = 1;
10616 else if (unformat (i, "table %d", &table_index))
10620 clib_warning ("parse error '%U'", format_unformat_error, i);
10625 if (sw_if_index_set == 0)
10627 errmsg ("missing interface name or sw_if_index");
10632 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10634 mp->sw_if_index = ntohl (sw_if_index);
10635 mp->table_index = ntohl (table_index);
10636 mp->is_ipv6 = is_ipv6;
10644 api_classify_set_interface_l2_tables (vat_main_t * vam)
10646 unformat_input_t *i = vam->input;
10647 vl_api_classify_set_interface_l2_tables_t *mp;
10649 int sw_if_index_set;
10650 u32 ip4_table_index = ~0;
10651 u32 ip6_table_index = ~0;
10652 u32 other_table_index = ~0;
10656 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10658 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10659 sw_if_index_set = 1;
10660 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10661 sw_if_index_set = 1;
10662 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10664 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10666 else if (unformat (i, "other-table %d", &other_table_index))
10668 else if (unformat (i, "is-input %d", &is_input))
10672 clib_warning ("parse error '%U'", format_unformat_error, i);
10677 if (sw_if_index_set == 0)
10679 errmsg ("missing interface name or sw_if_index");
10684 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10686 mp->sw_if_index = ntohl (sw_if_index);
10687 mp->ip4_table_index = ntohl (ip4_table_index);
10688 mp->ip6_table_index = ntohl (ip6_table_index);
10689 mp->other_table_index = ntohl (other_table_index);
10690 mp->is_input = (u8) is_input;
10698 api_set_ipfix_exporter (vat_main_t * vam)
10700 unformat_input_t *i = vam->input;
10701 vl_api_set_ipfix_exporter_t *mp;
10702 ip4_address_t collector_address;
10703 u8 collector_address_set = 0;
10704 u32 collector_port = ~0;
10705 ip4_address_t src_address;
10706 u8 src_address_set = 0;
10709 u32 template_interval = ~0;
10710 u8 udp_checksum = 0;
10713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10715 if (unformat (i, "collector_address %U", unformat_ip4_address,
10716 &collector_address))
10717 collector_address_set = 1;
10718 else if (unformat (i, "collector_port %d", &collector_port))
10720 else if (unformat (i, "src_address %U", unformat_ip4_address,
10722 src_address_set = 1;
10723 else if (unformat (i, "vrf_id %d", &vrf_id))
10725 else if (unformat (i, "path_mtu %d", &path_mtu))
10727 else if (unformat (i, "template_interval %d", &template_interval))
10729 else if (unformat (i, "udp_checksum"))
10735 if (collector_address_set == 0)
10737 errmsg ("collector_address required");
10741 if (src_address_set == 0)
10743 errmsg ("src_address required");
10747 M (SET_IPFIX_EXPORTER, mp);
10749 memcpy (mp->collector_address, collector_address.data,
10750 sizeof (collector_address.data));
10751 mp->collector_port = htons ((u16) collector_port);
10752 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10753 mp->vrf_id = htonl (vrf_id);
10754 mp->path_mtu = htonl (path_mtu);
10755 mp->template_interval = htonl (template_interval);
10756 mp->udp_checksum = udp_checksum;
10764 api_set_ipfix_classify_stream (vat_main_t * vam)
10766 unformat_input_t *i = vam->input;
10767 vl_api_set_ipfix_classify_stream_t *mp;
10769 u32 src_port = UDP_DST_PORT_ipfix;
10772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10774 if (unformat (i, "domain %d", &domain_id))
10776 else if (unformat (i, "src_port %d", &src_port))
10780 errmsg ("unknown input `%U'", format_unformat_error, i);
10785 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10787 mp->domain_id = htonl (domain_id);
10788 mp->src_port = htons ((u16) src_port);
10796 api_ipfix_classify_table_add_del (vat_main_t * vam)
10798 unformat_input_t *i = vam->input;
10799 vl_api_ipfix_classify_table_add_del_t *mp;
10801 u32 classify_table_index = ~0;
10803 u8 transport_protocol = 255;
10806 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10808 if (unformat (i, "add"))
10810 else if (unformat (i, "del"))
10812 else if (unformat (i, "table %d", &classify_table_index))
10814 else if (unformat (i, "ip4"))
10816 else if (unformat (i, "ip6"))
10818 else if (unformat (i, "tcp"))
10819 transport_protocol = 6;
10820 else if (unformat (i, "udp"))
10821 transport_protocol = 17;
10824 errmsg ("unknown input `%U'", format_unformat_error, i);
10831 errmsg ("expecting: add|del");
10834 if (classify_table_index == ~0)
10836 errmsg ("classifier table not specified");
10839 if (ip_version == 0)
10841 errmsg ("IP version not specified");
10845 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10847 mp->is_add = is_add;
10848 mp->table_id = htonl (classify_table_index);
10849 mp->ip_version = ip_version;
10850 mp->transport_protocol = transport_protocol;
10858 api_get_node_index (vat_main_t * vam)
10860 unformat_input_t *i = vam->input;
10861 vl_api_get_node_index_t *mp;
10865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10867 if (unformat (i, "node %s", &name))
10874 errmsg ("node name required");
10877 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10879 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10883 M (GET_NODE_INDEX, mp);
10884 clib_memcpy (mp->node_name, name, vec_len (name));
10893 api_get_next_index (vat_main_t * vam)
10895 unformat_input_t *i = vam->input;
10896 vl_api_get_next_index_t *mp;
10897 u8 *node_name = 0, *next_node_name = 0;
10900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10902 if (unformat (i, "node-name %s", &node_name))
10904 else if (unformat (i, "next-node-name %s", &next_node_name))
10908 if (node_name == 0)
10910 errmsg ("node name required");
10913 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10915 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10919 if (next_node_name == 0)
10921 errmsg ("next node name required");
10924 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10926 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10930 M (GET_NEXT_INDEX, mp);
10931 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10932 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10933 vec_free (node_name);
10934 vec_free (next_node_name);
10942 api_add_node_next (vat_main_t * vam)
10944 unformat_input_t *i = vam->input;
10945 vl_api_add_node_next_t *mp;
10950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10952 if (unformat (i, "node %s", &name))
10954 else if (unformat (i, "next %s", &next))
10961 errmsg ("node name required");
10964 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10966 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10971 errmsg ("next node required");
10974 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10976 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10980 M (ADD_NODE_NEXT, mp);
10981 clib_memcpy (mp->node_name, name, vec_len (name));
10982 clib_memcpy (mp->next_name, next, vec_len (next));
10992 api_l2tpv3_create_tunnel (vat_main_t * vam)
10994 unformat_input_t *i = vam->input;
10995 ip6_address_t client_address, our_address;
10996 int client_address_set = 0;
10997 int our_address_set = 0;
10998 u32 local_session_id = 0;
10999 u32 remote_session_id = 0;
11000 u64 local_cookie = 0;
11001 u64 remote_cookie = 0;
11002 u8 l2_sublayer_present = 0;
11003 vl_api_l2tpv3_create_tunnel_t *mp;
11006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11008 if (unformat (i, "client_address %U", unformat_ip6_address,
11010 client_address_set = 1;
11011 else if (unformat (i, "our_address %U", unformat_ip6_address,
11013 our_address_set = 1;
11014 else if (unformat (i, "local_session_id %d", &local_session_id))
11016 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11018 else if (unformat (i, "local_cookie %lld", &local_cookie))
11020 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11022 else if (unformat (i, "l2-sublayer-present"))
11023 l2_sublayer_present = 1;
11028 if (client_address_set == 0)
11030 errmsg ("client_address required");
11034 if (our_address_set == 0)
11036 errmsg ("our_address required");
11040 M (L2TPV3_CREATE_TUNNEL, mp);
11042 clib_memcpy (mp->client_address, client_address.as_u8,
11043 sizeof (mp->client_address));
11045 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11047 mp->local_session_id = ntohl (local_session_id);
11048 mp->remote_session_id = ntohl (remote_session_id);
11049 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11050 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11051 mp->l2_sublayer_present = l2_sublayer_present;
11060 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11062 unformat_input_t *i = vam->input;
11064 u8 sw_if_index_set = 0;
11065 u64 new_local_cookie = 0;
11066 u64 new_remote_cookie = 0;
11067 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11070 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11072 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11073 sw_if_index_set = 1;
11074 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11075 sw_if_index_set = 1;
11076 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11078 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11084 if (sw_if_index_set == 0)
11086 errmsg ("missing interface name or sw_if_index");
11090 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11092 mp->sw_if_index = ntohl (sw_if_index);
11093 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11094 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11102 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11104 unformat_input_t *i = vam->input;
11105 vl_api_l2tpv3_interface_enable_disable_t *mp;
11107 u8 sw_if_index_set = 0;
11108 u8 enable_disable = 1;
11111 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11113 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11114 sw_if_index_set = 1;
11115 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11116 sw_if_index_set = 1;
11117 else if (unformat (i, "enable"))
11118 enable_disable = 1;
11119 else if (unformat (i, "disable"))
11120 enable_disable = 0;
11125 if (sw_if_index_set == 0)
11127 errmsg ("missing interface name or sw_if_index");
11131 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11133 mp->sw_if_index = ntohl (sw_if_index);
11134 mp->enable_disable = enable_disable;
11142 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11144 unformat_input_t *i = vam->input;
11145 vl_api_l2tpv3_set_lookup_key_t *mp;
11149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11151 if (unformat (i, "lookup_v6_src"))
11152 key = L2T_LOOKUP_SRC_ADDRESS;
11153 else if (unformat (i, "lookup_v6_dst"))
11154 key = L2T_LOOKUP_DST_ADDRESS;
11155 else if (unformat (i, "lookup_session_id"))
11156 key = L2T_LOOKUP_SESSION_ID;
11161 if (key == (u8) ~ 0)
11163 errmsg ("l2tp session lookup key unset");
11167 M (L2TPV3_SET_LOOKUP_KEY, mp);
11176 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11177 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11179 vat_main_t *vam = &vat_main;
11181 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11182 format_ip6_address, mp->our_address,
11183 format_ip6_address, mp->client_address,
11184 clib_net_to_host_u32 (mp->sw_if_index));
11187 " local cookies %016llx %016llx remote cookie %016llx",
11188 clib_net_to_host_u64 (mp->local_cookie[0]),
11189 clib_net_to_host_u64 (mp->local_cookie[1]),
11190 clib_net_to_host_u64 (mp->remote_cookie));
11192 print (vam->ofp, " local session-id %d remote session-id %d",
11193 clib_net_to_host_u32 (mp->local_session_id),
11194 clib_net_to_host_u32 (mp->remote_session_id));
11196 print (vam->ofp, " l2 specific sublayer %s\n",
11197 mp->l2_sublayer_present ? "preset" : "absent");
11201 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11202 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11204 vat_main_t *vam = &vat_main;
11205 vat_json_node_t *node = NULL;
11206 struct in6_addr addr;
11208 if (VAT_JSON_ARRAY != vam->json_tree.type)
11210 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11211 vat_json_init_array (&vam->json_tree);
11213 node = vat_json_array_add (&vam->json_tree);
11215 vat_json_init_object (node);
11217 clib_memcpy (&addr, mp->our_address, sizeof (addr));
11218 vat_json_object_add_ip6 (node, "our_address", addr);
11219 clib_memcpy (&addr, mp->client_address, sizeof (addr));
11220 vat_json_object_add_ip6 (node, "client_address", addr);
11222 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11223 vat_json_init_array (lc);
11224 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11225 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11226 vat_json_object_add_uint (node, "remote_cookie",
11227 clib_net_to_host_u64 (mp->remote_cookie));
11229 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11230 vat_json_object_add_uint (node, "local_session_id",
11231 clib_net_to_host_u32 (mp->local_session_id));
11232 vat_json_object_add_uint (node, "remote_session_id",
11233 clib_net_to_host_u32 (mp->remote_session_id));
11234 vat_json_object_add_string_copy (node, "l2_sublayer",
11235 mp->l2_sublayer_present ? (u8 *) "present"
11236 : (u8 *) "absent");
11240 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11242 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11243 vl_api_control_ping_t *mp_ping;
11246 /* Get list of l2tpv3-tunnel interfaces */
11247 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11250 /* Use a control ping for synchronization */
11251 M (CONTROL_PING, mp_ping);
11259 static void vl_api_sw_interface_tap_details_t_handler
11260 (vl_api_sw_interface_tap_details_t * mp)
11262 vat_main_t *vam = &vat_main;
11264 print (vam->ofp, "%-16s %d",
11265 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
11268 static void vl_api_sw_interface_tap_details_t_handler_json
11269 (vl_api_sw_interface_tap_details_t * mp)
11271 vat_main_t *vam = &vat_main;
11272 vat_json_node_t *node = NULL;
11274 if (VAT_JSON_ARRAY != vam->json_tree.type)
11276 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11277 vat_json_init_array (&vam->json_tree);
11279 node = vat_json_array_add (&vam->json_tree);
11281 vat_json_init_object (node);
11282 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11283 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11287 api_sw_interface_tap_dump (vat_main_t * vam)
11289 vl_api_sw_interface_tap_dump_t *mp;
11290 vl_api_control_ping_t *mp_ping;
11293 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
11294 /* Get list of tap interfaces */
11295 M (SW_INTERFACE_TAP_DUMP, mp);
11298 /* Use a control ping for synchronization */
11299 M (CONTROL_PING, mp_ping);
11306 static uword unformat_vxlan_decap_next
11307 (unformat_input_t * input, va_list * args)
11309 u32 *result = va_arg (*args, u32 *);
11312 if (unformat (input, "l2"))
11313 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11314 else if (unformat (input, "%d", &tmp))
11322 api_vxlan_add_del_tunnel (vat_main_t * vam)
11324 unformat_input_t *line_input = vam->input;
11325 vl_api_vxlan_add_del_tunnel_t *mp;
11326 ip46_address_t src, dst;
11328 u8 ipv4_set = 0, ipv6_set = 0;
11332 u32 mcast_sw_if_index = ~0;
11333 u32 encap_vrf_id = 0;
11334 u32 decap_next_index = ~0;
11338 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11339 memset (&src, 0, sizeof src);
11340 memset (&dst, 0, sizeof dst);
11342 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11344 if (unformat (line_input, "del"))
11347 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11353 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11359 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11365 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11370 else if (unformat (line_input, "group %U %U",
11371 unformat_ip4_address, &dst.ip4,
11372 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11374 grp_set = dst_set = 1;
11377 else if (unformat (line_input, "group %U",
11378 unformat_ip4_address, &dst.ip4))
11380 grp_set = dst_set = 1;
11383 else if (unformat (line_input, "group %U %U",
11384 unformat_ip6_address, &dst.ip6,
11385 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11387 grp_set = dst_set = 1;
11390 else if (unformat (line_input, "group %U",
11391 unformat_ip6_address, &dst.ip6))
11393 grp_set = dst_set = 1;
11397 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11399 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11401 else if (unformat (line_input, "decap-next %U",
11402 unformat_vxlan_decap_next, &decap_next_index))
11404 else if (unformat (line_input, "vni %d", &vni))
11408 errmsg ("parse error '%U'", format_unformat_error, line_input);
11415 errmsg ("tunnel src address not specified");
11420 errmsg ("tunnel dst address not specified");
11424 if (grp_set && !ip46_address_is_multicast (&dst))
11426 errmsg ("tunnel group address not multicast");
11429 if (grp_set && mcast_sw_if_index == ~0)
11431 errmsg ("tunnel nonexistent multicast device");
11434 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11436 errmsg ("tunnel dst address must be unicast");
11441 if (ipv4_set && ipv6_set)
11443 errmsg ("both IPv4 and IPv6 addresses specified");
11447 if ((vni == 0) || (vni >> 24))
11449 errmsg ("vni not specified or out of range");
11453 M (VXLAN_ADD_DEL_TUNNEL, mp);
11457 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11458 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11462 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11463 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11465 mp->encap_vrf_id = ntohl (encap_vrf_id);
11466 mp->decap_next_index = ntohl (decap_next_index);
11467 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11468 mp->vni = ntohl (vni);
11469 mp->is_add = is_add;
11470 mp->is_ipv6 = ipv6_set;
11477 static void vl_api_vxlan_tunnel_details_t_handler
11478 (vl_api_vxlan_tunnel_details_t * mp)
11480 vat_main_t *vam = &vat_main;
11481 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11482 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11484 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
11485 ntohl (mp->sw_if_index),
11486 format_ip46_address, &src, IP46_TYPE_ANY,
11487 format_ip46_address, &dst, IP46_TYPE_ANY,
11488 ntohl (mp->encap_vrf_id),
11489 ntohl (mp->decap_next_index), ntohl (mp->vni),
11490 ntohl (mp->mcast_sw_if_index));
11493 static void vl_api_vxlan_tunnel_details_t_handler_json
11494 (vl_api_vxlan_tunnel_details_t * mp)
11496 vat_main_t *vam = &vat_main;
11497 vat_json_node_t *node = NULL;
11499 if (VAT_JSON_ARRAY != vam->json_tree.type)
11501 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11502 vat_json_init_array (&vam->json_tree);
11504 node = vat_json_array_add (&vam->json_tree);
11506 vat_json_init_object (node);
11507 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11510 struct in6_addr ip6;
11512 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11513 vat_json_object_add_ip6 (node, "src_address", ip6);
11514 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11515 vat_json_object_add_ip6 (node, "dst_address", ip6);
11519 struct in_addr ip4;
11521 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11522 vat_json_object_add_ip4 (node, "src_address", ip4);
11523 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11524 vat_json_object_add_ip4 (node, "dst_address", ip4);
11526 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11527 vat_json_object_add_uint (node, "decap_next_index",
11528 ntohl (mp->decap_next_index));
11529 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11530 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11531 vat_json_object_add_uint (node, "mcast_sw_if_index",
11532 ntohl (mp->mcast_sw_if_index));
11536 api_vxlan_tunnel_dump (vat_main_t * vam)
11538 unformat_input_t *i = vam->input;
11539 vl_api_vxlan_tunnel_dump_t *mp;
11540 vl_api_control_ping_t *mp_ping;
11542 u8 sw_if_index_set = 0;
11545 /* Parse args required to build the message */
11546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11548 if (unformat (i, "sw_if_index %d", &sw_if_index))
11549 sw_if_index_set = 1;
11554 if (sw_if_index_set == 0)
11559 if (!vam->json_output)
11561 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
11562 "sw_if_index", "src_address", "dst_address",
11563 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11566 /* Get list of vxlan-tunnel interfaces */
11567 M (VXLAN_TUNNEL_DUMP, mp);
11569 mp->sw_if_index = htonl (sw_if_index);
11573 /* Use a control ping for synchronization */
11574 M (CONTROL_PING, mp_ping);
11582 api_gre_add_del_tunnel (vat_main_t * vam)
11584 unformat_input_t *line_input = vam->input;
11585 vl_api_gre_add_del_tunnel_t *mp;
11586 ip4_address_t src4, dst4;
11587 ip6_address_t src6, dst6;
11594 u32 outer_fib_id = 0;
11597 memset (&src4, 0, sizeof src4);
11598 memset (&dst4, 0, sizeof dst4);
11599 memset (&src6, 0, sizeof src6);
11600 memset (&dst6, 0, sizeof dst6);
11602 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11604 if (unformat (line_input, "del"))
11606 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
11611 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
11616 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
11621 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
11626 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
11628 else if (unformat (line_input, "teb"))
11632 errmsg ("parse error '%U'", format_unformat_error, line_input);
11639 errmsg ("tunnel src address not specified");
11644 errmsg ("tunnel dst address not specified");
11647 if (ipv4_set && ipv6_set)
11649 errmsg ("both IPv4 and IPv6 addresses specified");
11654 M (GRE_ADD_DEL_TUNNEL, mp);
11658 clib_memcpy (&mp->src_address, &src4, 4);
11659 clib_memcpy (&mp->dst_address, &dst4, 4);
11663 clib_memcpy (&mp->src_address, &src6, 16);
11664 clib_memcpy (&mp->dst_address, &dst6, 16);
11666 mp->outer_fib_id = ntohl (outer_fib_id);
11667 mp->is_add = is_add;
11669 mp->is_ipv6 = ipv6_set;
11676 static void vl_api_gre_tunnel_details_t_handler
11677 (vl_api_gre_tunnel_details_t * mp)
11679 vat_main_t *vam = &vat_main;
11680 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
11681 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
11683 print (vam->ofp, "%11d%24U%24U%6d%14d",
11684 ntohl (mp->sw_if_index),
11685 format_ip46_address, &src, IP46_TYPE_ANY,
11686 format_ip46_address, &dst, IP46_TYPE_ANY,
11687 mp->teb, ntohl (mp->outer_fib_id));
11690 static void vl_api_gre_tunnel_details_t_handler_json
11691 (vl_api_gre_tunnel_details_t * mp)
11693 vat_main_t *vam = &vat_main;
11694 vat_json_node_t *node = NULL;
11695 struct in_addr ip4;
11696 struct in6_addr ip6;
11698 if (VAT_JSON_ARRAY != vam->json_tree.type)
11700 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11701 vat_json_init_array (&vam->json_tree);
11703 node = vat_json_array_add (&vam->json_tree);
11705 vat_json_init_object (node);
11706 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11709 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11710 vat_json_object_add_ip4 (node, "src_address", ip4);
11711 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11712 vat_json_object_add_ip4 (node, "dst_address", ip4);
11716 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
11717 vat_json_object_add_ip6 (node, "src_address", ip6);
11718 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
11719 vat_json_object_add_ip6 (node, "dst_address", ip6);
11721 vat_json_object_add_uint (node, "teb", mp->teb);
11722 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11723 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
11727 api_gre_tunnel_dump (vat_main_t * vam)
11729 unformat_input_t *i = vam->input;
11730 vl_api_gre_tunnel_dump_t *mp;
11731 vl_api_control_ping_t *mp_ping;
11733 u8 sw_if_index_set = 0;
11736 /* Parse args required to build the message */
11737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11739 if (unformat (i, "sw_if_index %d", &sw_if_index))
11740 sw_if_index_set = 1;
11745 if (sw_if_index_set == 0)
11750 if (!vam->json_output)
11752 print (vam->ofp, "%11s%24s%24s%6s%14s",
11753 "sw_if_index", "src_address", "dst_address", "teb",
11757 /* Get list of gre-tunnel interfaces */
11758 M (GRE_TUNNEL_DUMP, mp);
11760 mp->sw_if_index = htonl (sw_if_index);
11764 /* Use a control ping for synchronization */
11765 M (CONTROL_PING, mp_ping);
11773 api_l2_fib_clear_table (vat_main_t * vam)
11775 // unformat_input_t * i = vam->input;
11776 vl_api_l2_fib_clear_table_t *mp;
11779 M (L2_FIB_CLEAR_TABLE, mp);
11787 api_l2_interface_efp_filter (vat_main_t * vam)
11789 unformat_input_t *i = vam->input;
11790 vl_api_l2_interface_efp_filter_t *mp;
11793 u8 sw_if_index_set = 0;
11796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11798 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11799 sw_if_index_set = 1;
11800 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11801 sw_if_index_set = 1;
11802 else if (unformat (i, "enable"))
11804 else if (unformat (i, "disable"))
11808 clib_warning ("parse error '%U'", format_unformat_error, i);
11813 if (sw_if_index_set == 0)
11815 errmsg ("missing sw_if_index");
11819 M (L2_INTERFACE_EFP_FILTER, mp);
11821 mp->sw_if_index = ntohl (sw_if_index);
11822 mp->enable_disable = enable;
11829 #define foreach_vtr_op \
11830 _("disable", L2_VTR_DISABLED) \
11831 _("push-1", L2_VTR_PUSH_1) \
11832 _("push-2", L2_VTR_PUSH_2) \
11833 _("pop-1", L2_VTR_POP_1) \
11834 _("pop-2", L2_VTR_POP_2) \
11835 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11836 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11837 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11838 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11841 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11843 unformat_input_t *i = vam->input;
11844 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11846 u8 sw_if_index_set = 0;
11849 u32 push_dot1q = 1;
11854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11856 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11857 sw_if_index_set = 1;
11858 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11859 sw_if_index_set = 1;
11860 else if (unformat (i, "vtr_op %d", &vtr_op))
11862 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11865 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11867 else if (unformat (i, "tag1 %d", &tag1))
11869 else if (unformat (i, "tag2 %d", &tag2))
11873 clib_warning ("parse error '%U'", format_unformat_error, i);
11878 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11880 errmsg ("missing vtr operation or sw_if_index");
11884 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11885 mp->sw_if_index = ntohl (sw_if_index);
11886 mp->vtr_op = ntohl (vtr_op);
11887 mp->push_dot1q = ntohl (push_dot1q);
11888 mp->tag1 = ntohl (tag1);
11889 mp->tag2 = ntohl (tag2);
11897 api_create_vhost_user_if (vat_main_t * vam)
11899 unformat_input_t *i = vam->input;
11900 vl_api_create_vhost_user_if_t *mp;
11903 u8 file_name_set = 0;
11904 u32 custom_dev_instance = ~0;
11906 u8 use_custom_mac = 0;
11910 /* Shut up coverity */
11911 memset (hwaddr, 0, sizeof (hwaddr));
11913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11915 if (unformat (i, "socket %s", &file_name))
11919 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11921 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11922 use_custom_mac = 1;
11923 else if (unformat (i, "server"))
11925 else if (unformat (i, "tag %s", &tag))
11931 if (file_name_set == 0)
11933 errmsg ("missing socket file name");
11937 if (vec_len (file_name) > 255)
11939 errmsg ("socket file name too long");
11942 vec_add1 (file_name, 0);
11944 M (CREATE_VHOST_USER_IF, mp);
11946 mp->is_server = is_server;
11947 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11948 vec_free (file_name);
11949 if (custom_dev_instance != ~0)
11952 mp->custom_dev_instance = ntohl (custom_dev_instance);
11954 mp->use_custom_mac = use_custom_mac;
11955 clib_memcpy (mp->mac_address, hwaddr, 6);
11957 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11966 api_modify_vhost_user_if (vat_main_t * vam)
11968 unformat_input_t *i = vam->input;
11969 vl_api_modify_vhost_user_if_t *mp;
11972 u8 file_name_set = 0;
11973 u32 custom_dev_instance = ~0;
11974 u8 sw_if_index_set = 0;
11975 u32 sw_if_index = (u32) ~ 0;
11978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11980 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11981 sw_if_index_set = 1;
11982 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11983 sw_if_index_set = 1;
11984 else if (unformat (i, "socket %s", &file_name))
11988 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11990 else if (unformat (i, "server"))
11996 if (sw_if_index_set == 0)
11998 errmsg ("missing sw_if_index or interface name");
12002 if (file_name_set == 0)
12004 errmsg ("missing socket file name");
12008 if (vec_len (file_name) > 255)
12010 errmsg ("socket file name too long");
12013 vec_add1 (file_name, 0);
12015 M (MODIFY_VHOST_USER_IF, mp);
12017 mp->sw_if_index = ntohl (sw_if_index);
12018 mp->is_server = is_server;
12019 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12020 vec_free (file_name);
12021 if (custom_dev_instance != ~0)
12024 mp->custom_dev_instance = ntohl (custom_dev_instance);
12033 api_delete_vhost_user_if (vat_main_t * vam)
12035 unformat_input_t *i = vam->input;
12036 vl_api_delete_vhost_user_if_t *mp;
12037 u32 sw_if_index = ~0;
12038 u8 sw_if_index_set = 0;
12041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12043 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12044 sw_if_index_set = 1;
12045 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12046 sw_if_index_set = 1;
12051 if (sw_if_index_set == 0)
12053 errmsg ("missing sw_if_index or interface name");
12058 M (DELETE_VHOST_USER_IF, mp);
12060 mp->sw_if_index = ntohl (sw_if_index);
12067 static void vl_api_sw_interface_vhost_user_details_t_handler
12068 (vl_api_sw_interface_vhost_user_details_t * mp)
12070 vat_main_t *vam = &vat_main;
12072 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12073 (char *) mp->interface_name,
12074 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12075 clib_net_to_host_u64 (mp->features), mp->is_server,
12076 ntohl (mp->num_regions), (char *) mp->sock_filename);
12077 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12080 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12081 (vl_api_sw_interface_vhost_user_details_t * mp)
12083 vat_main_t *vam = &vat_main;
12084 vat_json_node_t *node = NULL;
12086 if (VAT_JSON_ARRAY != vam->json_tree.type)
12088 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12089 vat_json_init_array (&vam->json_tree);
12091 node = vat_json_array_add (&vam->json_tree);
12093 vat_json_init_object (node);
12094 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12095 vat_json_object_add_string_copy (node, "interface_name",
12096 mp->interface_name);
12097 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12098 ntohl (mp->virtio_net_hdr_sz));
12099 vat_json_object_add_uint (node, "features",
12100 clib_net_to_host_u64 (mp->features));
12101 vat_json_object_add_uint (node, "is_server", mp->is_server);
12102 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12103 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12104 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12108 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12110 vl_api_sw_interface_vhost_user_dump_t *mp;
12111 vl_api_control_ping_t *mp_ping;
12114 "Interface name idx hdr_sz features server regions filename");
12116 /* Get list of vhost-user interfaces */
12117 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12120 /* Use a control ping for synchronization */
12121 M (CONTROL_PING, mp_ping);
12129 api_show_version (vat_main_t * vam)
12131 vl_api_show_version_t *mp;
12134 M (SHOW_VERSION, mp);
12143 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12145 unformat_input_t *line_input = vam->input;
12146 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12147 ip4_address_t local4, remote4;
12148 ip6_address_t local6, remote6;
12150 u8 ipv4_set = 0, ipv6_set = 0;
12154 u32 mcast_sw_if_index = ~0;
12155 u32 encap_vrf_id = 0;
12156 u32 decap_vrf_id = 0;
12162 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12163 memset (&local4, 0, sizeof local4);
12164 memset (&remote4, 0, sizeof remote4);
12165 memset (&local6, 0, sizeof local6);
12166 memset (&remote6, 0, sizeof remote6);
12168 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12170 if (unformat (line_input, "del"))
12172 else if (unformat (line_input, "local %U",
12173 unformat_ip4_address, &local4))
12178 else if (unformat (line_input, "remote %U",
12179 unformat_ip4_address, &remote4))
12184 else if (unformat (line_input, "local %U",
12185 unformat_ip6_address, &local6))
12190 else if (unformat (line_input, "remote %U",
12191 unformat_ip6_address, &remote6))
12196 else if (unformat (line_input, "group %U %U",
12197 unformat_ip4_address, &remote4,
12198 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12200 grp_set = remote_set = 1;
12203 else if (unformat (line_input, "group %U",
12204 unformat_ip4_address, &remote4))
12206 grp_set = remote_set = 1;
12209 else if (unformat (line_input, "group %U %U",
12210 unformat_ip6_address, &remote6,
12211 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12213 grp_set = remote_set = 1;
12216 else if (unformat (line_input, "group %U",
12217 unformat_ip6_address, &remote6))
12219 grp_set = remote_set = 1;
12223 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12225 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12227 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12229 else if (unformat (line_input, "vni %d", &vni))
12231 else if (unformat (line_input, "next-ip4"))
12233 else if (unformat (line_input, "next-ip6"))
12235 else if (unformat (line_input, "next-ethernet"))
12237 else if (unformat (line_input, "next-nsh"))
12241 errmsg ("parse error '%U'", format_unformat_error, line_input);
12246 if (local_set == 0)
12248 errmsg ("tunnel local address not specified");
12251 if (remote_set == 0)
12253 errmsg ("tunnel remote address not specified");
12256 if (grp_set && mcast_sw_if_index == ~0)
12258 errmsg ("tunnel nonexistent multicast device");
12261 if (ipv4_set && ipv6_set)
12263 errmsg ("both IPv4 and IPv6 addresses specified");
12269 errmsg ("vni not specified");
12273 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12278 clib_memcpy (&mp->local, &local6, sizeof (local6));
12279 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12283 clib_memcpy (&mp->local, &local4, sizeof (local4));
12284 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12287 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12288 mp->encap_vrf_id = ntohl (encap_vrf_id);
12289 mp->decap_vrf_id = ntohl (decap_vrf_id);
12290 mp->protocol = protocol;
12291 mp->vni = ntohl (vni);
12292 mp->is_add = is_add;
12293 mp->is_ipv6 = ipv6_set;
12300 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12301 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12303 vat_main_t *vam = &vat_main;
12304 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12305 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12307 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12308 ntohl (mp->sw_if_index),
12309 format_ip46_address, &local, IP46_TYPE_ANY,
12310 format_ip46_address, &remote, IP46_TYPE_ANY,
12311 ntohl (mp->vni), mp->protocol,
12312 ntohl (mp->mcast_sw_if_index),
12313 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12317 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12318 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12320 vat_main_t *vam = &vat_main;
12321 vat_json_node_t *node = NULL;
12322 struct in_addr ip4;
12323 struct in6_addr ip6;
12325 if (VAT_JSON_ARRAY != vam->json_tree.type)
12327 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12328 vat_json_init_array (&vam->json_tree);
12330 node = vat_json_array_add (&vam->json_tree);
12332 vat_json_init_object (node);
12333 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12336 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12337 vat_json_object_add_ip6 (node, "local", ip6);
12338 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12339 vat_json_object_add_ip6 (node, "remote", ip6);
12343 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12344 vat_json_object_add_ip4 (node, "local", ip4);
12345 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12346 vat_json_object_add_ip4 (node, "remote", ip4);
12348 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12349 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12350 vat_json_object_add_uint (node, "mcast_sw_if_index",
12351 ntohl (mp->mcast_sw_if_index));
12352 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12353 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12354 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12358 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12360 unformat_input_t *i = vam->input;
12361 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12362 vl_api_control_ping_t *mp_ping;
12364 u8 sw_if_index_set = 0;
12367 /* Parse args required to build the message */
12368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12370 if (unformat (i, "sw_if_index %d", &sw_if_index))
12371 sw_if_index_set = 1;
12376 if (sw_if_index_set == 0)
12381 if (!vam->json_output)
12383 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12384 "sw_if_index", "local", "remote", "vni",
12385 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12388 /* Get list of vxlan-tunnel interfaces */
12389 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12391 mp->sw_if_index = htonl (sw_if_index);
12395 /* Use a control ping for synchronization */
12396 M (CONTROL_PING, mp_ping);
12405 format_l2_fib_mac_address (u8 * s, va_list * args)
12407 u8 *a = va_arg (*args, u8 *);
12409 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
12410 a[2], a[3], a[4], a[5], a[6], a[7]);
12413 static void vl_api_l2_fib_table_details_t_handler
12414 (vl_api_l2_fib_table_details_t * mp)
12416 vat_main_t *vam = &vat_main;
12418 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12420 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
12421 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12425 static void vl_api_l2_fib_table_details_t_handler_json
12426 (vl_api_l2_fib_table_details_t * mp)
12428 vat_main_t *vam = &vat_main;
12429 vat_json_node_t *node = NULL;
12431 if (VAT_JSON_ARRAY != vam->json_tree.type)
12433 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12434 vat_json_init_array (&vam->json_tree);
12436 node = vat_json_array_add (&vam->json_tree);
12438 vat_json_init_object (node);
12439 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12440 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
12441 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12442 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12443 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12444 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12448 api_l2_fib_table_dump (vat_main_t * vam)
12450 unformat_input_t *i = vam->input;
12451 vl_api_l2_fib_table_dump_t *mp;
12452 vl_api_control_ping_t *mp_ping;
12457 /* Parse args required to build the message */
12458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12460 if (unformat (i, "bd_id %d", &bd_id))
12466 if (bd_id_set == 0)
12468 errmsg ("missing bridge domain");
12472 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12474 /* Get list of l2 fib entries */
12475 M (L2_FIB_TABLE_DUMP, mp);
12477 mp->bd_id = ntohl (bd_id);
12480 /* Use a control ping for synchronization */
12481 M (CONTROL_PING, mp_ping);
12490 api_interface_name_renumber (vat_main_t * vam)
12492 unformat_input_t *line_input = vam->input;
12493 vl_api_interface_name_renumber_t *mp;
12494 u32 sw_if_index = ~0;
12495 u32 new_show_dev_instance = ~0;
12498 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12500 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
12503 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12505 else if (unformat (line_input, "new_show_dev_instance %d",
12506 &new_show_dev_instance))
12512 if (sw_if_index == ~0)
12514 errmsg ("missing interface name or sw_if_index");
12518 if (new_show_dev_instance == ~0)
12520 errmsg ("missing new_show_dev_instance");
12524 M (INTERFACE_NAME_RENUMBER, mp);
12526 mp->sw_if_index = ntohl (sw_if_index);
12527 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
12535 api_want_ip4_arp_events (vat_main_t * vam)
12537 unformat_input_t *line_input = vam->input;
12538 vl_api_want_ip4_arp_events_t *mp;
12539 ip4_address_t address;
12540 int address_set = 0;
12541 u32 enable_disable = 1;
12544 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12546 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
12548 else if (unformat (line_input, "del"))
12549 enable_disable = 0;
12554 if (address_set == 0)
12556 errmsg ("missing addresses");
12560 M (WANT_IP4_ARP_EVENTS, mp);
12561 mp->enable_disable = enable_disable;
12562 mp->pid = htonl (getpid ());
12563 mp->address = address.as_u32;
12571 api_want_ip6_nd_events (vat_main_t * vam)
12573 unformat_input_t *line_input = vam->input;
12574 vl_api_want_ip6_nd_events_t *mp;
12575 ip6_address_t address;
12576 int address_set = 0;
12577 u32 enable_disable = 1;
12580 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12582 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
12584 else if (unformat (line_input, "del"))
12585 enable_disable = 0;
12590 if (address_set == 0)
12592 errmsg ("missing addresses");
12596 M (WANT_IP6_ND_EVENTS, mp);
12597 mp->enable_disable = enable_disable;
12598 mp->pid = htonl (getpid ());
12599 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
12607 api_want_l2_macs_events (vat_main_t * vam)
12609 unformat_input_t *line_input = vam->input;
12610 vl_api_want_l2_macs_events_t *mp;
12611 u8 enable_disable = 1;
12612 u32 scan_delay = 0;
12613 u32 max_macs_in_event = 0;
12614 u32 learn_limit = 0;
12617 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12619 if (unformat (line_input, "learn-limit %d", &learn_limit))
12621 else if (unformat (line_input, "scan-delay %d", &scan_delay))
12623 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
12625 else if (unformat (line_input, "disable"))
12626 enable_disable = 0;
12631 M (WANT_L2_MACS_EVENTS, mp);
12632 mp->enable_disable = enable_disable;
12633 mp->pid = htonl (getpid ());
12634 mp->learn_limit = htonl (learn_limit);
12635 mp->scan_delay = (u8) scan_delay;
12636 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
12643 api_input_acl_set_interface (vat_main_t * vam)
12645 unformat_input_t *i = vam->input;
12646 vl_api_input_acl_set_interface_t *mp;
12648 int sw_if_index_set;
12649 u32 ip4_table_index = ~0;
12650 u32 ip6_table_index = ~0;
12651 u32 l2_table_index = ~0;
12655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12657 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12658 sw_if_index_set = 1;
12659 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12660 sw_if_index_set = 1;
12661 else if (unformat (i, "del"))
12663 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12665 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12667 else if (unformat (i, "l2-table %d", &l2_table_index))
12671 clib_warning ("parse error '%U'", format_unformat_error, i);
12676 if (sw_if_index_set == 0)
12678 errmsg ("missing interface name or sw_if_index");
12682 M (INPUT_ACL_SET_INTERFACE, mp);
12684 mp->sw_if_index = ntohl (sw_if_index);
12685 mp->ip4_table_index = ntohl (ip4_table_index);
12686 mp->ip6_table_index = ntohl (ip6_table_index);
12687 mp->l2_table_index = ntohl (l2_table_index);
12688 mp->is_add = is_add;
12696 api_ip_address_dump (vat_main_t * vam)
12698 unformat_input_t *i = vam->input;
12699 vl_api_ip_address_dump_t *mp;
12700 vl_api_control_ping_t *mp_ping;
12701 u32 sw_if_index = ~0;
12702 u8 sw_if_index_set = 0;
12707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12709 if (unformat (i, "sw_if_index %d", &sw_if_index))
12710 sw_if_index_set = 1;
12712 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12713 sw_if_index_set = 1;
12714 else if (unformat (i, "ipv4"))
12716 else if (unformat (i, "ipv6"))
12722 if (ipv4_set && ipv6_set)
12724 errmsg ("ipv4 and ipv6 flags cannot be both set");
12728 if ((!ipv4_set) && (!ipv6_set))
12730 errmsg ("no ipv4 nor ipv6 flag set");
12734 if (sw_if_index_set == 0)
12736 errmsg ("missing interface name or sw_if_index");
12740 vam->current_sw_if_index = sw_if_index;
12741 vam->is_ipv6 = ipv6_set;
12743 M (IP_ADDRESS_DUMP, mp);
12744 mp->sw_if_index = ntohl (sw_if_index);
12745 mp->is_ipv6 = ipv6_set;
12748 /* Use a control ping for synchronization */
12749 M (CONTROL_PING, mp_ping);
12757 api_ip_dump (vat_main_t * vam)
12759 vl_api_ip_dump_t *mp;
12760 vl_api_control_ping_t *mp_ping;
12761 unformat_input_t *in = vam->input;
12768 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
12770 if (unformat (in, "ipv4"))
12772 else if (unformat (in, "ipv6"))
12778 if (ipv4_set && ipv6_set)
12780 errmsg ("ipv4 and ipv6 flags cannot be both set");
12784 if ((!ipv4_set) && (!ipv6_set))
12786 errmsg ("no ipv4 nor ipv6 flag set");
12790 is_ipv6 = ipv6_set;
12791 vam->is_ipv6 = is_ipv6;
12793 /* free old data */
12794 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12796 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12798 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12801 mp->is_ipv6 = ipv6_set;
12804 /* Use a control ping for synchronization */
12805 M (CONTROL_PING, mp_ping);
12813 api_ipsec_spd_add_del (vat_main_t * vam)
12815 unformat_input_t *i = vam->input;
12816 vl_api_ipsec_spd_add_del_t *mp;
12821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12823 if (unformat (i, "spd_id %d", &spd_id))
12825 else if (unformat (i, "del"))
12829 clib_warning ("parse error '%U'", format_unformat_error, i);
12835 errmsg ("spd_id must be set");
12839 M (IPSEC_SPD_ADD_DEL, mp);
12841 mp->spd_id = ntohl (spd_id);
12842 mp->is_add = is_add;
12850 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12852 unformat_input_t *i = vam->input;
12853 vl_api_ipsec_interface_add_del_spd_t *mp;
12855 u8 sw_if_index_set = 0;
12856 u32 spd_id = (u32) ~ 0;
12860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12862 if (unformat (i, "del"))
12864 else if (unformat (i, "spd_id %d", &spd_id))
12867 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12868 sw_if_index_set = 1;
12869 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12870 sw_if_index_set = 1;
12873 clib_warning ("parse error '%U'", format_unformat_error, i);
12879 if (spd_id == (u32) ~ 0)
12881 errmsg ("spd_id must be set");
12885 if (sw_if_index_set == 0)
12887 errmsg ("missing interface name or sw_if_index");
12891 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12893 mp->spd_id = ntohl (spd_id);
12894 mp->sw_if_index = ntohl (sw_if_index);
12895 mp->is_add = is_add;
12903 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12905 unformat_input_t *i = vam->input;
12906 vl_api_ipsec_spd_add_del_entry_t *mp;
12907 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12908 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12910 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12911 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12912 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12913 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12916 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12917 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12918 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12919 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12920 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12921 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12925 if (unformat (i, "del"))
12927 if (unformat (i, "outbound"))
12929 if (unformat (i, "inbound"))
12931 else if (unformat (i, "spd_id %d", &spd_id))
12933 else if (unformat (i, "sa_id %d", &sa_id))
12935 else if (unformat (i, "priority %d", &priority))
12937 else if (unformat (i, "protocol %d", &protocol))
12939 else if (unformat (i, "lport_start %d", &lport_start))
12941 else if (unformat (i, "lport_stop %d", &lport_stop))
12943 else if (unformat (i, "rport_start %d", &rport_start))
12945 else if (unformat (i, "rport_stop %d", &rport_stop))
12949 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12955 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12962 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12968 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12975 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12981 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12988 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12994 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
13000 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13002 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13004 clib_warning ("unsupported action: 'resolve'");
13010 clib_warning ("parse error '%U'", format_unformat_error, i);
13016 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
13018 mp->spd_id = ntohl (spd_id);
13019 mp->priority = ntohl (priority);
13020 mp->is_outbound = is_outbound;
13022 mp->is_ipv6 = is_ipv6;
13023 if (is_ipv6 || is_ip_any)
13025 clib_memcpy (mp->remote_address_start, &raddr6_start,
13026 sizeof (ip6_address_t));
13027 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
13028 sizeof (ip6_address_t));
13029 clib_memcpy (mp->local_address_start, &laddr6_start,
13030 sizeof (ip6_address_t));
13031 clib_memcpy (mp->local_address_stop, &laddr6_stop,
13032 sizeof (ip6_address_t));
13036 clib_memcpy (mp->remote_address_start, &raddr4_start,
13037 sizeof (ip4_address_t));
13038 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
13039 sizeof (ip4_address_t));
13040 clib_memcpy (mp->local_address_start, &laddr4_start,
13041 sizeof (ip4_address_t));
13042 clib_memcpy (mp->local_address_stop, &laddr4_stop,
13043 sizeof (ip4_address_t));
13045 mp->protocol = (u8) protocol;
13046 mp->local_port_start = ntohs ((u16) lport_start);
13047 mp->local_port_stop = ntohs ((u16) lport_stop);
13048 mp->remote_port_start = ntohs ((u16) rport_start);
13049 mp->remote_port_stop = ntohs ((u16) rport_stop);
13050 mp->policy = (u8) policy;
13051 mp->sa_id = ntohl (sa_id);
13052 mp->is_add = is_add;
13053 mp->is_ip_any = is_ip_any;
13060 api_ipsec_sad_add_del_entry (vat_main_t * vam)
13062 unformat_input_t *i = vam->input;
13063 vl_api_ipsec_sad_add_del_entry_t *mp;
13064 u32 sad_id = 0, spi = 0;
13065 u8 *ck = 0, *ik = 0;
13068 u8 protocol = IPSEC_PROTOCOL_AH;
13069 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
13070 u32 crypto_alg = 0, integ_alg = 0;
13071 ip4_address_t tun_src4;
13072 ip4_address_t tun_dst4;
13073 ip6_address_t tun_src6;
13074 ip6_address_t tun_dst6;
13077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13079 if (unformat (i, "del"))
13081 else if (unformat (i, "sad_id %d", &sad_id))
13083 else if (unformat (i, "spi %d", &spi))
13085 else if (unformat (i, "esp"))
13086 protocol = IPSEC_PROTOCOL_ESP;
13087 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
13090 is_tunnel_ipv6 = 0;
13092 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
13095 is_tunnel_ipv6 = 0;
13097 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
13100 is_tunnel_ipv6 = 1;
13102 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
13105 is_tunnel_ipv6 = 1;
13109 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
13111 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
13112 crypto_alg >= IPSEC_CRYPTO_N_ALG)
13114 clib_warning ("unsupported crypto-alg: '%U'",
13115 format_ipsec_crypto_alg, crypto_alg);
13119 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13123 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
13125 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
13126 integ_alg >= IPSEC_INTEG_N_ALG)
13128 clib_warning ("unsupported integ-alg: '%U'",
13129 format_ipsec_integ_alg, integ_alg);
13133 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13137 clib_warning ("parse error '%U'", format_unformat_error, i);
13143 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
13145 mp->sad_id = ntohl (sad_id);
13146 mp->is_add = is_add;
13147 mp->protocol = protocol;
13148 mp->spi = ntohl (spi);
13149 mp->is_tunnel = is_tunnel;
13150 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
13151 mp->crypto_algorithm = crypto_alg;
13152 mp->integrity_algorithm = integ_alg;
13153 mp->crypto_key_length = vec_len (ck);
13154 mp->integrity_key_length = vec_len (ik);
13156 if (mp->crypto_key_length > sizeof (mp->crypto_key))
13157 mp->crypto_key_length = sizeof (mp->crypto_key);
13159 if (mp->integrity_key_length > sizeof (mp->integrity_key))
13160 mp->integrity_key_length = sizeof (mp->integrity_key);
13163 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
13165 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
13169 if (is_tunnel_ipv6)
13171 clib_memcpy (mp->tunnel_src_address, &tun_src6,
13172 sizeof (ip6_address_t));
13173 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
13174 sizeof (ip6_address_t));
13178 clib_memcpy (mp->tunnel_src_address, &tun_src4,
13179 sizeof (ip4_address_t));
13180 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
13181 sizeof (ip4_address_t));
13191 api_ipsec_sa_set_key (vat_main_t * vam)
13193 unformat_input_t *i = vam->input;
13194 vl_api_ipsec_sa_set_key_t *mp;
13196 u8 *ck = 0, *ik = 0;
13199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13201 if (unformat (i, "sa_id %d", &sa_id))
13203 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13205 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13209 clib_warning ("parse error '%U'", format_unformat_error, i);
13214 M (IPSEC_SA_SET_KEY, mp);
13216 mp->sa_id = ntohl (sa_id);
13217 mp->crypto_key_length = vec_len (ck);
13218 mp->integrity_key_length = vec_len (ik);
13220 if (mp->crypto_key_length > sizeof (mp->crypto_key))
13221 mp->crypto_key_length = sizeof (mp->crypto_key);
13223 if (mp->integrity_key_length > sizeof (mp->integrity_key))
13224 mp->integrity_key_length = sizeof (mp->integrity_key);
13227 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
13229 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
13237 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13239 unformat_input_t *i = vam->input;
13240 vl_api_ipsec_tunnel_if_add_del_t *mp;
13241 u32 local_spi = 0, remote_spi = 0;
13242 u32 crypto_alg = 0, integ_alg = 0;
13243 u8 *lck = NULL, *rck = NULL;
13244 u8 *lik = NULL, *rik = NULL;
13245 ip4_address_t local_ip = { {0} };
13246 ip4_address_t remote_ip = { {0} };
13249 u8 anti_replay = 0;
13252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13254 if (unformat (i, "del"))
13256 else if (unformat (i, "esn"))
13258 else if (unformat (i, "anti_replay"))
13260 else if (unformat (i, "local_spi %d", &local_spi))
13262 else if (unformat (i, "remote_spi %d", &remote_spi))
13264 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
13266 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
13268 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13271 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13273 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13275 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13279 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
13281 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
13282 crypto_alg >= IPSEC_CRYPTO_N_ALG)
13284 errmsg ("unsupported crypto-alg: '%U'\n",
13285 format_ipsec_crypto_alg, crypto_alg);
13291 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
13293 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
13294 integ_alg >= IPSEC_INTEG_N_ALG)
13296 errmsg ("unsupported integ-alg: '%U'\n",
13297 format_ipsec_integ_alg, integ_alg);
13303 errmsg ("parse error '%U'\n", format_unformat_error, i);
13308 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13310 mp->is_add = is_add;
13312 mp->anti_replay = anti_replay;
13314 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
13315 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
13317 mp->local_spi = htonl (local_spi);
13318 mp->remote_spi = htonl (remote_spi);
13319 mp->crypto_alg = (u8) crypto_alg;
13321 mp->local_crypto_key_len = 0;
13324 mp->local_crypto_key_len = vec_len (lck);
13325 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13326 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13327 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13330 mp->remote_crypto_key_len = 0;
13333 mp->remote_crypto_key_len = vec_len (rck);
13334 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13335 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13336 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13339 mp->integ_alg = (u8) integ_alg;
13341 mp->local_integ_key_len = 0;
13344 mp->local_integ_key_len = vec_len (lik);
13345 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13346 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13347 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13350 mp->remote_integ_key_len = 0;
13353 mp->remote_integ_key_len = vec_len (rik);
13354 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13355 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13356 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13365 api_ikev2_profile_add_del (vat_main_t * vam)
13367 unformat_input_t *i = vam->input;
13368 vl_api_ikev2_profile_add_del_t *mp;
13373 const char *valid_chars = "a-zA-Z0-9_";
13375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13377 if (unformat (i, "del"))
13379 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13380 vec_add1 (name, 0);
13383 errmsg ("parse error '%U'", format_unformat_error, i);
13388 if (!vec_len (name))
13390 errmsg ("profile name must be specified");
13394 if (vec_len (name) > 64)
13396 errmsg ("profile name too long");
13400 M (IKEV2_PROFILE_ADD_DEL, mp);
13402 clib_memcpy (mp->name, name, vec_len (name));
13403 mp->is_add = is_add;
13412 api_ikev2_profile_set_auth (vat_main_t * vam)
13414 unformat_input_t *i = vam->input;
13415 vl_api_ikev2_profile_set_auth_t *mp;
13418 u32 auth_method = 0;
13422 const char *valid_chars = "a-zA-Z0-9_";
13424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13426 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13427 vec_add1 (name, 0);
13428 else if (unformat (i, "auth_method %U",
13429 unformat_ikev2_auth_method, &auth_method))
13431 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
13433 else if (unformat (i, "auth_data %v", &data))
13437 errmsg ("parse error '%U'", format_unformat_error, i);
13442 if (!vec_len (name))
13444 errmsg ("profile name must be specified");
13448 if (vec_len (name) > 64)
13450 errmsg ("profile name too long");
13454 if (!vec_len (data))
13456 errmsg ("auth_data must be specified");
13462 errmsg ("auth_method must be specified");
13466 M (IKEV2_PROFILE_SET_AUTH, mp);
13468 mp->is_hex = is_hex;
13469 mp->auth_method = (u8) auth_method;
13470 mp->data_len = vec_len (data);
13471 clib_memcpy (mp->name, name, vec_len (name));
13472 clib_memcpy (mp->data, data, vec_len (data));
13482 api_ikev2_profile_set_id (vat_main_t * vam)
13484 unformat_input_t *i = vam->input;
13485 vl_api_ikev2_profile_set_id_t *mp;
13493 const char *valid_chars = "a-zA-Z0-9_";
13495 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13497 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13498 vec_add1 (name, 0);
13499 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
13501 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
13503 data = vec_new (u8, 4);
13504 clib_memcpy (data, ip4.as_u8, 4);
13506 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
13508 else if (unformat (i, "id_data %v", &data))
13510 else if (unformat (i, "local"))
13512 else if (unformat (i, "remote"))
13516 errmsg ("parse error '%U'", format_unformat_error, i);
13521 if (!vec_len (name))
13523 errmsg ("profile name must be specified");
13527 if (vec_len (name) > 64)
13529 errmsg ("profile name too long");
13533 if (!vec_len (data))
13535 errmsg ("id_data must be specified");
13541 errmsg ("id_type must be specified");
13545 M (IKEV2_PROFILE_SET_ID, mp);
13547 mp->is_local = is_local;
13548 mp->id_type = (u8) id_type;
13549 mp->data_len = vec_len (data);
13550 clib_memcpy (mp->name, name, vec_len (name));
13551 clib_memcpy (mp->data, data, vec_len (data));
13561 api_ikev2_profile_set_ts (vat_main_t * vam)
13563 unformat_input_t *i = vam->input;
13564 vl_api_ikev2_profile_set_ts_t *mp;
13567 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
13568 ip4_address_t start_addr, end_addr;
13570 const char *valid_chars = "a-zA-Z0-9_";
13573 start_addr.as_u32 = 0;
13574 end_addr.as_u32 = (u32) ~ 0;
13576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13578 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
13579 vec_add1 (name, 0);
13580 else if (unformat (i, "protocol %d", &proto))
13582 else if (unformat (i, "start_port %d", &start_port))
13584 else if (unformat (i, "end_port %d", &end_port))
13587 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
13589 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
13591 else if (unformat (i, "local"))
13593 else if (unformat (i, "remote"))
13597 errmsg ("parse error '%U'", format_unformat_error, i);
13602 if (!vec_len (name))
13604 errmsg ("profile name must be specified");
13608 if (vec_len (name) > 64)
13610 errmsg ("profile name too long");
13614 M (IKEV2_PROFILE_SET_TS, mp);
13616 mp->is_local = is_local;
13617 mp->proto = (u8) proto;
13618 mp->start_port = (u16) start_port;
13619 mp->end_port = (u16) end_port;
13620 mp->start_addr = start_addr.as_u32;
13621 mp->end_addr = end_addr.as_u32;
13622 clib_memcpy (mp->name, name, vec_len (name));
13631 api_ikev2_set_local_key (vat_main_t * vam)
13633 unformat_input_t *i = vam->input;
13634 vl_api_ikev2_set_local_key_t *mp;
13638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13640 if (unformat (i, "file %v", &file))
13641 vec_add1 (file, 0);
13644 errmsg ("parse error '%U'", format_unformat_error, i);
13649 if (!vec_len (file))
13651 errmsg ("RSA key file must be specified");
13655 if (vec_len (file) > 256)
13657 errmsg ("file name too long");
13661 M (IKEV2_SET_LOCAL_KEY, mp);
13663 clib_memcpy (mp->key_file, file, vec_len (file));
13672 api_ikev2_set_responder (vat_main_t * vam)
13674 unformat_input_t *i = vam->input;
13675 vl_api_ikev2_set_responder_t *mp;
13678 u32 sw_if_index = ~0;
13679 ip4_address_t address;
13681 const char *valid_chars = "a-zA-Z0-9_";
13683 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13686 (i, "%U interface %d address %U", unformat_token, valid_chars,
13687 &name, &sw_if_index, unformat_ip4_address, &address))
13688 vec_add1 (name, 0);
13691 errmsg ("parse error '%U'", format_unformat_error, i);
13696 if (!vec_len (name))
13698 errmsg ("profile name must be specified");
13702 if (vec_len (name) > 64)
13704 errmsg ("profile name too long");
13708 M (IKEV2_SET_RESPONDER, mp);
13710 clib_memcpy (mp->name, name, vec_len (name));
13713 mp->sw_if_index = sw_if_index;
13714 clib_memcpy (mp->address, &address, sizeof (address));
13722 api_ikev2_set_ike_transforms (vat_main_t * vam)
13724 unformat_input_t *i = vam->input;
13725 vl_api_ikev2_set_ike_transforms_t *mp;
13728 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13730 const char *valid_chars = "a-zA-Z0-9_";
13732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13734 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13735 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13736 vec_add1 (name, 0);
13739 errmsg ("parse error '%U'", format_unformat_error, i);
13744 if (!vec_len (name))
13746 errmsg ("profile name must be specified");
13750 if (vec_len (name) > 64)
13752 errmsg ("profile name too long");
13756 M (IKEV2_SET_IKE_TRANSFORMS, mp);
13758 clib_memcpy (mp->name, name, vec_len (name));
13760 mp->crypto_alg = crypto_alg;
13761 mp->crypto_key_size = crypto_key_size;
13762 mp->integ_alg = integ_alg;
13763 mp->dh_group = dh_group;
13772 api_ikev2_set_esp_transforms (vat_main_t * vam)
13774 unformat_input_t *i = vam->input;
13775 vl_api_ikev2_set_esp_transforms_t *mp;
13778 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13780 const char *valid_chars = "a-zA-Z0-9_";
13782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13784 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13785 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13786 vec_add1 (name, 0);
13789 errmsg ("parse error '%U'", format_unformat_error, i);
13794 if (!vec_len (name))
13796 errmsg ("profile name must be specified");
13800 if (vec_len (name) > 64)
13802 errmsg ("profile name too long");
13806 M (IKEV2_SET_ESP_TRANSFORMS, mp);
13808 clib_memcpy (mp->name, name, vec_len (name));
13810 mp->crypto_alg = crypto_alg;
13811 mp->crypto_key_size = crypto_key_size;
13812 mp->integ_alg = integ_alg;
13813 mp->dh_group = dh_group;
13821 api_ikev2_set_sa_lifetime (vat_main_t * vam)
13823 unformat_input_t *i = vam->input;
13824 vl_api_ikev2_set_sa_lifetime_t *mp;
13827 u64 lifetime, lifetime_maxdata;
13828 u32 lifetime_jitter, handover;
13830 const char *valid_chars = "a-zA-Z0-9_";
13832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13834 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
13835 &lifetime, &lifetime_jitter, &handover,
13836 &lifetime_maxdata))
13837 vec_add1 (name, 0);
13840 errmsg ("parse error '%U'", format_unformat_error, i);
13845 if (!vec_len (name))
13847 errmsg ("profile name must be specified");
13851 if (vec_len (name) > 64)
13853 errmsg ("profile name too long");
13857 M (IKEV2_SET_SA_LIFETIME, mp);
13859 clib_memcpy (mp->name, name, vec_len (name));
13861 mp->lifetime = lifetime;
13862 mp->lifetime_jitter = lifetime_jitter;
13863 mp->handover = handover;
13864 mp->lifetime_maxdata = lifetime_maxdata;
13872 api_ikev2_initiate_sa_init (vat_main_t * vam)
13874 unformat_input_t *i = vam->input;
13875 vl_api_ikev2_initiate_sa_init_t *mp;
13879 const char *valid_chars = "a-zA-Z0-9_";
13881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13883 if (unformat (i, "%U", unformat_token, valid_chars, &name))
13884 vec_add1 (name, 0);
13887 errmsg ("parse error '%U'", format_unformat_error, i);
13892 if (!vec_len (name))
13894 errmsg ("profile name must be specified");
13898 if (vec_len (name) > 64)
13900 errmsg ("profile name too long");
13904 M (IKEV2_INITIATE_SA_INIT, mp);
13906 clib_memcpy (mp->name, name, vec_len (name));
13915 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
13917 unformat_input_t *i = vam->input;
13918 vl_api_ikev2_initiate_del_ike_sa_t *mp;
13923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13925 if (unformat (i, "%lx", &ispi))
13929 errmsg ("parse error '%U'", format_unformat_error, i);
13934 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
13944 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
13946 unformat_input_t *i = vam->input;
13947 vl_api_ikev2_initiate_del_child_sa_t *mp;
13952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13954 if (unformat (i, "%x", &ispi))
13958 errmsg ("parse error '%U'", format_unformat_error, i);
13963 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
13973 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
13975 unformat_input_t *i = vam->input;
13976 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
13981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13983 if (unformat (i, "%x", &ispi))
13987 errmsg ("parse error '%U'", format_unformat_error, i);
13992 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
14005 api_map_add_domain (vat_main_t * vam)
14007 unformat_input_t *i = vam->input;
14008 vl_api_map_add_domain_t *mp;
14010 ip4_address_t ip4_prefix;
14011 ip6_address_t ip6_prefix;
14012 ip6_address_t ip6_src;
14013 u32 num_m_args = 0;
14014 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
14015 0, psid_length = 0;
14016 u8 is_translation = 0;
14018 u32 ip6_src_len = 128;
14021 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14023 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
14024 &ip4_prefix, &ip4_prefix_len))
14026 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
14027 &ip6_prefix, &ip6_prefix_len))
14031 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
14034 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
14036 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
14038 else if (unformat (i, "psid-offset %d", &psid_offset))
14040 else if (unformat (i, "psid-len %d", &psid_length))
14042 else if (unformat (i, "mtu %d", &mtu))
14044 else if (unformat (i, "map-t"))
14045 is_translation = 1;
14048 clib_warning ("parse error '%U'", format_unformat_error, i);
14053 if (num_m_args < 3)
14055 errmsg ("mandatory argument(s) missing");
14059 /* Construct the API message */
14060 M (MAP_ADD_DOMAIN, mp);
14062 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
14063 mp->ip4_prefix_len = ip4_prefix_len;
14065 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
14066 mp->ip6_prefix_len = ip6_prefix_len;
14068 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
14069 mp->ip6_src_prefix_len = ip6_src_len;
14071 mp->ea_bits_len = ea_bits_len;
14072 mp->psid_offset = psid_offset;
14073 mp->psid_length = psid_length;
14074 mp->is_translation = is_translation;
14075 mp->mtu = htons (mtu);
14080 /* Wait for a reply, return good/bad news */
14086 api_map_del_domain (vat_main_t * vam)
14088 unformat_input_t *i = vam->input;
14089 vl_api_map_del_domain_t *mp;
14091 u32 num_m_args = 0;
14095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14097 if (unformat (i, "index %d", &index))
14101 clib_warning ("parse error '%U'", format_unformat_error, i);
14106 if (num_m_args != 1)
14108 errmsg ("mandatory argument(s) missing");
14112 /* Construct the API message */
14113 M (MAP_DEL_DOMAIN, mp);
14115 mp->index = ntohl (index);
14120 /* Wait for a reply, return good/bad news */
14126 api_map_add_del_rule (vat_main_t * vam)
14128 unformat_input_t *i = vam->input;
14129 vl_api_map_add_del_rule_t *mp;
14131 ip6_address_t ip6_dst;
14132 u32 num_m_args = 0, index, psid = 0;
14135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14137 if (unformat (i, "index %d", &index))
14139 else if (unformat (i, "psid %d", &psid))
14141 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
14143 else if (unformat (i, "del"))
14149 clib_warning ("parse error '%U'", format_unformat_error, i);
14154 /* Construct the API message */
14155 M (MAP_ADD_DEL_RULE, mp);
14157 mp->index = ntohl (index);
14158 mp->is_add = is_add;
14159 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
14160 mp->psid = ntohs (psid);
14165 /* Wait for a reply, return good/bad news */
14171 api_map_domain_dump (vat_main_t * vam)
14173 vl_api_map_domain_dump_t *mp;
14174 vl_api_control_ping_t *mp_ping;
14177 /* Construct the API message */
14178 M (MAP_DOMAIN_DUMP, mp);
14183 /* Use a control ping for synchronization */
14184 M (CONTROL_PING, mp_ping);
14192 api_map_rule_dump (vat_main_t * vam)
14194 unformat_input_t *i = vam->input;
14195 vl_api_map_rule_dump_t *mp;
14196 vl_api_control_ping_t *mp_ping;
14197 u32 domain_index = ~0;
14200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14202 if (unformat (i, "index %u", &domain_index))
14208 if (domain_index == ~0)
14210 clib_warning ("parse error: domain index expected");
14214 /* Construct the API message */
14215 M (MAP_RULE_DUMP, mp);
14217 mp->domain_index = htonl (domain_index);
14222 /* Use a control ping for synchronization */
14223 M (CONTROL_PING, mp_ping);
14230 static void vl_api_map_add_domain_reply_t_handler
14231 (vl_api_map_add_domain_reply_t * mp)
14233 vat_main_t *vam = &vat_main;
14234 i32 retval = ntohl (mp->retval);
14236 if (vam->async_mode)
14238 vam->async_errors += (retval < 0);
14242 vam->retval = retval;
14243 vam->result_ready = 1;
14247 static void vl_api_map_add_domain_reply_t_handler_json
14248 (vl_api_map_add_domain_reply_t * mp)
14250 vat_main_t *vam = &vat_main;
14251 vat_json_node_t node;
14253 vat_json_init_object (&node);
14254 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
14255 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
14257 vat_json_print (vam->ofp, &node);
14258 vat_json_free (&node);
14260 vam->retval = ntohl (mp->retval);
14261 vam->result_ready = 1;
14265 api_get_first_msg_id (vat_main_t * vam)
14267 vl_api_get_first_msg_id_t *mp;
14268 unformat_input_t *i = vam->input;
14273 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14275 if (unformat (i, "client %s", &name))
14283 errmsg ("missing client name");
14286 vec_add1 (name, 0);
14288 if (vec_len (name) > 63)
14290 errmsg ("client name too long");
14294 M (GET_FIRST_MSG_ID, mp);
14295 clib_memcpy (mp->name, name, vec_len (name));
14302 api_cop_interface_enable_disable (vat_main_t * vam)
14304 unformat_input_t *line_input = vam->input;
14305 vl_api_cop_interface_enable_disable_t *mp;
14306 u32 sw_if_index = ~0;
14307 u8 enable_disable = 1;
14310 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14312 if (unformat (line_input, "disable"))
14313 enable_disable = 0;
14314 if (unformat (line_input, "enable"))
14315 enable_disable = 1;
14316 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14317 vam, &sw_if_index))
14319 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14325 if (sw_if_index == ~0)
14327 errmsg ("missing interface name or sw_if_index");
14331 /* Construct the API message */
14332 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14333 mp->sw_if_index = ntohl (sw_if_index);
14334 mp->enable_disable = enable_disable;
14338 /* Wait for the reply */
14344 api_cop_whitelist_enable_disable (vat_main_t * vam)
14346 unformat_input_t *line_input = vam->input;
14347 vl_api_cop_whitelist_enable_disable_t *mp;
14348 u32 sw_if_index = ~0;
14349 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14353 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14355 if (unformat (line_input, "ip4"))
14357 else if (unformat (line_input, "ip6"))
14359 else if (unformat (line_input, "default"))
14361 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14362 vam, &sw_if_index))
14364 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14366 else if (unformat (line_input, "fib-id %d", &fib_id))
14372 if (sw_if_index == ~0)
14374 errmsg ("missing interface name or sw_if_index");
14378 /* Construct the API message */
14379 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14380 mp->sw_if_index = ntohl (sw_if_index);
14381 mp->fib_id = ntohl (fib_id);
14384 mp->default_cop = default_cop;
14388 /* Wait for the reply */
14394 api_get_node_graph (vat_main_t * vam)
14396 vl_api_get_node_graph_t *mp;
14399 M (GET_NODE_GRAPH, mp);
14403 /* Wait for the reply */
14409 /** Used for parsing LISP eids */
14410 typedef CLIB_PACKED(struct{
14411 u8 addr[16]; /**< eid address */
14412 u32 len; /**< prefix length if IP */
14413 u8 type; /**< type of eid */
14418 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14420 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14422 memset (a, 0, sizeof (a[0]));
14424 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14426 a->type = 0; /* ipv4 type */
14428 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14430 a->type = 1; /* ipv6 type */
14432 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14434 a->type = 2; /* mac type */
14436 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14438 a->type = 3; /* NSH type */
14439 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14440 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14447 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14456 lisp_eid_size_vat (u8 type)
14473 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14475 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14479 api_one_add_del_locator_set (vat_main_t * vam)
14481 unformat_input_t *input = vam->input;
14482 vl_api_one_add_del_locator_set_t *mp;
14484 u8 *locator_set_name = NULL;
14485 u8 locator_set_name_set = 0;
14486 vl_api_local_locator_t locator, *locators = 0;
14487 u32 sw_if_index, priority, weight;
14491 /* Parse args required to build the message */
14492 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14494 if (unformat (input, "del"))
14498 else if (unformat (input, "locator-set %s", &locator_set_name))
14500 locator_set_name_set = 1;
14502 else if (unformat (input, "sw_if_index %u p %u w %u",
14503 &sw_if_index, &priority, &weight))
14505 locator.sw_if_index = htonl (sw_if_index);
14506 locator.priority = priority;
14507 locator.weight = weight;
14508 vec_add1 (locators, locator);
14512 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14513 &sw_if_index, &priority, &weight))
14515 locator.sw_if_index = htonl (sw_if_index);
14516 locator.priority = priority;
14517 locator.weight = weight;
14518 vec_add1 (locators, locator);
14524 if (locator_set_name_set == 0)
14526 errmsg ("missing locator-set name");
14527 vec_free (locators);
14531 if (vec_len (locator_set_name) > 64)
14533 errmsg ("locator-set name too long");
14534 vec_free (locator_set_name);
14535 vec_free (locators);
14538 vec_add1 (locator_set_name, 0);
14540 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14542 /* Construct the API message */
14543 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14545 mp->is_add = is_add;
14546 clib_memcpy (mp->locator_set_name, locator_set_name,
14547 vec_len (locator_set_name));
14548 vec_free (locator_set_name);
14550 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14552 clib_memcpy (mp->locators, locators, data_len);
14553 vec_free (locators);
14558 /* Wait for a reply... */
14563 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14566 api_one_add_del_locator (vat_main_t * vam)
14568 unformat_input_t *input = vam->input;
14569 vl_api_one_add_del_locator_t *mp;
14570 u32 tmp_if_index = ~0;
14571 u32 sw_if_index = ~0;
14572 u8 sw_if_index_set = 0;
14573 u8 sw_if_index_if_name_set = 0;
14575 u8 priority_set = 0;
14579 u8 *locator_set_name = NULL;
14580 u8 locator_set_name_set = 0;
14583 /* Parse args required to build the message */
14584 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14586 if (unformat (input, "del"))
14590 else if (unformat (input, "locator-set %s", &locator_set_name))
14592 locator_set_name_set = 1;
14594 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14597 sw_if_index_if_name_set = 1;
14598 sw_if_index = tmp_if_index;
14600 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14602 sw_if_index_set = 1;
14603 sw_if_index = tmp_if_index;
14605 else if (unformat (input, "p %d", &priority))
14609 else if (unformat (input, "w %d", &weight))
14617 if (locator_set_name_set == 0)
14619 errmsg ("missing locator-set name");
14623 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14625 errmsg ("missing sw_if_index");
14626 vec_free (locator_set_name);
14630 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14632 errmsg ("cannot use both params interface name and sw_if_index");
14633 vec_free (locator_set_name);
14637 if (priority_set == 0)
14639 errmsg ("missing locator-set priority");
14640 vec_free (locator_set_name);
14644 if (weight_set == 0)
14646 errmsg ("missing locator-set weight");
14647 vec_free (locator_set_name);
14651 if (vec_len (locator_set_name) > 64)
14653 errmsg ("locator-set name too long");
14654 vec_free (locator_set_name);
14657 vec_add1 (locator_set_name, 0);
14659 /* Construct the API message */
14660 M (ONE_ADD_DEL_LOCATOR, mp);
14662 mp->is_add = is_add;
14663 mp->sw_if_index = ntohl (sw_if_index);
14664 mp->priority = priority;
14665 mp->weight = weight;
14666 clib_memcpy (mp->locator_set_name, locator_set_name,
14667 vec_len (locator_set_name));
14668 vec_free (locator_set_name);
14673 /* Wait for a reply... */
14678 #define api_lisp_add_del_locator api_one_add_del_locator
14681 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14683 u32 *key_id = va_arg (*args, u32 *);
14686 if (unformat (input, "%s", &s))
14688 if (!strcmp ((char *) s, "sha1"))
14689 key_id[0] = HMAC_SHA_1_96;
14690 else if (!strcmp ((char *) s, "sha256"))
14691 key_id[0] = HMAC_SHA_256_128;
14694 clib_warning ("invalid key_id: '%s'", s);
14695 key_id[0] = HMAC_NO_KEY;
14706 api_one_add_del_local_eid (vat_main_t * vam)
14708 unformat_input_t *input = vam->input;
14709 vl_api_one_add_del_local_eid_t *mp;
14712 lisp_eid_vat_t _eid, *eid = &_eid;
14713 u8 *locator_set_name = 0;
14714 u8 locator_set_name_set = 0;
14720 /* Parse args required to build the message */
14721 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14723 if (unformat (input, "del"))
14727 else if (unformat (input, "vni %d", &vni))
14731 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14735 else if (unformat (input, "locator-set %s", &locator_set_name))
14737 locator_set_name_set = 1;
14739 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14741 else if (unformat (input, "secret-key %_%v%_", &key))
14747 if (locator_set_name_set == 0)
14749 errmsg ("missing locator-set name");
14755 errmsg ("EID address not set!");
14756 vec_free (locator_set_name);
14760 if (key && (0 == key_id))
14762 errmsg ("invalid key_id!");
14766 if (vec_len (key) > 64)
14768 errmsg ("key too long");
14773 if (vec_len (locator_set_name) > 64)
14775 errmsg ("locator-set name too long");
14776 vec_free (locator_set_name);
14779 vec_add1 (locator_set_name, 0);
14781 /* Construct the API message */
14782 M (ONE_ADD_DEL_LOCAL_EID, mp);
14784 mp->is_add = is_add;
14785 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14786 mp->eid_type = eid->type;
14787 mp->prefix_len = eid->len;
14788 mp->vni = clib_host_to_net_u32 (vni);
14789 mp->key_id = clib_host_to_net_u16 (key_id);
14790 clib_memcpy (mp->locator_set_name, locator_set_name,
14791 vec_len (locator_set_name));
14792 clib_memcpy (mp->key, key, vec_len (key));
14794 vec_free (locator_set_name);
14800 /* Wait for a reply... */
14805 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14808 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14810 u32 dp_table = 0, vni = 0;;
14811 unformat_input_t *input = vam->input;
14812 vl_api_gpe_add_del_fwd_entry_t *mp;
14814 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14815 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14816 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14817 u32 action = ~0, w;
14818 ip4_address_t rmt_rloc4, lcl_rloc4;
14819 ip6_address_t rmt_rloc6, lcl_rloc6;
14820 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14823 memset (&rloc, 0, sizeof (rloc));
14825 /* Parse args required to build the message */
14826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14828 if (unformat (input, "del"))
14830 else if (unformat (input, "add"))
14832 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14836 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14840 else if (unformat (input, "vrf %d", &dp_table))
14842 else if (unformat (input, "bd %d", &dp_table))
14844 else if (unformat (input, "vni %d", &vni))
14846 else if (unformat (input, "w %d", &w))
14850 errmsg ("No RLOC configured for setting priority/weight!");
14853 curr_rloc->weight = w;
14855 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14856 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14860 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14862 vec_add1 (lcl_locs, rloc);
14864 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14865 vec_add1 (rmt_locs, rloc);
14866 /* weight saved in rmt loc */
14867 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14869 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14870 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14873 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14875 vec_add1 (lcl_locs, rloc);
14877 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14878 vec_add1 (rmt_locs, rloc);
14879 /* weight saved in rmt loc */
14880 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14882 else if (unformat (input, "action %d", &action))
14888 clib_warning ("parse error '%U'", format_unformat_error, input);
14895 errmsg ("remote eid addresses not set");
14899 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14901 errmsg ("eid types don't match");
14905 if (0 == rmt_locs && (u32) ~ 0 == action)
14907 errmsg ("action not set for negative mapping");
14911 /* Construct the API message */
14912 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14913 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14915 mp->is_add = is_add;
14916 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14917 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14918 mp->eid_type = rmt_eid->type;
14919 mp->dp_table = clib_host_to_net_u32 (dp_table);
14920 mp->vni = clib_host_to_net_u32 (vni);
14921 mp->rmt_len = rmt_eid->len;
14922 mp->lcl_len = lcl_eid->len;
14923 mp->action = action;
14925 if (0 != rmt_locs && 0 != lcl_locs)
14927 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14928 clib_memcpy (mp->locs, lcl_locs,
14929 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14931 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14932 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14933 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14935 vec_free (lcl_locs);
14936 vec_free (rmt_locs);
14941 /* Wait for a reply... */
14947 api_one_add_del_map_server (vat_main_t * vam)
14949 unformat_input_t *input = vam->input;
14950 vl_api_one_add_del_map_server_t *mp;
14954 ip4_address_t ipv4;
14955 ip6_address_t ipv6;
14958 /* Parse args required to build the message */
14959 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14961 if (unformat (input, "del"))
14965 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14969 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14977 if (ipv4_set && ipv6_set)
14979 errmsg ("both eid v4 and v6 addresses set");
14983 if (!ipv4_set && !ipv6_set)
14985 errmsg ("eid addresses not set");
14989 /* Construct the API message */
14990 M (ONE_ADD_DEL_MAP_SERVER, mp);
14992 mp->is_add = is_add;
14996 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15001 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15007 /* Wait for a reply... */
15012 #define api_lisp_add_del_map_server api_one_add_del_map_server
15015 api_one_add_del_map_resolver (vat_main_t * vam)
15017 unformat_input_t *input = vam->input;
15018 vl_api_one_add_del_map_resolver_t *mp;
15022 ip4_address_t ipv4;
15023 ip6_address_t ipv6;
15026 /* Parse args required to build the message */
15027 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15029 if (unformat (input, "del"))
15033 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15037 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15045 if (ipv4_set && ipv6_set)
15047 errmsg ("both eid v4 and v6 addresses set");
15051 if (!ipv4_set && !ipv6_set)
15053 errmsg ("eid addresses not set");
15057 /* Construct the API message */
15058 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15060 mp->is_add = is_add;
15064 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15069 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15075 /* Wait for a reply... */
15080 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15083 api_lisp_gpe_enable_disable (vat_main_t * vam)
15085 unformat_input_t *input = vam->input;
15086 vl_api_gpe_enable_disable_t *mp;
15091 /* Parse args required to build the message */
15092 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15094 if (unformat (input, "enable"))
15099 else if (unformat (input, "disable"))
15110 errmsg ("Value not set");
15114 /* Construct the API message */
15115 M (GPE_ENABLE_DISABLE, mp);
15122 /* Wait for a reply... */
15128 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15130 unformat_input_t *input = vam->input;
15131 vl_api_one_rloc_probe_enable_disable_t *mp;
15136 /* Parse args required to build the message */
15137 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15139 if (unformat (input, "enable"))
15144 else if (unformat (input, "disable"))
15152 errmsg ("Value not set");
15156 /* Construct the API message */
15157 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15159 mp->is_enabled = is_en;
15164 /* Wait for a reply... */
15169 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15172 api_one_map_register_enable_disable (vat_main_t * vam)
15174 unformat_input_t *input = vam->input;
15175 vl_api_one_map_register_enable_disable_t *mp;
15180 /* Parse args required to build the message */
15181 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15183 if (unformat (input, "enable"))
15188 else if (unformat (input, "disable"))
15196 errmsg ("Value not set");
15200 /* Construct the API message */
15201 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15203 mp->is_enabled = is_en;
15208 /* Wait for a reply... */
15213 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15216 api_one_enable_disable (vat_main_t * vam)
15218 unformat_input_t *input = vam->input;
15219 vl_api_one_enable_disable_t *mp;
15224 /* Parse args required to build the message */
15225 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15227 if (unformat (input, "enable"))
15232 else if (unformat (input, "disable"))
15242 errmsg ("Value not set");
15246 /* Construct the API message */
15247 M (ONE_ENABLE_DISABLE, mp);
15254 /* Wait for a reply... */
15259 #define api_lisp_enable_disable api_one_enable_disable
15262 api_show_one_map_register_state (vat_main_t * vam)
15264 vl_api_show_one_map_register_state_t *mp;
15267 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15272 /* wait for reply */
15277 #define api_show_lisp_map_register_state api_show_one_map_register_state
15280 api_show_one_rloc_probe_state (vat_main_t * vam)
15282 vl_api_show_one_rloc_probe_state_t *mp;
15285 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15290 /* wait for reply */
15295 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15298 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15300 vl_api_one_add_del_l2_arp_entry_t *mp;
15301 unformat_input_t *input = vam->input;
15306 u8 mac[6] = { 0, };
15307 u32 ip4 = 0, bd = ~0;
15310 /* Parse args required to build the message */
15311 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15313 if (unformat (input, "del"))
15315 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15317 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15319 else if (unformat (input, "bd %d", &bd))
15323 errmsg ("parse error '%U'", format_unformat_error, input);
15328 if (!bd_set || !ip_set || (!mac_set && is_add))
15330 errmsg ("Missing BD, IP or MAC!");
15334 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15335 mp->is_add = is_add;
15336 clib_memcpy (mp->mac, mac, 6);
15337 mp->bd = clib_host_to_net_u32 (bd);
15343 /* wait for reply */
15349 api_one_l2_arp_bd_get (vat_main_t * vam)
15351 vl_api_one_l2_arp_bd_get_t *mp;
15354 M (ONE_L2_ARP_BD_GET, mp);
15359 /* wait for reply */
15365 api_one_l2_arp_entries_get (vat_main_t * vam)
15367 vl_api_one_l2_arp_entries_get_t *mp;
15368 unformat_input_t *input = vam->input;
15373 /* Parse args required to build the message */
15374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15376 if (unformat (input, "bd %d", &bd))
15380 errmsg ("parse error '%U'", format_unformat_error, input);
15387 errmsg ("Expected bridge domain!");
15391 M (ONE_L2_ARP_ENTRIES_GET, mp);
15392 mp->bd = clib_host_to_net_u32 (bd);
15397 /* wait for reply */
15403 api_one_stats_enable_disable (vat_main_t * vam)
15405 vl_api_one_stats_enable_disable_t *mp;
15406 unformat_input_t *input = vam->input;
15411 /* Parse args required to build the message */
15412 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15414 if (unformat (input, "enable"))
15419 else if (unformat (input, "disable"))
15429 errmsg ("Value not set");
15433 M (ONE_STATS_ENABLE_DISABLE, mp);
15439 /* wait for reply */
15445 api_show_one_stats_enable_disable (vat_main_t * vam)
15447 vl_api_show_one_stats_enable_disable_t *mp;
15450 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15455 /* wait for reply */
15461 api_show_one_map_request_mode (vat_main_t * vam)
15463 vl_api_show_one_map_request_mode_t *mp;
15466 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15471 /* wait for reply */
15476 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15479 api_one_map_request_mode (vat_main_t * vam)
15481 unformat_input_t *input = vam->input;
15482 vl_api_one_map_request_mode_t *mp;
15486 /* Parse args required to build the message */
15487 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15489 if (unformat (input, "dst-only"))
15491 else if (unformat (input, "src-dst"))
15495 errmsg ("parse error '%U'", format_unformat_error, input);
15500 M (ONE_MAP_REQUEST_MODE, mp);
15507 /* wait for reply */
15512 #define api_lisp_map_request_mode api_one_map_request_mode
15515 * Enable/disable ONE proxy ITR.
15517 * @param vam vpp API test context
15518 * @return return code
15521 api_one_pitr_set_locator_set (vat_main_t * vam)
15523 u8 ls_name_set = 0;
15524 unformat_input_t *input = vam->input;
15525 vl_api_one_pitr_set_locator_set_t *mp;
15530 /* Parse args required to build the message */
15531 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15533 if (unformat (input, "del"))
15535 else if (unformat (input, "locator-set %s", &ls_name))
15539 errmsg ("parse error '%U'", format_unformat_error, input);
15546 errmsg ("locator-set name not set!");
15550 M (ONE_PITR_SET_LOCATOR_SET, mp);
15552 mp->is_add = is_add;
15553 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15554 vec_free (ls_name);
15559 /* wait for reply */
15564 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15567 api_one_nsh_set_locator_set (vat_main_t * vam)
15569 u8 ls_name_set = 0;
15570 unformat_input_t *input = vam->input;
15571 vl_api_one_nsh_set_locator_set_t *mp;
15576 /* Parse args required to build the message */
15577 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15579 if (unformat (input, "del"))
15581 else if (unformat (input, "ls %s", &ls_name))
15585 errmsg ("parse error '%U'", format_unformat_error, input);
15590 if (!ls_name_set && is_add)
15592 errmsg ("locator-set name not set!");
15596 M (ONE_NSH_SET_LOCATOR_SET, mp);
15598 mp->is_add = is_add;
15599 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15600 vec_free (ls_name);
15605 /* wait for reply */
15611 api_show_one_pitr (vat_main_t * vam)
15613 vl_api_show_one_pitr_t *mp;
15616 if (!vam->json_output)
15618 print (vam->ofp, "%=20s", "lisp status:");
15621 M (SHOW_ONE_PITR, mp);
15625 /* Wait for a reply... */
15630 #define api_show_lisp_pitr api_show_one_pitr
15633 api_one_use_petr (vat_main_t * vam)
15635 unformat_input_t *input = vam->input;
15636 vl_api_one_use_petr_t *mp;
15641 memset (&ip, 0, sizeof (ip));
15643 /* Parse args required to build the message */
15644 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15646 if (unformat (input, "disable"))
15649 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15652 ip_addr_version (&ip) = IP4;
15655 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15658 ip_addr_version (&ip) = IP6;
15662 errmsg ("parse error '%U'", format_unformat_error, input);
15667 M (ONE_USE_PETR, mp);
15669 mp->is_add = is_add;
15672 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
15674 clib_memcpy (mp->address, &ip, 4);
15676 clib_memcpy (mp->address, &ip, 16);
15682 /* wait for reply */
15687 #define api_lisp_use_petr api_one_use_petr
15690 api_show_one_nsh_mapping (vat_main_t * vam)
15692 vl_api_show_one_use_petr_t *mp;
15695 if (!vam->json_output)
15697 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15700 M (SHOW_ONE_NSH_MAPPING, mp);
15704 /* Wait for a reply... */
15710 api_show_one_use_petr (vat_main_t * vam)
15712 vl_api_show_one_use_petr_t *mp;
15715 if (!vam->json_output)
15717 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15720 M (SHOW_ONE_USE_PETR, mp);
15724 /* Wait for a reply... */
15729 #define api_show_lisp_use_petr api_show_one_use_petr
15732 * Add/delete mapping between vni and vrf
15735 api_one_eid_table_add_del_map (vat_main_t * vam)
15737 unformat_input_t *input = vam->input;
15738 vl_api_one_eid_table_add_del_map_t *mp;
15739 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15740 u32 vni, vrf, bd_index;
15743 /* Parse args required to build the message */
15744 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15746 if (unformat (input, "del"))
15748 else if (unformat (input, "vrf %d", &vrf))
15750 else if (unformat (input, "bd_index %d", &bd_index))
15752 else if (unformat (input, "vni %d", &vni))
15758 if (!vni_set || (!vrf_set && !bd_index_set))
15760 errmsg ("missing arguments!");
15764 if (vrf_set && bd_index_set)
15766 errmsg ("error: both vrf and bd entered!");
15770 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15772 mp->is_add = is_add;
15773 mp->vni = htonl (vni);
15774 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15775 mp->is_l2 = bd_index_set;
15780 /* wait for reply */
15785 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15788 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15790 u32 *action = va_arg (*args, u32 *);
15793 if (unformat (input, "%s", &s))
15795 if (!strcmp ((char *) s, "no-action"))
15797 else if (!strcmp ((char *) s, "natively-forward"))
15799 else if (!strcmp ((char *) s, "send-map-request"))
15801 else if (!strcmp ((char *) s, "drop"))
15805 clib_warning ("invalid action: '%s'", s);
15817 * Add/del remote mapping to/from ONE control plane
15819 * @param vam vpp API test context
15820 * @return return code
15823 api_one_add_del_remote_mapping (vat_main_t * vam)
15825 unformat_input_t *input = vam->input;
15826 vl_api_one_add_del_remote_mapping_t *mp;
15828 lisp_eid_vat_t _eid, *eid = &_eid;
15829 lisp_eid_vat_t _seid, *seid = &_seid;
15830 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15831 u32 action = ~0, p, w, data_len;
15832 ip4_address_t rloc4;
15833 ip6_address_t rloc6;
15834 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15837 memset (&rloc, 0, sizeof (rloc));
15839 /* Parse args required to build the message */
15840 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15842 if (unformat (input, "del-all"))
15846 else if (unformat (input, "del"))
15850 else if (unformat (input, "add"))
15854 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15858 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15862 else if (unformat (input, "vni %d", &vni))
15866 else if (unformat (input, "p %d w %d", &p, &w))
15870 errmsg ("No RLOC configured for setting priority/weight!");
15873 curr_rloc->priority = p;
15874 curr_rloc->weight = w;
15876 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15879 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15880 vec_add1 (rlocs, rloc);
15881 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15883 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15886 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15887 vec_add1 (rlocs, rloc);
15888 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15890 else if (unformat (input, "action %U",
15891 unformat_negative_mapping_action, &action))
15897 clib_warning ("parse error '%U'", format_unformat_error, input);
15904 errmsg ("missing params!");
15908 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15910 errmsg ("no action set for negative map-reply!");
15914 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15916 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15917 mp->is_add = is_add;
15918 mp->vni = htonl (vni);
15919 mp->action = (u8) action;
15920 mp->is_src_dst = seid_set;
15921 mp->eid_len = eid->len;
15922 mp->seid_len = seid->len;
15923 mp->del_all = del_all;
15924 mp->eid_type = eid->type;
15925 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15926 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15928 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15929 clib_memcpy (mp->rlocs, rlocs, data_len);
15935 /* Wait for a reply... */
15940 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15943 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15944 * forwarding entries in data-plane accordingly.
15946 * @param vam vpp API test context
15947 * @return return code
15950 api_one_add_del_adjacency (vat_main_t * vam)
15952 unformat_input_t *input = vam->input;
15953 vl_api_one_add_del_adjacency_t *mp;
15955 ip4_address_t leid4, reid4;
15956 ip6_address_t leid6, reid6;
15957 u8 reid_mac[6] = { 0 };
15958 u8 leid_mac[6] = { 0 };
15959 u8 reid_type, leid_type;
15960 u32 leid_len = 0, reid_len = 0, len;
15964 leid_type = reid_type = (u8) ~ 0;
15966 /* Parse args required to build the message */
15967 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15969 if (unformat (input, "del"))
15973 else if (unformat (input, "add"))
15977 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15980 reid_type = 0; /* ipv4 */
15983 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15986 reid_type = 1; /* ipv6 */
15989 else if (unformat (input, "reid %U", unformat_ethernet_address,
15992 reid_type = 2; /* mac */
15994 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15997 leid_type = 0; /* ipv4 */
16000 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
16003 leid_type = 1; /* ipv6 */
16006 else if (unformat (input, "leid %U", unformat_ethernet_address,
16009 leid_type = 2; /* mac */
16011 else if (unformat (input, "vni %d", &vni))
16017 errmsg ("parse error '%U'", format_unformat_error, input);
16022 if ((u8) ~ 0 == reid_type)
16024 errmsg ("missing params!");
16028 if (leid_type != reid_type)
16030 errmsg ("remote and local EIDs are of different types!");
16034 M (ONE_ADD_DEL_ADJACENCY, mp);
16035 mp->is_add = is_add;
16036 mp->vni = htonl (vni);
16037 mp->leid_len = leid_len;
16038 mp->reid_len = reid_len;
16039 mp->eid_type = reid_type;
16041 switch (mp->eid_type)
16044 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16045 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16048 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16049 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16052 clib_memcpy (mp->leid, leid_mac, 6);
16053 clib_memcpy (mp->reid, reid_mac, 6);
16056 errmsg ("unknown EID type %d!", mp->eid_type);
16063 /* Wait for a reply... */
16068 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16071 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16073 u32 *mode = va_arg (*args, u32 *);
16075 if (unformat (input, "lisp"))
16077 else if (unformat (input, "vxlan"))
16086 api_gpe_get_encap_mode (vat_main_t * vam)
16088 vl_api_gpe_get_encap_mode_t *mp;
16091 /* Construct the API message */
16092 M (GPE_GET_ENCAP_MODE, mp);
16097 /* Wait for a reply... */
16103 api_gpe_set_encap_mode (vat_main_t * vam)
16105 unformat_input_t *input = vam->input;
16106 vl_api_gpe_set_encap_mode_t *mp;
16110 /* Parse args required to build the message */
16111 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16113 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16119 /* Construct the API message */
16120 M (GPE_SET_ENCAP_MODE, mp);
16127 /* Wait for a reply... */
16133 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16135 unformat_input_t *input = vam->input;
16136 vl_api_gpe_add_del_iface_t *mp;
16137 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16138 u32 dp_table = 0, vni = 0;
16141 /* Parse args required to build the message */
16142 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16144 if (unformat (input, "up"))
16149 else if (unformat (input, "down"))
16154 else if (unformat (input, "table_id %d", &dp_table))
16158 else if (unformat (input, "bd_id %d", &dp_table))
16163 else if (unformat (input, "vni %d", &vni))
16171 if (action_set == 0)
16173 errmsg ("Action not set");
16176 if (dp_table_set == 0 || vni_set == 0)
16178 errmsg ("vni and dp_table must be set");
16182 /* Construct the API message */
16183 M (GPE_ADD_DEL_IFACE, mp);
16185 mp->is_add = is_add;
16186 mp->dp_table = clib_host_to_net_u32 (dp_table);
16188 mp->vni = clib_host_to_net_u32 (vni);
16193 /* Wait for a reply... */
16199 api_one_map_register_fallback_threshold (vat_main_t * vam)
16201 unformat_input_t *input = vam->input;
16202 vl_api_one_map_register_fallback_threshold_t *mp;
16207 /* Parse args required to build the message */
16208 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16210 if (unformat (input, "%u", &value))
16214 clib_warning ("parse error '%U'", format_unformat_error, input);
16221 errmsg ("fallback threshold value is missing!");
16225 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16226 mp->value = clib_host_to_net_u32 (value);
16231 /* Wait for a reply... */
16237 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16239 vl_api_show_one_map_register_fallback_threshold_t *mp;
16242 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16247 /* Wait for a reply... */
16253 api_one_map_register_set_ttl (vat_main_t * vam)
16255 unformat_input_t *input = vam->input;
16256 vl_api_one_map_register_set_ttl_t *mp;
16261 /* Parse args required to build the message */
16262 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16264 if (unformat (input, "%u", &ttl))
16268 clib_warning ("parse error '%U'", format_unformat_error, input);
16275 errmsg ("TTL value missing!");
16279 M (ONE_MAP_REGISTER_SET_TTL, mp);
16280 mp->ttl = clib_host_to_net_u32 (ttl);
16285 /* Wait for a reply... */
16291 api_show_one_map_register_ttl (vat_main_t * vam)
16293 vl_api_show_one_map_register_ttl_t *mp;
16296 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16301 /* Wait for a reply... */
16307 * Add/del map request itr rlocs from ONE control plane and updates
16309 * @param vam vpp API test context
16310 * @return return code
16313 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16315 unformat_input_t *input = vam->input;
16316 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16317 u8 *locator_set_name = 0;
16318 u8 locator_set_name_set = 0;
16322 /* Parse args required to build the message */
16323 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16325 if (unformat (input, "del"))
16329 else if (unformat (input, "%_%v%_", &locator_set_name))
16331 locator_set_name_set = 1;
16335 clib_warning ("parse error '%U'", format_unformat_error, input);
16340 if (is_add && !locator_set_name_set)
16342 errmsg ("itr-rloc is not set!");
16346 if (is_add && vec_len (locator_set_name) > 64)
16348 errmsg ("itr-rloc locator-set name too long");
16349 vec_free (locator_set_name);
16353 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16354 mp->is_add = is_add;
16357 clib_memcpy (mp->locator_set_name, locator_set_name,
16358 vec_len (locator_set_name));
16362 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16364 vec_free (locator_set_name);
16369 /* Wait for a reply... */
16374 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16377 api_one_locator_dump (vat_main_t * vam)
16379 unformat_input_t *input = vam->input;
16380 vl_api_one_locator_dump_t *mp;
16381 vl_api_control_ping_t *mp_ping;
16382 u8 is_index_set = 0, is_name_set = 0;
16387 /* Parse args required to build the message */
16388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16390 if (unformat (input, "ls_name %_%v%_", &ls_name))
16394 else if (unformat (input, "ls_index %d", &ls_index))
16400 errmsg ("parse error '%U'", format_unformat_error, input);
16405 if (!is_index_set && !is_name_set)
16407 errmsg ("error: expected one of index or name!");
16411 if (is_index_set && is_name_set)
16413 errmsg ("error: only one param expected!");
16417 if (vec_len (ls_name) > 62)
16419 errmsg ("error: locator set name too long!");
16423 if (!vam->json_output)
16425 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16428 M (ONE_LOCATOR_DUMP, mp);
16429 mp->is_index_set = is_index_set;
16432 mp->ls_index = clib_host_to_net_u32 (ls_index);
16435 vec_add1 (ls_name, 0);
16436 strncpy ((char *) mp->ls_name, (char *) ls_name,
16437 sizeof (mp->ls_name) - 1);
16443 /* Use a control ping for synchronization */
16444 M (CONTROL_PING, mp_ping);
16447 /* Wait for a reply... */
16452 #define api_lisp_locator_dump api_one_locator_dump
16455 api_one_locator_set_dump (vat_main_t * vam)
16457 vl_api_one_locator_set_dump_t *mp;
16458 vl_api_control_ping_t *mp_ping;
16459 unformat_input_t *input = vam->input;
16463 /* Parse args required to build the message */
16464 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16466 if (unformat (input, "local"))
16470 else if (unformat (input, "remote"))
16476 errmsg ("parse error '%U'", format_unformat_error, input);
16481 if (!vam->json_output)
16483 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16486 M (ONE_LOCATOR_SET_DUMP, mp);
16488 mp->filter = filter;
16493 /* Use a control ping for synchronization */
16494 M (CONTROL_PING, mp_ping);
16497 /* Wait for a reply... */
16502 #define api_lisp_locator_set_dump api_one_locator_set_dump
16505 api_one_eid_table_map_dump (vat_main_t * vam)
16509 unformat_input_t *input = vam->input;
16510 vl_api_one_eid_table_map_dump_t *mp;
16511 vl_api_control_ping_t *mp_ping;
16514 /* Parse args required to build the message */
16515 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16517 if (unformat (input, "l2"))
16522 else if (unformat (input, "l3"))
16529 errmsg ("parse error '%U'", format_unformat_error, input);
16536 errmsg ("expected one of 'l2' or 'l3' parameter!");
16540 if (!vam->json_output)
16542 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16545 M (ONE_EID_TABLE_MAP_DUMP, mp);
16551 /* Use a control ping for synchronization */
16552 M (CONTROL_PING, mp_ping);
16555 /* Wait for a reply... */
16560 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16563 api_one_eid_table_vni_dump (vat_main_t * vam)
16565 vl_api_one_eid_table_vni_dump_t *mp;
16566 vl_api_control_ping_t *mp_ping;
16569 if (!vam->json_output)
16571 print (vam->ofp, "VNI");
16574 M (ONE_EID_TABLE_VNI_DUMP, mp);
16579 /* Use a control ping for synchronization */
16580 M (CONTROL_PING, mp_ping);
16583 /* Wait for a reply... */
16588 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16591 api_one_eid_table_dump (vat_main_t * vam)
16593 unformat_input_t *i = vam->input;
16594 vl_api_one_eid_table_dump_t *mp;
16595 vl_api_control_ping_t *mp_ping;
16596 struct in_addr ip4;
16597 struct in6_addr ip6;
16599 u8 eid_type = ~0, eid_set = 0;
16600 u32 prefix_length = ~0, t, vni = 0;
16603 lisp_nsh_api_t nsh;
16605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16607 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16613 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16619 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16624 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16629 else if (unformat (i, "vni %d", &t))
16633 else if (unformat (i, "local"))
16637 else if (unformat (i, "remote"))
16643 errmsg ("parse error '%U'", format_unformat_error, i);
16648 if (!vam->json_output)
16650 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16651 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16654 M (ONE_EID_TABLE_DUMP, mp);
16656 mp->filter = filter;
16660 mp->vni = htonl (vni);
16661 mp->eid_type = eid_type;
16665 mp->prefix_length = prefix_length;
16666 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16669 mp->prefix_length = prefix_length;
16670 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16673 clib_memcpy (mp->eid, mac, sizeof (mac));
16676 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16679 errmsg ("unknown EID type %d!", eid_type);
16687 /* Use a control ping for synchronization */
16688 M (CONTROL_PING, mp_ping);
16691 /* Wait for a reply... */
16696 #define api_lisp_eid_table_dump api_one_eid_table_dump
16699 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16701 unformat_input_t *i = vam->input;
16702 vl_api_gpe_fwd_entries_get_t *mp;
16707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16709 if (unformat (i, "vni %d", &vni))
16715 errmsg ("parse error '%U'", format_unformat_error, i);
16722 errmsg ("vni not set!");
16726 if (!vam->json_output)
16728 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16732 M (GPE_FWD_ENTRIES_GET, mp);
16733 mp->vni = clib_host_to_net_u32 (vni);
16738 /* Wait for a reply... */
16743 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16744 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16745 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16746 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16747 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16748 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16749 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16750 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16753 api_one_adjacencies_get (vat_main_t * vam)
16755 unformat_input_t *i = vam->input;
16756 vl_api_one_adjacencies_get_t *mp;
16761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16763 if (unformat (i, "vni %d", &vni))
16769 errmsg ("parse error '%U'", format_unformat_error, i);
16776 errmsg ("vni not set!");
16780 if (!vam->json_output)
16782 print (vam->ofp, "%s %40s", "leid", "reid");
16785 M (ONE_ADJACENCIES_GET, mp);
16786 mp->vni = clib_host_to_net_u32 (vni);
16791 /* Wait for a reply... */
16796 #define api_lisp_adjacencies_get api_one_adjacencies_get
16799 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16801 unformat_input_t *i = vam->input;
16802 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16804 u8 ip_family_set = 0, is_ip4 = 1;
16806 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16808 if (unformat (i, "ip4"))
16813 else if (unformat (i, "ip6"))
16820 errmsg ("parse error '%U'", format_unformat_error, i);
16825 if (!ip_family_set)
16827 errmsg ("ip family not set!");
16831 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16832 mp->is_ip4 = is_ip4;
16837 /* Wait for a reply... */
16843 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16845 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16848 if (!vam->json_output)
16850 print (vam->ofp, "VNIs");
16853 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16858 /* Wait for a reply... */
16864 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16866 unformat_input_t *i = vam->input;
16867 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16869 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16870 struct in_addr ip4;
16871 struct in6_addr ip6;
16872 u32 table_id = 0, nh_sw_if_index = ~0;
16874 memset (&ip4, 0, sizeof (ip4));
16875 memset (&ip6, 0, sizeof (ip6));
16877 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16879 if (unformat (i, "del"))
16881 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16882 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16887 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16888 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16893 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16897 nh_sw_if_index = ~0;
16899 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16903 nh_sw_if_index = ~0;
16905 else if (unformat (i, "table %d", &table_id))
16909 errmsg ("parse error '%U'", format_unformat_error, i);
16916 errmsg ("nh addr not set!");
16920 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16921 mp->is_add = is_add;
16922 mp->table_id = clib_host_to_net_u32 (table_id);
16923 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16924 mp->is_ip4 = is_ip4;
16926 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16928 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16933 /* Wait for a reply... */
16939 api_one_map_server_dump (vat_main_t * vam)
16941 vl_api_one_map_server_dump_t *mp;
16942 vl_api_control_ping_t *mp_ping;
16945 if (!vam->json_output)
16947 print (vam->ofp, "%=20s", "Map server");
16950 M (ONE_MAP_SERVER_DUMP, mp);
16954 /* Use a control ping for synchronization */
16955 M (CONTROL_PING, mp_ping);
16958 /* Wait for a reply... */
16963 #define api_lisp_map_server_dump api_one_map_server_dump
16966 api_one_map_resolver_dump (vat_main_t * vam)
16968 vl_api_one_map_resolver_dump_t *mp;
16969 vl_api_control_ping_t *mp_ping;
16972 if (!vam->json_output)
16974 print (vam->ofp, "%=20s", "Map resolver");
16977 M (ONE_MAP_RESOLVER_DUMP, mp);
16981 /* Use a control ping for synchronization */
16982 M (CONTROL_PING, mp_ping);
16985 /* Wait for a reply... */
16990 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
16993 api_one_stats_flush (vat_main_t * vam)
16995 vl_api_one_stats_flush_t *mp;
16998 M (ONE_STATS_FLUSH, mp);
17005 api_one_stats_dump (vat_main_t * vam)
17007 vl_api_one_stats_dump_t *mp;
17008 vl_api_control_ping_t *mp_ping;
17011 M (ONE_STATS_DUMP, mp);
17015 /* Use a control ping for synchronization */
17016 M (CONTROL_PING, mp_ping);
17019 /* Wait for a reply... */
17025 api_show_one_status (vat_main_t * vam)
17027 vl_api_show_one_status_t *mp;
17030 if (!vam->json_output)
17032 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17035 M (SHOW_ONE_STATUS, mp);
17038 /* Wait for a reply... */
17043 #define api_show_lisp_status api_show_one_status
17046 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17048 vl_api_gpe_fwd_entry_path_dump_t *mp;
17049 vl_api_control_ping_t *mp_ping;
17050 unformat_input_t *i = vam->input;
17051 u32 fwd_entry_index = ~0;
17054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17056 if (unformat (i, "index %d", &fwd_entry_index))
17062 if (~0 == fwd_entry_index)
17064 errmsg ("no index specified!");
17068 if (!vam->json_output)
17070 print (vam->ofp, "first line");
17073 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17077 /* Use a control ping for synchronization */
17078 M (CONTROL_PING, mp_ping);
17081 /* Wait for a reply... */
17087 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17089 vl_api_one_get_map_request_itr_rlocs_t *mp;
17092 if (!vam->json_output)
17094 print (vam->ofp, "%=20s", "itr-rlocs:");
17097 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17100 /* Wait for a reply... */
17105 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17108 api_af_packet_create (vat_main_t * vam)
17110 unformat_input_t *i = vam->input;
17111 vl_api_af_packet_create_t *mp;
17112 u8 *host_if_name = 0;
17114 u8 random_hw_addr = 1;
17117 memset (hw_addr, 0, sizeof (hw_addr));
17119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17121 if (unformat (i, "name %s", &host_if_name))
17122 vec_add1 (host_if_name, 0);
17123 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17124 random_hw_addr = 0;
17129 if (!vec_len (host_if_name))
17131 errmsg ("host-interface name must be specified");
17135 if (vec_len (host_if_name) > 64)
17137 errmsg ("host-interface name too long");
17141 M (AF_PACKET_CREATE, mp);
17143 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17144 clib_memcpy (mp->hw_addr, hw_addr, 6);
17145 mp->use_random_hw_addr = random_hw_addr;
17146 vec_free (host_if_name);
17154 fprintf (vam->ofp ? vam->ofp : stderr,
17155 " new sw_if_index = %d\n", vam->sw_if_index);
17162 api_af_packet_delete (vat_main_t * vam)
17164 unformat_input_t *i = vam->input;
17165 vl_api_af_packet_delete_t *mp;
17166 u8 *host_if_name = 0;
17169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17171 if (unformat (i, "name %s", &host_if_name))
17172 vec_add1 (host_if_name, 0);
17177 if (!vec_len (host_if_name))
17179 errmsg ("host-interface name must be specified");
17183 if (vec_len (host_if_name) > 64)
17185 errmsg ("host-interface name too long");
17189 M (AF_PACKET_DELETE, mp);
17191 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17192 vec_free (host_if_name);
17200 api_policer_add_del (vat_main_t * vam)
17202 unformat_input_t *i = vam->input;
17203 vl_api_policer_add_del_t *mp;
17213 u8 color_aware = 0;
17214 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17217 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17218 conform_action.dscp = 0;
17219 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17220 exceed_action.dscp = 0;
17221 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17222 violate_action.dscp = 0;
17224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17226 if (unformat (i, "del"))
17228 else if (unformat (i, "name %s", &name))
17229 vec_add1 (name, 0);
17230 else if (unformat (i, "cir %u", &cir))
17232 else if (unformat (i, "eir %u", &eir))
17234 else if (unformat (i, "cb %u", &cb))
17236 else if (unformat (i, "eb %u", &eb))
17238 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17241 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17244 else if (unformat (i, "type %U", unformat_policer_type, &type))
17246 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17249 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17252 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17255 else if (unformat (i, "color-aware"))
17261 if (!vec_len (name))
17263 errmsg ("policer name must be specified");
17267 if (vec_len (name) > 64)
17269 errmsg ("policer name too long");
17273 M (POLICER_ADD_DEL, mp);
17275 clib_memcpy (mp->name, name, vec_len (name));
17277 mp->is_add = is_add;
17282 mp->rate_type = rate_type;
17283 mp->round_type = round_type;
17285 mp->conform_action_type = conform_action.action_type;
17286 mp->conform_dscp = conform_action.dscp;
17287 mp->exceed_action_type = exceed_action.action_type;
17288 mp->exceed_dscp = exceed_action.dscp;
17289 mp->violate_action_type = violate_action.action_type;
17290 mp->violate_dscp = violate_action.dscp;
17291 mp->color_aware = color_aware;
17299 api_policer_dump (vat_main_t * vam)
17301 unformat_input_t *i = vam->input;
17302 vl_api_policer_dump_t *mp;
17303 vl_api_control_ping_t *mp_ping;
17304 u8 *match_name = 0;
17305 u8 match_name_valid = 0;
17308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17310 if (unformat (i, "name %s", &match_name))
17312 vec_add1 (match_name, 0);
17313 match_name_valid = 1;
17319 M (POLICER_DUMP, mp);
17320 mp->match_name_valid = match_name_valid;
17321 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17322 vec_free (match_name);
17326 /* Use a control ping for synchronization */
17327 M (CONTROL_PING, mp_ping);
17330 /* Wait for a reply... */
17336 api_policer_classify_set_interface (vat_main_t * vam)
17338 unformat_input_t *i = vam->input;
17339 vl_api_policer_classify_set_interface_t *mp;
17341 int sw_if_index_set;
17342 u32 ip4_table_index = ~0;
17343 u32 ip6_table_index = ~0;
17344 u32 l2_table_index = ~0;
17348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17350 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17351 sw_if_index_set = 1;
17352 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17353 sw_if_index_set = 1;
17354 else if (unformat (i, "del"))
17356 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17358 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17360 else if (unformat (i, "l2-table %d", &l2_table_index))
17364 clib_warning ("parse error '%U'", format_unformat_error, i);
17369 if (sw_if_index_set == 0)
17371 errmsg ("missing interface name or sw_if_index");
17375 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17377 mp->sw_if_index = ntohl (sw_if_index);
17378 mp->ip4_table_index = ntohl (ip4_table_index);
17379 mp->ip6_table_index = ntohl (ip6_table_index);
17380 mp->l2_table_index = ntohl (l2_table_index);
17381 mp->is_add = is_add;
17389 api_policer_classify_dump (vat_main_t * vam)
17391 unformat_input_t *i = vam->input;
17392 vl_api_policer_classify_dump_t *mp;
17393 vl_api_control_ping_t *mp_ping;
17394 u8 type = POLICER_CLASSIFY_N_TABLES;
17397 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17401 errmsg ("classify table type must be specified");
17405 if (!vam->json_output)
17407 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17410 M (POLICER_CLASSIFY_DUMP, mp);
17415 /* Use a control ping for synchronization */
17416 M (CONTROL_PING, mp_ping);
17419 /* Wait for a reply... */
17425 api_netmap_create (vat_main_t * vam)
17427 unformat_input_t *i = vam->input;
17428 vl_api_netmap_create_t *mp;
17431 u8 random_hw_addr = 1;
17436 memset (hw_addr, 0, sizeof (hw_addr));
17438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17440 if (unformat (i, "name %s", &if_name))
17441 vec_add1 (if_name, 0);
17442 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17443 random_hw_addr = 0;
17444 else if (unformat (i, "pipe"))
17446 else if (unformat (i, "master"))
17448 else if (unformat (i, "slave"))
17454 if (!vec_len (if_name))
17456 errmsg ("interface name must be specified");
17460 if (vec_len (if_name) > 64)
17462 errmsg ("interface name too long");
17466 M (NETMAP_CREATE, mp);
17468 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17469 clib_memcpy (mp->hw_addr, hw_addr, 6);
17470 mp->use_random_hw_addr = random_hw_addr;
17471 mp->is_pipe = is_pipe;
17472 mp->is_master = is_master;
17473 vec_free (if_name);
17481 api_netmap_delete (vat_main_t * vam)
17483 unformat_input_t *i = vam->input;
17484 vl_api_netmap_delete_t *mp;
17488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17490 if (unformat (i, "name %s", &if_name))
17491 vec_add1 (if_name, 0);
17496 if (!vec_len (if_name))
17498 errmsg ("interface name must be specified");
17502 if (vec_len (if_name) > 64)
17504 errmsg ("interface name too long");
17508 M (NETMAP_DELETE, mp);
17510 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17511 vec_free (if_name);
17519 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
17521 if (fp->afi == IP46_TYPE_IP6)
17523 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17524 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17525 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17526 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17527 format_ip6_address, fp->next_hop);
17528 else if (fp->afi == IP46_TYPE_IP4)
17530 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17531 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17532 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17533 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17534 format_ip4_address, fp->next_hop);
17538 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17539 vl_api_fib_path2_t * fp)
17541 struct in_addr ip4;
17542 struct in6_addr ip6;
17544 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17545 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17546 vat_json_object_add_uint (node, "is_local", fp->is_local);
17547 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
17548 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
17549 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
17550 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
17551 if (fp->afi == IP46_TYPE_IP4)
17553 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
17554 vat_json_object_add_ip4 (node, "next_hop", ip4);
17556 else if (fp->afi == IP46_TYPE_IP6)
17558 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
17559 vat_json_object_add_ip6 (node, "next_hop", ip6);
17564 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17566 vat_main_t *vam = &vat_main;
17567 int count = ntohl (mp->mt_count);
17568 vl_api_fib_path2_t *fp;
17571 print (vam->ofp, "[%d]: sw_if_index %d via:",
17572 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
17574 for (i = 0; i < count; i++)
17576 vl_api_mpls_fib_path_print (vam, fp);
17580 print (vam->ofp, "");
17583 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17584 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17587 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17589 vat_main_t *vam = &vat_main;
17590 vat_json_node_t *node = NULL;
17591 int count = ntohl (mp->mt_count);
17592 vl_api_fib_path2_t *fp;
17595 if (VAT_JSON_ARRAY != vam->json_tree.type)
17597 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17598 vat_json_init_array (&vam->json_tree);
17600 node = vat_json_array_add (&vam->json_tree);
17602 vat_json_init_object (node);
17603 vat_json_object_add_uint (node, "tunnel_index",
17604 ntohl (mp->mt_tunnel_index));
17605 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
17607 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
17610 for (i = 0; i < count; i++)
17612 vl_api_mpls_fib_path_json_print (node, fp);
17618 api_mpls_tunnel_dump (vat_main_t * vam)
17620 vl_api_mpls_tunnel_dump_t *mp;
17621 vl_api_control_ping_t *mp_ping;
17625 /* Parse args required to build the message */
17626 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
17628 if (!unformat (vam->input, "tunnel_index %d", &index))
17635 print (vam->ofp, " tunnel_index %d", index);
17637 M (MPLS_TUNNEL_DUMP, mp);
17638 mp->tunnel_index = htonl (index);
17641 /* Use a control ping for synchronization */
17642 M (CONTROL_PING, mp_ping);
17649 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
17650 #define vl_api_mpls_fib_details_t_print vl_noop_handler
17654 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
17656 vat_main_t *vam = &vat_main;
17657 int count = ntohl (mp->count);
17658 vl_api_fib_path2_t *fp;
17662 "table-id %d, label %u, ess_bit %u",
17663 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
17665 for (i = 0; i < count; i++)
17667 vl_api_mpls_fib_path_print (vam, fp);
17672 static void vl_api_mpls_fib_details_t_handler_json
17673 (vl_api_mpls_fib_details_t * mp)
17675 vat_main_t *vam = &vat_main;
17676 int count = ntohl (mp->count);
17677 vat_json_node_t *node = NULL;
17678 vl_api_fib_path2_t *fp;
17681 if (VAT_JSON_ARRAY != vam->json_tree.type)
17683 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17684 vat_json_init_array (&vam->json_tree);
17686 node = vat_json_array_add (&vam->json_tree);
17688 vat_json_init_object (node);
17689 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
17690 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
17691 vat_json_object_add_uint (node, "label", ntohl (mp->label));
17692 vat_json_object_add_uint (node, "path_count", count);
17694 for (i = 0; i < count; i++)
17696 vl_api_mpls_fib_path_json_print (node, fp);
17702 api_mpls_fib_dump (vat_main_t * vam)
17704 vl_api_mpls_fib_dump_t *mp;
17705 vl_api_control_ping_t *mp_ping;
17708 M (MPLS_FIB_DUMP, mp);
17711 /* Use a control ping for synchronization */
17712 M (CONTROL_PING, mp_ping);
17719 #define vl_api_ip_fib_details_t_endian vl_noop_handler
17720 #define vl_api_ip_fib_details_t_print vl_noop_handler
17723 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
17725 vat_main_t *vam = &vat_main;
17726 int count = ntohl (mp->count);
17727 vl_api_fib_path_t *fp;
17731 "table-id %d, prefix %U/%d",
17732 ntohl (mp->table_id), format_ip4_address, mp->address,
17733 mp->address_length);
17735 for (i = 0; i < count; i++)
17737 if (fp->afi == IP46_TYPE_IP6)
17739 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17740 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17741 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17742 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17743 format_ip6_address, fp->next_hop);
17744 else if (fp->afi == IP46_TYPE_IP4)
17746 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17747 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17748 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17749 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17750 format_ip4_address, fp->next_hop);
17755 static void vl_api_ip_fib_details_t_handler_json
17756 (vl_api_ip_fib_details_t * mp)
17758 vat_main_t *vam = &vat_main;
17759 int count = ntohl (mp->count);
17760 vat_json_node_t *node = NULL;
17761 struct in_addr ip4;
17762 struct in6_addr ip6;
17763 vl_api_fib_path_t *fp;
17766 if (VAT_JSON_ARRAY != vam->json_tree.type)
17768 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17769 vat_json_init_array (&vam->json_tree);
17771 node = vat_json_array_add (&vam->json_tree);
17773 vat_json_init_object (node);
17774 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
17775 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
17776 vat_json_object_add_ip4 (node, "prefix", ip4);
17777 vat_json_object_add_uint (node, "mask_length", mp->address_length);
17778 vat_json_object_add_uint (node, "path_count", count);
17780 for (i = 0; i < count; i++)
17782 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17783 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17784 vat_json_object_add_uint (node, "is_local", fp->is_local);
17785 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
17786 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
17787 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
17788 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
17789 if (fp->afi == IP46_TYPE_IP4)
17791 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
17792 vat_json_object_add_ip4 (node, "next_hop", ip4);
17794 else if (fp->afi == IP46_TYPE_IP6)
17796 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
17797 vat_json_object_add_ip6 (node, "next_hop", ip6);
17803 api_ip_fib_dump (vat_main_t * vam)
17805 vl_api_ip_fib_dump_t *mp;
17806 vl_api_control_ping_t *mp_ping;
17809 M (IP_FIB_DUMP, mp);
17812 /* Use a control ping for synchronization */
17813 M (CONTROL_PING, mp_ping);
17821 api_ip_mfib_dump (vat_main_t * vam)
17823 vl_api_ip_mfib_dump_t *mp;
17824 vl_api_control_ping_t *mp_ping;
17827 M (IP_MFIB_DUMP, mp);
17830 /* Use a control ping for synchronization */
17831 M (CONTROL_PING, mp_ping);
17838 static void vl_api_ip_neighbor_details_t_handler
17839 (vl_api_ip_neighbor_details_t * mp)
17841 vat_main_t *vam = &vat_main;
17843 print (vam->ofp, "%c %U %U",
17844 (mp->is_static) ? 'S' : 'D',
17845 format_ethernet_address, &mp->mac_address,
17846 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
17850 static void vl_api_ip_neighbor_details_t_handler_json
17851 (vl_api_ip_neighbor_details_t * mp)
17854 vat_main_t *vam = &vat_main;
17855 vat_json_node_t *node;
17856 struct in_addr ip4;
17857 struct in6_addr ip6;
17859 if (VAT_JSON_ARRAY != vam->json_tree.type)
17861 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17862 vat_json_init_array (&vam->json_tree);
17864 node = vat_json_array_add (&vam->json_tree);
17866 vat_json_init_object (node);
17867 vat_json_object_add_string_copy (node, "flag",
17868 (mp->is_static) ? (u8 *) "static" : (u8 *)
17871 vat_json_object_add_string_copy (node, "link_layer",
17872 format (0, "%U", format_ethernet_address,
17873 &mp->mac_address));
17877 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
17878 vat_json_object_add_ip6 (node, "ip_address", ip6);
17882 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
17883 vat_json_object_add_ip4 (node, "ip_address", ip4);
17888 api_ip_neighbor_dump (vat_main_t * vam)
17890 unformat_input_t *i = vam->input;
17891 vl_api_ip_neighbor_dump_t *mp;
17892 vl_api_control_ping_t *mp_ping;
17894 u32 sw_if_index = ~0;
17897 /* Parse args required to build the message */
17898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17900 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17902 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17904 else if (unformat (i, "ip6"))
17910 if (sw_if_index == ~0)
17912 errmsg ("missing interface name or sw_if_index");
17916 M (IP_NEIGHBOR_DUMP, mp);
17917 mp->is_ipv6 = (u8) is_ipv6;
17918 mp->sw_if_index = ntohl (sw_if_index);
17921 /* Use a control ping for synchronization */
17922 M (CONTROL_PING, mp_ping);
17929 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
17930 #define vl_api_ip6_fib_details_t_print vl_noop_handler
17933 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
17935 vat_main_t *vam = &vat_main;
17936 int count = ntohl (mp->count);
17937 vl_api_fib_path_t *fp;
17941 "table-id %d, prefix %U/%d",
17942 ntohl (mp->table_id), format_ip6_address, mp->address,
17943 mp->address_length);
17945 for (i = 0; i < count; i++)
17947 if (fp->afi == IP46_TYPE_IP6)
17949 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17950 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17951 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17952 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17953 format_ip6_address, fp->next_hop);
17954 else if (fp->afi == IP46_TYPE_IP4)
17956 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
17957 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
17958 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
17959 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
17960 format_ip4_address, fp->next_hop);
17965 static void vl_api_ip6_fib_details_t_handler_json
17966 (vl_api_ip6_fib_details_t * mp)
17968 vat_main_t *vam = &vat_main;
17969 int count = ntohl (mp->count);
17970 vat_json_node_t *node = NULL;
17971 struct in_addr ip4;
17972 struct in6_addr ip6;
17973 vl_api_fib_path_t *fp;
17976 if (VAT_JSON_ARRAY != vam->json_tree.type)
17978 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17979 vat_json_init_array (&vam->json_tree);
17981 node = vat_json_array_add (&vam->json_tree);
17983 vat_json_init_object (node);
17984 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
17985 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
17986 vat_json_object_add_ip6 (node, "prefix", ip6);
17987 vat_json_object_add_uint (node, "mask_length", mp->address_length);
17988 vat_json_object_add_uint (node, "path_count", count);
17990 for (i = 0; i < count; i++)
17992 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17993 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17994 vat_json_object_add_uint (node, "is_local", fp->is_local);
17995 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
17996 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
17997 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
17998 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
17999 if (fp->afi == IP46_TYPE_IP4)
18001 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
18002 vat_json_object_add_ip4 (node, "next_hop", ip4);
18004 else if (fp->afi == IP46_TYPE_IP6)
18006 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
18007 vat_json_object_add_ip6 (node, "next_hop", ip6);
18013 api_ip6_fib_dump (vat_main_t * vam)
18015 vl_api_ip6_fib_dump_t *mp;
18016 vl_api_control_ping_t *mp_ping;
18019 M (IP6_FIB_DUMP, mp);
18022 /* Use a control ping for synchronization */
18023 M (CONTROL_PING, mp_ping);
18031 api_ip6_mfib_dump (vat_main_t * vam)
18033 vl_api_ip6_mfib_dump_t *mp;
18034 vl_api_control_ping_t *mp_ping;
18037 M (IP6_MFIB_DUMP, mp);
18040 /* Use a control ping for synchronization */
18041 M (CONTROL_PING, mp_ping);
18049 api_classify_table_ids (vat_main_t * vam)
18051 vl_api_classify_table_ids_t *mp;
18054 /* Construct the API message */
18055 M (CLASSIFY_TABLE_IDS, mp);
18064 api_classify_table_by_interface (vat_main_t * vam)
18066 unformat_input_t *input = vam->input;
18067 vl_api_classify_table_by_interface_t *mp;
18069 u32 sw_if_index = ~0;
18071 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18073 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18075 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18080 if (sw_if_index == ~0)
18082 errmsg ("missing interface name or sw_if_index");
18086 /* Construct the API message */
18087 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18089 mp->sw_if_index = ntohl (sw_if_index);
18097 api_classify_table_info (vat_main_t * vam)
18099 unformat_input_t *input = vam->input;
18100 vl_api_classify_table_info_t *mp;
18104 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18106 if (unformat (input, "table_id %d", &table_id))
18111 if (table_id == ~0)
18113 errmsg ("missing table id");
18117 /* Construct the API message */
18118 M (CLASSIFY_TABLE_INFO, mp);
18120 mp->table_id = ntohl (table_id);
18128 api_classify_session_dump (vat_main_t * vam)
18130 unformat_input_t *input = vam->input;
18131 vl_api_classify_session_dump_t *mp;
18132 vl_api_control_ping_t *mp_ping;
18136 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18138 if (unformat (input, "table_id %d", &table_id))
18143 if (table_id == ~0)
18145 errmsg ("missing table id");
18149 /* Construct the API message */
18150 M (CLASSIFY_SESSION_DUMP, mp);
18152 mp->table_id = ntohl (table_id);
18155 /* Use a control ping for synchronization */
18156 M (CONTROL_PING, mp_ping);
18164 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18166 vat_main_t *vam = &vat_main;
18168 print (vam->ofp, "collector_address %U, collector_port %d, "
18169 "src_address %U, vrf_id %d, path_mtu %u, "
18170 "template_interval %u, udp_checksum %d",
18171 format_ip4_address, mp->collector_address,
18172 ntohs (mp->collector_port),
18173 format_ip4_address, mp->src_address,
18174 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18175 ntohl (mp->template_interval), mp->udp_checksum);
18178 vam->result_ready = 1;
18182 vl_api_ipfix_exporter_details_t_handler_json
18183 (vl_api_ipfix_exporter_details_t * mp)
18185 vat_main_t *vam = &vat_main;
18186 vat_json_node_t node;
18187 struct in_addr collector_address;
18188 struct in_addr src_address;
18190 vat_json_init_object (&node);
18191 clib_memcpy (&collector_address, &mp->collector_address,
18192 sizeof (collector_address));
18193 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18194 vat_json_object_add_uint (&node, "collector_port",
18195 ntohs (mp->collector_port));
18196 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18197 vat_json_object_add_ip4 (&node, "src_address", src_address);
18198 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18199 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18200 vat_json_object_add_uint (&node, "template_interval",
18201 ntohl (mp->template_interval));
18202 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18204 vat_json_print (vam->ofp, &node);
18205 vat_json_free (&node);
18207 vam->result_ready = 1;
18211 api_ipfix_exporter_dump (vat_main_t * vam)
18213 vl_api_ipfix_exporter_dump_t *mp;
18216 /* Construct the API message */
18217 M (IPFIX_EXPORTER_DUMP, mp);
18226 api_ipfix_classify_stream_dump (vat_main_t * vam)
18228 vl_api_ipfix_classify_stream_dump_t *mp;
18231 /* Construct the API message */
18232 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18243 vl_api_ipfix_classify_stream_details_t_handler
18244 (vl_api_ipfix_classify_stream_details_t * mp)
18246 vat_main_t *vam = &vat_main;
18247 print (vam->ofp, "domain_id %d, src_port %d",
18248 ntohl (mp->domain_id), ntohs (mp->src_port));
18250 vam->result_ready = 1;
18254 vl_api_ipfix_classify_stream_details_t_handler_json
18255 (vl_api_ipfix_classify_stream_details_t * mp)
18257 vat_main_t *vam = &vat_main;
18258 vat_json_node_t node;
18260 vat_json_init_object (&node);
18261 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18262 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18264 vat_json_print (vam->ofp, &node);
18265 vat_json_free (&node);
18267 vam->result_ready = 1;
18271 api_ipfix_classify_table_dump (vat_main_t * vam)
18273 vl_api_ipfix_classify_table_dump_t *mp;
18274 vl_api_control_ping_t *mp_ping;
18277 if (!vam->json_output)
18279 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18280 "transport_protocol");
18283 /* Construct the API message */
18284 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18289 /* Use a control ping for synchronization */
18290 M (CONTROL_PING, mp_ping);
18298 vl_api_ipfix_classify_table_details_t_handler
18299 (vl_api_ipfix_classify_table_details_t * mp)
18301 vat_main_t *vam = &vat_main;
18302 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18303 mp->transport_protocol);
18307 vl_api_ipfix_classify_table_details_t_handler_json
18308 (vl_api_ipfix_classify_table_details_t * mp)
18310 vat_json_node_t *node = NULL;
18311 vat_main_t *vam = &vat_main;
18313 if (VAT_JSON_ARRAY != vam->json_tree.type)
18315 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18316 vat_json_init_array (&vam->json_tree);
18319 node = vat_json_array_add (&vam->json_tree);
18320 vat_json_init_object (node);
18322 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18323 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18324 vat_json_object_add_uint (node, "transport_protocol",
18325 mp->transport_protocol);
18329 api_sw_interface_span_enable_disable (vat_main_t * vam)
18331 unformat_input_t *i = vam->input;
18332 vl_api_sw_interface_span_enable_disable_t *mp;
18333 u32 src_sw_if_index = ~0;
18334 u32 dst_sw_if_index = ~0;
18339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18342 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18344 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18348 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18350 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18352 else if (unformat (i, "disable"))
18354 else if (unformat (i, "rx"))
18356 else if (unformat (i, "tx"))
18358 else if (unformat (i, "both"))
18360 else if (unformat (i, "l2"))
18366 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18368 mp->sw_if_index_from = htonl (src_sw_if_index);
18369 mp->sw_if_index_to = htonl (dst_sw_if_index);
18379 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18382 vat_main_t *vam = &vat_main;
18383 u8 *sw_if_from_name = 0;
18384 u8 *sw_if_to_name = 0;
18385 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18386 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18387 char *states[] = { "none", "rx", "tx", "both" };
18391 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18393 if ((u32) p->value[0] == sw_if_index_from)
18395 sw_if_from_name = (u8 *)(p->key);
18399 if ((u32) p->value[0] == sw_if_index_to)
18401 sw_if_to_name = (u8 *)(p->key);
18402 if (sw_if_from_name)
18407 print (vam->ofp, "%20s => %20s (%s)",
18408 sw_if_from_name, sw_if_to_name, states[mp->state]);
18412 vl_api_sw_interface_span_details_t_handler_json
18413 (vl_api_sw_interface_span_details_t * mp)
18415 vat_main_t *vam = &vat_main;
18416 vat_json_node_t *node = NULL;
18417 u8 *sw_if_from_name = 0;
18418 u8 *sw_if_to_name = 0;
18419 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18420 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18424 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18426 if ((u32) p->value[0] == sw_if_index_from)
18428 sw_if_from_name = (u8 *)(p->key);
18432 if ((u32) p->value[0] == sw_if_index_to)
18434 sw_if_to_name = (u8 *)(p->key);
18435 if (sw_if_from_name)
18441 if (VAT_JSON_ARRAY != vam->json_tree.type)
18443 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18444 vat_json_init_array (&vam->json_tree);
18446 node = vat_json_array_add (&vam->json_tree);
18448 vat_json_init_object (node);
18449 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18450 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18451 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18452 if (0 != sw_if_to_name)
18454 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18456 vat_json_object_add_uint (node, "state", mp->state);
18460 api_sw_interface_span_dump (vat_main_t * vam)
18462 unformat_input_t *input = vam->input;
18463 vl_api_sw_interface_span_dump_t *mp;
18464 vl_api_control_ping_t *mp_ping;
18468 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18470 if (unformat (input, "l2"))
18476 M (SW_INTERFACE_SPAN_DUMP, mp);
18480 /* Use a control ping for synchronization */
18481 M (CONTROL_PING, mp_ping);
18489 api_pg_create_interface (vat_main_t * vam)
18491 unformat_input_t *input = vam->input;
18492 vl_api_pg_create_interface_t *mp;
18496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18498 if (unformat (input, "if_id %d", &if_id))
18505 errmsg ("missing pg interface index");
18509 /* Construct the API message */
18510 M (PG_CREATE_INTERFACE, mp);
18512 mp->interface_id = ntohl (if_id);
18520 api_pg_capture (vat_main_t * vam)
18522 unformat_input_t *input = vam->input;
18523 vl_api_pg_capture_t *mp;
18528 u8 pcap_file_set = 0;
18531 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18533 if (unformat (input, "if_id %d", &if_id))
18535 else if (unformat (input, "pcap %s", &pcap_file))
18537 else if (unformat (input, "count %d", &count))
18539 else if (unformat (input, "disable"))
18546 errmsg ("missing pg interface index");
18549 if (pcap_file_set > 0)
18551 if (vec_len (pcap_file) > 255)
18553 errmsg ("pcap file name is too long");
18558 u32 name_len = vec_len (pcap_file);
18559 /* Construct the API message */
18560 M (PG_CAPTURE, mp);
18562 mp->interface_id = ntohl (if_id);
18563 mp->is_enabled = enable;
18564 mp->count = ntohl (count);
18565 mp->pcap_name_length = ntohl (name_len);
18566 if (pcap_file_set != 0)
18568 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18570 vec_free (pcap_file);
18578 api_pg_enable_disable (vat_main_t * vam)
18580 unformat_input_t *input = vam->input;
18581 vl_api_pg_enable_disable_t *mp;
18584 u8 stream_name_set = 0;
18585 u8 *stream_name = 0;
18587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18589 if (unformat (input, "stream %s", &stream_name))
18590 stream_name_set = 1;
18591 else if (unformat (input, "disable"))
18597 if (stream_name_set > 0)
18599 if (vec_len (stream_name) > 255)
18601 errmsg ("stream name too long");
18606 u32 name_len = vec_len (stream_name);
18607 /* Construct the API message */
18608 M (PG_ENABLE_DISABLE, mp);
18610 mp->is_enabled = enable;
18611 if (stream_name_set != 0)
18613 mp->stream_name_length = ntohl (name_len);
18614 clib_memcpy (mp->stream_name, stream_name, name_len);
18616 vec_free (stream_name);
18624 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18626 unformat_input_t *input = vam->input;
18627 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18629 u16 *low_ports = 0;
18630 u16 *high_ports = 0;
18633 ip4_address_t ip4_addr;
18634 ip6_address_t ip6_addr;
18643 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18645 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
18651 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
18656 else if (unformat (input, "vrf %d", &vrf_id))
18658 else if (unformat (input, "del"))
18660 else if (unformat (input, "port %d", &tmp))
18662 if (tmp == 0 || tmp > 65535)
18664 errmsg ("port %d out of range", tmp);
18668 this_hi = this_low + 1;
18669 vec_add1 (low_ports, this_low);
18670 vec_add1 (high_ports, this_hi);
18672 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18674 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18676 errmsg ("incorrect range parameters");
18680 /* Note: in debug CLI +1 is added to high before
18681 passing to real fn that does "the work"
18682 (ip_source_and_port_range_check_add_del).
18683 This fn is a wrapper around the binary API fn a
18684 control plane will call, which expects this increment
18685 to have occurred. Hence letting the binary API control
18686 plane fn do the increment for consistency between VAT
18687 and other control planes.
18690 vec_add1 (low_ports, this_low);
18691 vec_add1 (high_ports, this_hi);
18697 if (prefix_set == 0)
18699 errmsg ("<address>/<mask> not specified");
18705 errmsg ("VRF ID required, not specified");
18712 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18716 if (vec_len (low_ports) == 0)
18718 errmsg ("At least one port or port range required");
18722 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18724 mp->is_add = is_add;
18729 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
18734 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
18737 mp->mask_length = length;
18738 mp->number_of_ranges = vec_len (low_ports);
18740 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18741 vec_free (low_ports);
18743 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18744 vec_free (high_ports);
18746 mp->vrf_id = ntohl (vrf_id);
18754 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18756 unformat_input_t *input = vam->input;
18757 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18758 u32 sw_if_index = ~0;
18760 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18761 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18765 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18767 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18769 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18771 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18773 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18775 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18777 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18779 else if (unformat (input, "del"))
18785 if (sw_if_index == ~0)
18787 errmsg ("Interface required but not specified");
18793 errmsg ("VRF ID required but not specified");
18797 if (tcp_out_vrf_id == 0
18798 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18801 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18805 /* Construct the API message */
18806 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18808 mp->sw_if_index = ntohl (sw_if_index);
18809 mp->is_add = is_add;
18810 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18811 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18812 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18813 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18818 /* Wait for a reply... */
18824 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
18826 unformat_input_t *i = vam->input;
18827 vl_api_ipsec_gre_add_del_tunnel_t *mp;
18828 u32 local_sa_id = 0;
18829 u32 remote_sa_id = 0;
18830 ip4_address_t src_address;
18831 ip4_address_t dst_address;
18835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18837 if (unformat (i, "local_sa %d", &local_sa_id))
18839 else if (unformat (i, "remote_sa %d", &remote_sa_id))
18841 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
18843 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
18845 else if (unformat (i, "del"))
18849 clib_warning ("parse error '%U'", format_unformat_error, i);
18854 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
18856 mp->local_sa_id = ntohl (local_sa_id);
18857 mp->remote_sa_id = ntohl (remote_sa_id);
18858 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
18859 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
18860 mp->is_add = is_add;
18868 api_punt (vat_main_t * vam)
18870 unformat_input_t *i = vam->input;
18878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18880 if (unformat (i, "ip %d", &ipv))
18882 else if (unformat (i, "protocol %d", &protocol))
18884 else if (unformat (i, "port %d", &port))
18886 else if (unformat (i, "del"))
18890 clib_warning ("parse error '%U'", format_unformat_error, i);
18897 mp->is_add = (u8) is_add;
18898 mp->ipv = (u8) ipv;
18899 mp->l4_protocol = (u8) protocol;
18900 mp->l4_port = htons ((u16) port);
18907 static void vl_api_ipsec_gre_tunnel_details_t_handler
18908 (vl_api_ipsec_gre_tunnel_details_t * mp)
18910 vat_main_t *vam = &vat_main;
18912 print (vam->ofp, "%11d%15U%15U%14d%14d",
18913 ntohl (mp->sw_if_index),
18914 format_ip4_address, &mp->src_address,
18915 format_ip4_address, &mp->dst_address,
18916 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
18919 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
18920 (vl_api_ipsec_gre_tunnel_details_t * mp)
18922 vat_main_t *vam = &vat_main;
18923 vat_json_node_t *node = NULL;
18924 struct in_addr ip4;
18926 if (VAT_JSON_ARRAY != vam->json_tree.type)
18928 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18929 vat_json_init_array (&vam->json_tree);
18931 node = vat_json_array_add (&vam->json_tree);
18933 vat_json_init_object (node);
18934 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18935 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
18936 vat_json_object_add_ip4 (node, "src_address", ip4);
18937 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
18938 vat_json_object_add_ip4 (node, "dst_address", ip4);
18939 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
18940 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
18944 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
18946 unformat_input_t *i = vam->input;
18947 vl_api_ipsec_gre_tunnel_dump_t *mp;
18948 vl_api_control_ping_t *mp_ping;
18950 u8 sw_if_index_set = 0;
18953 /* Parse args required to build the message */
18954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18956 if (unformat (i, "sw_if_index %d", &sw_if_index))
18957 sw_if_index_set = 1;
18962 if (sw_if_index_set == 0)
18967 if (!vam->json_output)
18969 print (vam->ofp, "%11s%15s%15s%14s%14s",
18970 "sw_if_index", "src_address", "dst_address",
18971 "local_sa_id", "remote_sa_id");
18974 /* Get list of gre-tunnel interfaces */
18975 M (IPSEC_GRE_TUNNEL_DUMP, mp);
18977 mp->sw_if_index = htonl (sw_if_index);
18981 /* Use a control ping for synchronization */
18982 M (CONTROL_PING, mp_ping);
18990 api_delete_subif (vat_main_t * vam)
18992 unformat_input_t *i = vam->input;
18993 vl_api_delete_subif_t *mp;
18994 u32 sw_if_index = ~0;
18997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18999 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19001 if (unformat (i, "sw_if_index %d", &sw_if_index))
19007 if (sw_if_index == ~0)
19009 errmsg ("missing sw_if_index");
19013 /* Construct the API message */
19014 M (DELETE_SUBIF, mp);
19015 mp->sw_if_index = ntohl (sw_if_index);
19022 #define foreach_pbb_vtr_op \
19023 _("disable", L2_VTR_DISABLED) \
19024 _("pop", L2_VTR_POP_2) \
19025 _("push", L2_VTR_PUSH_2)
19028 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
19030 unformat_input_t *i = vam->input;
19031 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
19032 u32 sw_if_index = ~0, vtr_op = ~0;
19033 u16 outer_tag = ~0;
19034 u8 dmac[6], smac[6];
19035 u8 dmac_set = 0, smac_set = 0;
19041 /* Shut up coverity */
19042 memset (dmac, 0, sizeof (dmac));
19043 memset (smac, 0, sizeof (smac));
19045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19047 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19049 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19051 else if (unformat (i, "vtr_op %d", &vtr_op))
19053 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
19056 else if (unformat (i, "translate_pbb_stag"))
19058 if (unformat (i, "%d", &tmp))
19060 vtr_op = L2_VTR_TRANSLATE_2_1;
19066 ("translate_pbb_stag operation requires outer tag definition");
19070 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
19072 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
19074 else if (unformat (i, "sid %d", &sid))
19076 else if (unformat (i, "vlanid %d", &tmp))
19080 clib_warning ("parse error '%U'", format_unformat_error, i);
19085 if ((sw_if_index == ~0) || (vtr_op == ~0))
19087 errmsg ("missing sw_if_index or vtr operation");
19090 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19091 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19094 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19098 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19099 mp->sw_if_index = ntohl (sw_if_index);
19100 mp->vtr_op = ntohl (vtr_op);
19101 mp->outer_tag = ntohs (outer_tag);
19102 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19103 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19104 mp->b_vlanid = ntohs (vlanid);
19105 mp->i_sid = ntohl (sid);
19113 api_flow_classify_set_interface (vat_main_t * vam)
19115 unformat_input_t *i = vam->input;
19116 vl_api_flow_classify_set_interface_t *mp;
19118 int sw_if_index_set;
19119 u32 ip4_table_index = ~0;
19120 u32 ip6_table_index = ~0;
19124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19126 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19127 sw_if_index_set = 1;
19128 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19129 sw_if_index_set = 1;
19130 else if (unformat (i, "del"))
19132 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19134 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19138 clib_warning ("parse error '%U'", format_unformat_error, i);
19143 if (sw_if_index_set == 0)
19145 errmsg ("missing interface name or sw_if_index");
19149 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19151 mp->sw_if_index = ntohl (sw_if_index);
19152 mp->ip4_table_index = ntohl (ip4_table_index);
19153 mp->ip6_table_index = ntohl (ip6_table_index);
19154 mp->is_add = is_add;
19162 api_flow_classify_dump (vat_main_t * vam)
19164 unformat_input_t *i = vam->input;
19165 vl_api_flow_classify_dump_t *mp;
19166 vl_api_control_ping_t *mp_ping;
19167 u8 type = FLOW_CLASSIFY_N_TABLES;
19170 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19174 errmsg ("classify table type must be specified");
19178 if (!vam->json_output)
19180 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19183 M (FLOW_CLASSIFY_DUMP, mp);
19188 /* Use a control ping for synchronization */
19189 M (CONTROL_PING, mp_ping);
19192 /* Wait for a reply... */
19198 api_feature_enable_disable (vat_main_t * vam)
19200 unformat_input_t *i = vam->input;
19201 vl_api_feature_enable_disable_t *mp;
19203 u8 *feature_name = 0;
19204 u32 sw_if_index = ~0;
19208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19210 if (unformat (i, "arc_name %s", &arc_name))
19212 else if (unformat (i, "feature_name %s", &feature_name))
19215 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19217 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19219 else if (unformat (i, "disable"))
19227 errmsg ("missing arc name");
19230 if (vec_len (arc_name) > 63)
19232 errmsg ("arc name too long");
19235 if (feature_name == 0)
19237 errmsg ("missing feature name");
19240 if (vec_len (feature_name) > 63)
19242 errmsg ("feature name too long");
19245 if (sw_if_index == ~0)
19247 errmsg ("missing interface name or sw_if_index");
19251 /* Construct the API message */
19252 M (FEATURE_ENABLE_DISABLE, mp);
19253 mp->sw_if_index = ntohl (sw_if_index);
19254 mp->enable = enable;
19255 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19256 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19257 vec_free (arc_name);
19258 vec_free (feature_name);
19266 api_sw_interface_tag_add_del (vat_main_t * vam)
19268 unformat_input_t *i = vam->input;
19269 vl_api_sw_interface_tag_add_del_t *mp;
19270 u32 sw_if_index = ~0;
19275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19277 if (unformat (i, "tag %s", &tag))
19279 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19281 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19283 else if (unformat (i, "del"))
19289 if (sw_if_index == ~0)
19291 errmsg ("missing interface name or sw_if_index");
19295 if (enable && (tag == 0))
19297 errmsg ("no tag specified");
19301 /* Construct the API message */
19302 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19303 mp->sw_if_index = ntohl (sw_if_index);
19304 mp->is_add = enable;
19306 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19314 static void vl_api_l2_xconnect_details_t_handler
19315 (vl_api_l2_xconnect_details_t * mp)
19317 vat_main_t *vam = &vat_main;
19319 print (vam->ofp, "%15d%15d",
19320 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19323 static void vl_api_l2_xconnect_details_t_handler_json
19324 (vl_api_l2_xconnect_details_t * mp)
19326 vat_main_t *vam = &vat_main;
19327 vat_json_node_t *node = NULL;
19329 if (VAT_JSON_ARRAY != vam->json_tree.type)
19331 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19332 vat_json_init_array (&vam->json_tree);
19334 node = vat_json_array_add (&vam->json_tree);
19336 vat_json_init_object (node);
19337 vat_json_object_add_uint (node, "rx_sw_if_index",
19338 ntohl (mp->rx_sw_if_index));
19339 vat_json_object_add_uint (node, "tx_sw_if_index",
19340 ntohl (mp->tx_sw_if_index));
19344 api_l2_xconnect_dump (vat_main_t * vam)
19346 vl_api_l2_xconnect_dump_t *mp;
19347 vl_api_control_ping_t *mp_ping;
19350 if (!vam->json_output)
19352 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19355 M (L2_XCONNECT_DUMP, mp);
19359 /* Use a control ping for synchronization */
19360 M (CONTROL_PING, mp_ping);
19368 api_sw_interface_set_mtu (vat_main_t * vam)
19370 unformat_input_t *i = vam->input;
19371 vl_api_sw_interface_set_mtu_t *mp;
19372 u32 sw_if_index = ~0;
19376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19378 if (unformat (i, "mtu %d", &mtu))
19380 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19382 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19388 if (sw_if_index == ~0)
19390 errmsg ("missing interface name or sw_if_index");
19396 errmsg ("no mtu specified");
19400 /* Construct the API message */
19401 M (SW_INTERFACE_SET_MTU, mp);
19402 mp->sw_if_index = ntohl (sw_if_index);
19403 mp->mtu = ntohs ((u16) mtu);
19411 api_p2p_ethernet_add (vat_main_t * vam)
19413 unformat_input_t *i = vam->input;
19414 vl_api_p2p_ethernet_add_t *mp;
19415 u32 parent_if_index = ~0;
19421 memset (remote_mac, 0, sizeof (remote_mac));
19422 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19424 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19426 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19430 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19432 else if (unformat (i, "sub_id %d", &sub_id))
19436 clib_warning ("parse error '%U'", format_unformat_error, i);
19441 if (parent_if_index == ~0)
19443 errmsg ("missing interface name or sw_if_index");
19448 errmsg ("missing remote mac address");
19453 errmsg ("missing sub-interface id");
19457 M (P2P_ETHERNET_ADD, mp);
19458 mp->parent_if_index = ntohl (parent_if_index);
19459 mp->subif_id = ntohl (sub_id);
19460 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19468 api_p2p_ethernet_del (vat_main_t * vam)
19470 unformat_input_t *i = vam->input;
19471 vl_api_p2p_ethernet_del_t *mp;
19472 u32 parent_if_index = ~0;
19477 memset (remote_mac, 0, sizeof (remote_mac));
19478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19480 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19482 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19486 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19490 clib_warning ("parse error '%U'", format_unformat_error, i);
19495 if (parent_if_index == ~0)
19497 errmsg ("missing interface name or sw_if_index");
19502 errmsg ("missing remote mac address");
19506 M (P2P_ETHERNET_DEL, mp);
19507 mp->parent_if_index = ntohl (parent_if_index);
19508 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19516 api_lldp_config (vat_main_t * vam)
19518 unformat_input_t *i = vam->input;
19519 vl_api_lldp_config_t *mp;
19521 int tx_interval = 0;
19522 u8 *sys_name = NULL;
19525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19527 if (unformat (i, "system-name %s", &sys_name))
19529 else if (unformat (i, "tx-hold %d", &tx_hold))
19531 else if (unformat (i, "tx-interval %d", &tx_interval))
19535 clib_warning ("parse error '%U'", format_unformat_error, i);
19540 vec_add1 (sys_name, 0);
19542 M (LLDP_CONFIG, mp);
19543 mp->tx_hold = htonl (tx_hold);
19544 mp->tx_interval = htonl (tx_interval);
19545 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19546 vec_free (sys_name);
19554 api_sw_interface_set_lldp (vat_main_t * vam)
19556 unformat_input_t *i = vam->input;
19557 vl_api_sw_interface_set_lldp_t *mp;
19558 u32 sw_if_index = ~0;
19560 u8 *port_desc = NULL;
19563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19565 if (unformat (i, "disable"))
19568 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19570 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19572 else if (unformat (i, "port-desc %s", &port_desc))
19578 if (sw_if_index == ~0)
19580 errmsg ("missing interface name or sw_if_index");
19584 /* Construct the API message */
19585 vec_add1 (port_desc, 0);
19586 M (SW_INTERFACE_SET_LLDP, mp);
19587 mp->sw_if_index = ntohl (sw_if_index);
19588 mp->enable = enable;
19589 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19590 vec_free (port_desc);
19598 q_or_quit (vat_main_t * vam)
19600 #if VPP_API_TEST_BUILTIN == 0
19601 longjmp (vam->jump_buf, 1);
19603 return 0; /* not so much */
19607 q (vat_main_t * vam)
19609 return q_or_quit (vam);
19613 quit (vat_main_t * vam)
19615 return q_or_quit (vam);
19619 comment (vat_main_t * vam)
19625 cmd_cmp (void *a1, void *a2)
19630 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
19634 help (vat_main_t * vam)
19639 unformat_input_t *i = vam->input;
19642 if (unformat (i, "%s", &name))
19646 vec_add1 (name, 0);
19648 hs = hash_get_mem (vam->help_by_name, name);
19650 print (vam->ofp, "usage: %s %s", name, hs[0]);
19652 print (vam->ofp, "No such msg / command '%s'", name);
19657 print (vam->ofp, "Help is available for the following:");
19660 hash_foreach_pair (p, vam->function_by_name,
19662 vec_add1 (cmds, (u8 *)(p->key));
19666 vec_sort_with_function (cmds, cmd_cmp);
19668 for (j = 0; j < vec_len (cmds); j++)
19669 print (vam->ofp, "%s", cmds[j]);
19676 set (vat_main_t * vam)
19678 u8 *name = 0, *value = 0;
19679 unformat_input_t *i = vam->input;
19681 if (unformat (i, "%s", &name))
19683 /* The input buffer is a vector, not a string. */
19684 value = vec_dup (i->buffer);
19685 vec_delete (value, i->index, 0);
19686 /* Almost certainly has a trailing newline */
19687 if (value[vec_len (value) - 1] == '\n')
19688 value[vec_len (value) - 1] = 0;
19689 /* Make sure it's a proper string, one way or the other */
19690 vec_add1 (value, 0);
19691 (void) clib_macro_set_value (&vam->macro_main,
19692 (char *) name, (char *) value);
19695 errmsg ("usage: set <name> <value>");
19703 unset (vat_main_t * vam)
19707 if (unformat (vam->input, "%s", &name))
19708 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
19709 errmsg ("unset: %s wasn't set", name);
19722 macro_sort_cmp (void *a1, void *a2)
19724 macro_sort_t *s1 = a1;
19725 macro_sort_t *s2 = a2;
19727 return strcmp ((char *) (s1->name), (char *) (s2->name));
19731 dump_macro_table (vat_main_t * vam)
19733 macro_sort_t *sort_me = 0, *sm;
19738 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
19740 vec_add2 (sort_me, sm, 1);
19741 sm->name = (u8 *)(p->key);
19742 sm->value = (u8 *) (p->value[0]);
19746 vec_sort_with_function (sort_me, macro_sort_cmp);
19748 if (vec_len (sort_me))
19749 print (vam->ofp, "%-15s%s", "Name", "Value");
19751 print (vam->ofp, "The macro table is empty...");
19753 for (i = 0; i < vec_len (sort_me); i++)
19754 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
19759 dump_node_table (vat_main_t * vam)
19762 vlib_node_t *node, *next_node;
19764 if (vec_len (vam->graph_nodes) == 0)
19766 print (vam->ofp, "Node table empty, issue get_node_graph...");
19770 for (i = 0; i < vec_len (vam->graph_nodes); i++)
19772 node = vam->graph_nodes[i];
19773 print (vam->ofp, "[%d] %s", i, node->name);
19774 for (j = 0; j < vec_len (node->next_nodes); j++)
19776 if (node->next_nodes[j] != ~0)
19778 next_node = vam->graph_nodes[node->next_nodes[j]];
19779 print (vam->ofp, " [%d] %s", j, next_node->name);
19787 value_sort_cmp (void *a1, void *a2)
19789 name_sort_t *n1 = a1;
19790 name_sort_t *n2 = a2;
19792 if (n1->value < n2->value)
19794 if (n1->value > n2->value)
19801 dump_msg_api_table (vat_main_t * vam)
19803 api_main_t *am = &api_main;
19804 name_sort_t *nses = 0, *ns;
19809 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
19811 vec_add2 (nses, ns, 1);
19812 ns->name = (u8 *)(hp->key);
19813 ns->value = (u32) hp->value[0];
19817 vec_sort_with_function (nses, value_sort_cmp);
19819 for (i = 0; i < vec_len (nses); i++)
19820 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
19826 get_msg_id (vat_main_t * vam)
19831 if (unformat (vam->input, "%s", &name_and_crc))
19833 message_index = vl_api_get_msg_index (name_and_crc);
19834 if (message_index == ~0)
19836 print (vam->ofp, " '%s' not found", name_and_crc);
19839 print (vam->ofp, " '%s' has message index %d",
19840 name_and_crc, message_index);
19843 errmsg ("name_and_crc required...");
19848 search_node_table (vat_main_t * vam)
19850 unformat_input_t *line_input = vam->input;
19853 vlib_node_t *node, *next_node;
19856 if (vam->graph_node_index_by_name == 0)
19858 print (vam->ofp, "Node table empty, issue get_node_graph...");
19862 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
19864 if (unformat (line_input, "%s", &node_to_find))
19866 vec_add1 (node_to_find, 0);
19867 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
19870 print (vam->ofp, "%s not found...", node_to_find);
19873 node = vam->graph_nodes[p[0]];
19874 print (vam->ofp, "[%d] %s", p[0], node->name);
19875 for (j = 0; j < vec_len (node->next_nodes); j++)
19877 if (node->next_nodes[j] != ~0)
19879 next_node = vam->graph_nodes[node->next_nodes[j]];
19880 print (vam->ofp, " [%d] %s", j, next_node->name);
19887 clib_warning ("parse error '%U'", format_unformat_error,
19893 vec_free (node_to_find);
19902 script (vat_main_t * vam)
19904 #if (VPP_API_TEST_BUILTIN==0)
19906 char *save_current_file;
19907 unformat_input_t save_input;
19908 jmp_buf save_jump_buf;
19909 u32 save_line_number;
19911 FILE *new_fp, *save_ifp;
19913 if (unformat (vam->input, "%s", &s))
19915 new_fp = fopen ((char *) s, "r");
19918 errmsg ("Couldn't open script file %s", s);
19925 errmsg ("Missing script name");
19929 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
19930 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
19931 save_ifp = vam->ifp;
19932 save_line_number = vam->input_line_number;
19933 save_current_file = (char *) vam->current_file;
19935 vam->input_line_number = 0;
19937 vam->current_file = s;
19940 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
19941 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
19942 vam->ifp = save_ifp;
19943 vam->input_line_number = save_line_number;
19944 vam->current_file = (u8 *) save_current_file;
19949 clib_warning ("use the exec command...");
19955 echo (vat_main_t * vam)
19957 print (vam->ofp, "%v", vam->input->buffer);
19961 /* List of API message constructors, CLI names map to api_xxx */
19962 #define foreach_vpe_api_msg \
19963 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
19964 _(sw_interface_dump,"") \
19965 _(sw_interface_set_flags, \
19966 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
19967 _(sw_interface_add_del_address, \
19968 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
19969 _(sw_interface_set_table, \
19970 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
19971 _(sw_interface_set_mpls_enable, \
19972 "<intfc> | sw_if_index [disable | dis]") \
19973 _(sw_interface_set_vpath, \
19974 "<intfc> | sw_if_index <id> enable | disable") \
19975 _(sw_interface_set_vxlan_bypass, \
19976 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
19977 _(sw_interface_set_l2_xconnect, \
19978 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
19979 "enable | disable") \
19980 _(sw_interface_set_l2_bridge, \
19981 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
19982 "[shg <split-horizon-group>] [bvi]\n" \
19983 "enable | disable") \
19984 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
19985 _(bridge_domain_add_del, \
19986 "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") \
19987 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
19989 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
19990 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
19991 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
19993 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
19995 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
19997 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
19999 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
20001 "<vpp-if-name> | sw_if_index <id>") \
20002 _(sw_interface_tap_dump, "") \
20003 _(ip_add_del_route, \
20004 "<addr>/<mask> via <addr> [table-id <n>]\n" \
20005 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
20006 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
20007 "[multipath] [count <n>]") \
20008 _(ip_mroute_add_del, \
20009 "<src> <grp>/<mask> [table-id <n>]\n" \
20010 "[<intfc> | sw_if_index <id>] [local] [del]") \
20011 _(mpls_route_add_del, \
20012 "<label> <eos> via <addr> [table-id <n>]\n" \
20013 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
20014 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
20015 "[multipath] [count <n>]") \
20016 _(mpls_ip_bind_unbind, \
20017 "<label> <addr/len>") \
20018 _(mpls_tunnel_add_del, \
20019 " via <addr> [table-id <n>]\n" \
20020 "sw_if_index <id>] [l2] [del]") \
20021 _(proxy_arp_add_del, \
20022 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
20023 _(proxy_arp_intfc_enable_disable, \
20024 "<intfc> | sw_if_index <id> enable | disable") \
20025 _(sw_interface_set_unnumbered, \
20026 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20027 _(ip_neighbor_add_del, \
20028 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
20029 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
20030 _(reset_vrf, "vrf <id> [ipv6]") \
20031 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20032 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20033 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20034 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20035 "[outer_vlan_id_any][inner_vlan_id_any]") \
20036 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
20037 _(reset_fib, "vrf <n> [ipv6]") \
20038 _(dhcp_proxy_config, \
20039 "svr <v46-address> src <v46-address>\n" \
20040 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
20041 _(dhcp_proxy_set_vss, \
20042 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
20043 _(dhcp_proxy_dump, "ip6") \
20044 _(dhcp_client_config, \
20045 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
20046 _(set_ip_flow_hash, \
20047 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20048 _(sw_interface_ip6_enable_disable, \
20049 "<intfc> | sw_if_index <id> enable | disable") \
20050 _(sw_interface_ip6_set_link_local_address, \
20051 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
20052 _(ip6nd_proxy_add_del, \
20053 "<intfc> | sw_if_index <id> <ip6-address>") \
20054 _(ip6nd_proxy_dump, "") \
20055 _(sw_interface_ip6nd_ra_prefix, \
20056 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
20057 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
20058 "[nolink] [isno]") \
20059 _(sw_interface_ip6nd_ra_config, \
20060 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
20061 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
20062 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
20063 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
20064 _(l2_patch_add_del, \
20065 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20066 "enable | disable") \
20067 _(sr_localsid_add_del, \
20068 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20069 "fib-table <num> (end.psp) sw_if_index <num>") \
20070 _(classify_add_del_table, \
20071 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20072 " [del] [del-chain] mask <mask-value>\n" \
20073 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20074 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20075 _(classify_add_del_session, \
20076 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20077 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20078 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20079 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20080 _(classify_set_interface_ip_table, \
20081 "<intfc> | sw_if_index <nn> table <nn>") \
20082 _(classify_set_interface_l2_tables, \
20083 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20084 " [other-table <nn>]") \
20085 _(get_node_index, "node <node-name") \
20086 _(add_node_next, "node <node-name> next <next-node-name>") \
20087 _(l2tpv3_create_tunnel, \
20088 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20089 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20090 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20091 _(l2tpv3_set_tunnel_cookies, \
20092 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20093 "[new_remote_cookie <nn>]\n") \
20094 _(l2tpv3_interface_enable_disable, \
20095 "<intfc> | sw_if_index <nn> enable | disable") \
20096 _(l2tpv3_set_lookup_key, \
20097 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20098 _(sw_if_l2tpv3_tunnel_dump, "") \
20099 _(vxlan_add_del_tunnel, \
20100 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20101 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20102 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20103 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20104 _(gre_add_del_tunnel, \
20105 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
20106 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20107 _(l2_fib_clear_table, "") \
20108 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20109 _(l2_interface_vlan_tag_rewrite, \
20110 "<intfc> | sw_if_index <nn> \n" \
20111 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20112 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20113 _(create_vhost_user_if, \
20114 "socket <filename> [server] [renumber <dev_instance>] " \
20115 "[mac <mac_address>]") \
20116 _(modify_vhost_user_if, \
20117 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20118 "[server] [renumber <dev_instance>]") \
20119 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20120 _(sw_interface_vhost_user_dump, "") \
20121 _(show_version, "") \
20122 _(vxlan_gpe_add_del_tunnel, \
20123 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20124 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20125 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20126 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20127 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20128 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20129 _(interface_name_renumber, \
20130 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20131 _(input_acl_set_interface, \
20132 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20133 " [l2-table <nn>] [del]") \
20134 _(want_ip4_arp_events, "address <ip4-address> [del]") \
20135 _(want_ip6_nd_events, "address <ip6-address> [del]") \
20136 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20137 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20138 _(ip_dump, "ipv4 | ipv6") \
20139 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20140 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20142 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20143 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20144 " integ_alg <alg> integ_key <hex>") \
20145 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
20146 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20147 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20148 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20149 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
20150 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20151 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20152 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20153 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
20154 _(ikev2_profile_add_del, "name <profile_name> [del]") \
20155 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
20156 "(auth_data 0x<data> | auth_data <data>)") \
20157 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
20158 "(id_data 0x<data> | id_data <data>) (local|remote)") \
20159 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
20160 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
20161 "(local|remote)") \
20162 _(ikev2_set_local_key, "file <absolute_file_path>") \
20163 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
20164 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
20165 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
20166 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
20167 _(ikev2_initiate_sa_init, "<profile_name>") \
20168 _(ikev2_initiate_del_ike_sa, "<ispi>") \
20169 _(ikev2_initiate_del_child_sa, "<ispi>") \
20170 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
20171 _(delete_loopback,"sw_if_index <nn>") \
20172 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20173 _(map_add_domain, \
20174 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
20175 "ip6-src <ip6addr> " \
20176 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
20177 _(map_del_domain, "index <n>") \
20178 _(map_add_del_rule, \
20179 "index <n> psid <n> dst <ip6addr> [del]") \
20180 _(map_domain_dump, "") \
20181 _(map_rule_dump, "index <map-domain>") \
20182 _(want_interface_events, "enable|disable") \
20183 _(want_stats,"enable|disable") \
20184 _(get_first_msg_id, "client <name>") \
20185 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20186 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20187 "fib-id <nn> [ip4][ip6][default]") \
20188 _(get_node_graph, " ") \
20189 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20190 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20191 _(ioam_disable, "") \
20192 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20193 " sw_if_index <sw_if_index> p <priority> " \
20194 "w <weight>] [del]") \
20195 _(one_add_del_locator, "locator-set <locator_name> " \
20196 "iface <intf> | sw_if_index <sw_if_index> " \
20197 "p <priority> w <weight> [del]") \
20198 _(one_add_del_local_eid,"vni <vni> eid " \
20199 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20200 "locator-set <locator_name> [del]" \
20201 "[key-id sha1|sha256 secret-key <secret-key>]")\
20202 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20203 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20204 _(one_enable_disable, "enable|disable") \
20205 _(one_map_register_enable_disable, "enable|disable") \
20206 _(one_map_register_fallback_threshold, "<value>") \
20207 _(one_rloc_probe_enable_disable, "enable|disable") \
20208 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20210 "rloc <locator> p <prio> " \
20211 "w <weight> [rloc <loc> ... ] " \
20212 "action <action> [del-all]") \
20213 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20215 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20216 _(one_use_petr, "ip-address> | disable") \
20217 _(one_map_request_mode, "src-dst|dst-only") \
20218 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20219 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20220 _(one_locator_set_dump, "[local | remote]") \
20221 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20222 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20223 "[local] | [remote]") \
20224 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20225 _(one_l2_arp_bd_get, "") \
20226 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20227 _(one_stats_enable_disable, "enable|disalbe") \
20228 _(show_one_stats_enable_disable, "") \
20229 _(one_eid_table_vni_dump, "") \
20230 _(one_eid_table_map_dump, "l2|l3") \
20231 _(one_map_resolver_dump, "") \
20232 _(one_map_server_dump, "") \
20233 _(one_adjacencies_get, "vni <vni>") \
20234 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20235 _(show_one_rloc_probe_state, "") \
20236 _(show_one_map_register_state, "") \
20237 _(show_one_status, "") \
20238 _(one_stats_dump, "") \
20239 _(one_stats_flush, "") \
20240 _(one_get_map_request_itr_rlocs, "") \
20241 _(one_map_register_set_ttl, "<ttl>") \
20242 _(show_one_nsh_mapping, "") \
20243 _(show_one_pitr, "") \
20244 _(show_one_use_petr, "") \
20245 _(show_one_map_request_mode, "") \
20246 _(show_one_map_register_ttl, "") \
20247 _(show_one_map_register_fallback_threshold, "") \
20248 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20249 " sw_if_index <sw_if_index> p <priority> " \
20250 "w <weight>] [del]") \
20251 _(lisp_add_del_locator, "locator-set <locator_name> " \
20252 "iface <intf> | sw_if_index <sw_if_index> " \
20253 "p <priority> w <weight> [del]") \
20254 _(lisp_add_del_local_eid,"vni <vni> eid " \
20255 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20256 "locator-set <locator_name> [del]" \
20257 "[key-id sha1|sha256 secret-key <secret-key>]") \
20258 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20259 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20260 _(lisp_enable_disable, "enable|disable") \
20261 _(lisp_map_register_enable_disable, "enable|disable") \
20262 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20263 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20265 "rloc <locator> p <prio> " \
20266 "w <weight> [rloc <loc> ... ] " \
20267 "action <action> [del-all]") \
20268 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20270 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20271 _(lisp_use_petr, "<ip-address> | disable") \
20272 _(lisp_map_request_mode, "src-dst|dst-only") \
20273 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20274 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20275 _(lisp_locator_set_dump, "[local | remote]") \
20276 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20277 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20278 "[local] | [remote]") \
20279 _(lisp_eid_table_vni_dump, "") \
20280 _(lisp_eid_table_map_dump, "l2|l3") \
20281 _(lisp_map_resolver_dump, "") \
20282 _(lisp_map_server_dump, "") \
20283 _(lisp_adjacencies_get, "vni <vni>") \
20284 _(gpe_fwd_entry_vnis_get, "") \
20285 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20286 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20287 "[table <table-id>]") \
20288 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20289 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20290 _(gpe_set_encap_mode, "lisp|vxlan") \
20291 _(gpe_get_encap_mode, "") \
20292 _(lisp_gpe_add_del_iface, "up|down") \
20293 _(lisp_gpe_enable_disable, "enable|disable") \
20294 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20295 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20296 _(show_lisp_rloc_probe_state, "") \
20297 _(show_lisp_map_register_state, "") \
20298 _(show_lisp_status, "") \
20299 _(lisp_get_map_request_itr_rlocs, "") \
20300 _(show_lisp_pitr, "") \
20301 _(show_lisp_use_petr, "") \
20302 _(show_lisp_map_request_mode, "") \
20303 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20304 _(af_packet_delete, "name <host interface name>") \
20305 _(policer_add_del, "name <policer name> <params> [del]") \
20306 _(policer_dump, "[name <policer name>]") \
20307 _(policer_classify_set_interface, \
20308 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20309 " [l2-table <nn>] [del]") \
20310 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20311 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
20312 "[master|slave]") \
20313 _(netmap_delete, "name <interface name>") \
20314 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20315 _(mpls_fib_dump, "") \
20316 _(classify_table_ids, "") \
20317 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20318 _(classify_table_info, "table_id <nn>") \
20319 _(classify_session_dump, "table_id <nn>") \
20320 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20321 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20322 "[template_interval <nn>] [udp_checksum]") \
20323 _(ipfix_exporter_dump, "") \
20324 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20325 _(ipfix_classify_stream_dump, "") \
20326 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20327 _(ipfix_classify_table_dump, "") \
20328 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20329 _(sw_interface_span_dump, "[l2]") \
20330 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20331 _(pg_create_interface, "if_id <nn>") \
20332 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20333 _(pg_enable_disable, "[stream <id>] disable") \
20334 _(ip_source_and_port_range_check_add_del, \
20335 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20336 _(ip_source_and_port_range_check_interface_add_del, \
20337 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20338 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20339 _(ipsec_gre_add_del_tunnel, \
20340 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
20341 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
20342 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20343 _(l2_interface_pbb_tag_rewrite, \
20344 "<intfc> | sw_if_index <nn> \n" \
20345 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
20346 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
20347 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
20348 _(flow_classify_set_interface, \
20349 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
20350 _(flow_classify_dump, "type [ip4|ip6]") \
20351 _(ip_fib_dump, "") \
20352 _(ip_mfib_dump, "") \
20353 _(ip6_fib_dump, "") \
20354 _(ip6_mfib_dump, "") \
20355 _(feature_enable_disable, "arc_name <arc_name> " \
20356 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
20357 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
20359 _(l2_xconnect_dump, "") \
20360 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
20361 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
20362 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
20363 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
20364 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
20365 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
20366 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>] [disable]")
20368 /* List of command functions, CLI names map directly to functions */
20369 #define foreach_cli_function \
20370 _(comment, "usage: comment <ignore-rest-of-line>") \
20371 _(dump_interface_table, "usage: dump_interface_table") \
20372 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
20373 _(dump_ipv4_table, "usage: dump_ipv4_table") \
20374 _(dump_ipv6_table, "usage: dump_ipv6_table") \
20375 _(dump_stats_table, "usage: dump_stats_table") \
20376 _(dump_macro_table, "usage: dump_macro_table ") \
20377 _(dump_node_table, "usage: dump_node_table") \
20378 _(dump_msg_api_table, "usage: dump_msg_api_table") \
20379 _(get_msg_id, "usage: get_msg_id name_and_crc") \
20380 _(echo, "usage: echo <message>") \
20381 _(exec, "usage: exec <vpe-debug-CLI-command>") \
20382 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
20383 _(help, "usage: help") \
20384 _(q, "usage: quit") \
20385 _(quit, "usage: quit") \
20386 _(search_node_table, "usage: search_node_table <name>...") \
20387 _(set, "usage: set <variable-name> <value>") \
20388 _(script, "usage: script <file-name>") \
20389 _(unset, "usage: unset <variable-name>")
20391 static void vl_api_##n##_t_handler_uni \
20392 (vl_api_##n##_t * mp) \
20394 vat_main_t * vam = &vat_main; \
20395 if (vam->json_output) { \
20396 vl_api_##n##_t_handler_json(mp); \
20398 vl_api_##n##_t_handler(mp); \
20401 foreach_vpe_api_reply_msg;
20402 #if VPP_API_TEST_BUILTIN == 0
20403 foreach_standalone_reply_msg;
20408 vat_api_hookup (vat_main_t * vam)
20411 vl_msg_api_set_handlers(VL_API_##N, #n, \
20412 vl_api_##n##_t_handler_uni, \
20414 vl_api_##n##_t_endian, \
20415 vl_api_##n##_t_print, \
20416 sizeof(vl_api_##n##_t), 1);
20417 foreach_vpe_api_reply_msg;
20418 #if VPP_API_TEST_BUILTIN == 0
20419 foreach_standalone_reply_msg;
20423 #if (VPP_API_TEST_BUILTIN==0)
20424 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
20426 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
20428 vam->function_by_name = hash_create_string (0, sizeof (uword));
20430 vam->help_by_name = hash_create_string (0, sizeof (uword));
20433 /* API messages we can send */
20434 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
20435 foreach_vpe_api_msg;
20439 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
20440 foreach_vpe_api_msg;
20443 /* CLI functions */
20444 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
20445 foreach_cli_function;
20449 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
20450 foreach_cli_function;
20454 #if VPP_API_TEST_BUILTIN
20455 static clib_error_t *
20456 vat_api_hookup_shim (vlib_main_t * vm)
20458 vat_api_hookup (&vat_main);
20462 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
20466 * fd.io coding-style-patch-verification: ON
20469 * eval: (c-set-style "gnu")