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 */
406 #define VHOST_USER_POLLING_MODE 0
407 #define VHOST_USER_INTERRUPT_MODE 1
408 #define VHOST_USER_ADAPTIVE_MODE 2
411 api_format_vhost_user_operation_mode (u8 * s, va_list * va)
413 int operation_mode = va_arg (*va, int);
415 switch (operation_mode)
417 case VHOST_USER_POLLING_MODE:
418 s = format (s, "%-9s", "polling");
420 case VHOST_USER_INTERRUPT_MODE:
421 s = format (s, "%-9s", "interrupt");
424 s = format (s, "%-9s", "invalid");
430 api_unformat_vhost_user_operation_mode (unformat_input_t * input,
433 u8 *operation_mode = va_arg (*args, u8 *);
436 if (unformat (input, "interrupt"))
437 *operation_mode = VHOST_USER_INTERRUPT_MODE;
438 else if (unformat (input, "polling"))
439 *operation_mode = VHOST_USER_POLLING_MODE;
447 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
449 u8 *r = va_arg (*args, u8 *);
451 if (unformat (input, "kbps"))
452 *r = SSE2_QOS_RATE_KBPS;
453 else if (unformat (input, "pps"))
454 *r = SSE2_QOS_RATE_PPS;
461 unformat_policer_round_type (unformat_input_t * input, va_list * args)
463 u8 *r = va_arg (*args, u8 *);
465 if (unformat (input, "closest"))
466 *r = SSE2_QOS_ROUND_TO_CLOSEST;
467 else if (unformat (input, "up"))
468 *r = SSE2_QOS_ROUND_TO_UP;
469 else if (unformat (input, "down"))
470 *r = SSE2_QOS_ROUND_TO_DOWN;
477 unformat_policer_type (unformat_input_t * input, va_list * args)
479 u8 *r = va_arg (*args, u8 *);
481 if (unformat (input, "1r2c"))
482 *r = SSE2_QOS_POLICER_TYPE_1R2C;
483 else if (unformat (input, "1r3c"))
484 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
485 else if (unformat (input, "2r3c-2698"))
486 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
487 else if (unformat (input, "2r3c-4115"))
488 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
489 else if (unformat (input, "2r3c-mef5cf1"))
490 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
497 unformat_dscp (unformat_input_t * input, va_list * va)
499 u8 *r = va_arg (*va, u8 *);
502 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
511 unformat_policer_action_type (unformat_input_t * input, va_list * va)
513 sse2_qos_pol_action_params_st *a
514 = va_arg (*va, sse2_qos_pol_action_params_st *);
516 if (unformat (input, "drop"))
517 a->action_type = SSE2_QOS_ACTION_DROP;
518 else if (unformat (input, "transmit"))
519 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
520 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
521 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
528 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
530 u32 *r = va_arg (*va, u32 *);
533 if (unformat (input, "ip4"))
534 tid = POLICER_CLASSIFY_TABLE_IP4;
535 else if (unformat (input, "ip6"))
536 tid = POLICER_CLASSIFY_TABLE_IP6;
537 else if (unformat (input, "l2"))
538 tid = POLICER_CLASSIFY_TABLE_L2;
547 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
549 u32 *r = va_arg (*va, u32 *);
552 if (unformat (input, "ip4"))
553 tid = FLOW_CLASSIFY_TABLE_IP4;
554 else if (unformat (input, "ip6"))
555 tid = FLOW_CLASSIFY_TABLE_IP6;
563 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
564 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
565 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
566 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
568 #if (VPP_API_TEST_BUILTIN==0)
570 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
572 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
573 mfib_itf_attribute_t attr;
576 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
578 if (unformat (input, mfib_itf_flag_long_names[attr]))
579 *iflags |= (1 << attr);
581 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
583 if (unformat (input, mfib_itf_flag_names[attr]))
584 *iflags |= (1 << attr);
587 return (old == *iflags ? 0 : 1);
591 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
593 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
594 mfib_entry_attribute_t attr;
597 FOR_EACH_MFIB_ATTRIBUTE (attr)
599 if (unformat (input, mfib_flag_long_names[attr]))
600 *eflags |= (1 << attr);
602 FOR_EACH_MFIB_ATTRIBUTE (attr)
604 if (unformat (input, mfib_flag_names[attr]))
605 *eflags |= (1 << attr);
608 return (old == *eflags ? 0 : 1);
612 format_ip4_address (u8 * s, va_list * args)
614 u8 *a = va_arg (*args, u8 *);
615 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
619 format_ip6_address (u8 * s, va_list * args)
621 ip6_address_t *a = va_arg (*args, ip6_address_t *);
622 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
624 i_max_n_zero = ARRAY_LEN (a->as_u16);
626 i_first_zero = i_max_n_zero;
628 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
630 u32 is_zero = a->as_u16[i] == 0;
631 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
637 if ((!is_zero && n_zeros > max_n_zeros)
638 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
640 i_max_n_zero = i_first_zero;
641 max_n_zeros = n_zeros;
642 i_first_zero = ARRAY_LEN (a->as_u16);
647 last_double_colon = 0;
648 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
650 if (i == i_max_n_zero && max_n_zeros > 1)
652 s = format (s, "::");
653 i += max_n_zeros - 1;
654 last_double_colon = 1;
658 s = format (s, "%s%x",
659 (last_double_colon || i == 0) ? "" : ":",
660 clib_net_to_host_u16 (a->as_u16[i]));
661 last_double_colon = 0;
668 /* Format an IP46 address. */
670 format_ip46_address (u8 * s, va_list * args)
672 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
673 ip46_type_t type = va_arg (*args, ip46_type_t);
679 is_ip4 = ip46_address_is_ip4 (ip46);
690 format (s, "%U", format_ip4_address, &ip46->ip4) :
691 format (s, "%U", format_ip6_address, &ip46->ip6);
695 format_ethernet_address (u8 * s, va_list * args)
697 u8 *a = va_arg (*args, u8 *);
699 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
700 a[0], a[1], a[2], a[3], a[4], a[5]);
705 increment_v4_address (ip4_address_t * a)
709 v = ntohl (a->as_u32) + 1;
710 a->as_u32 = ntohl (v);
714 increment_v6_address (ip6_address_t * a)
718 v0 = clib_net_to_host_u64 (a->as_u64[0]);
719 v1 = clib_net_to_host_u64 (a->as_u64[1]);
724 a->as_u64[0] = clib_net_to_host_u64 (v0);
725 a->as_u64[1] = clib_net_to_host_u64 (v1);
729 increment_mac_address (u64 * mac)
733 tmp = clib_net_to_host_u64 (tmp);
734 tmp += 1 << 16; /* skip unused (least significant) octets */
735 tmp = clib_host_to_net_u64 (tmp);
739 static void vl_api_create_loopback_reply_t_handler
740 (vl_api_create_loopback_reply_t * mp)
742 vat_main_t *vam = &vat_main;
743 i32 retval = ntohl (mp->retval);
745 vam->retval = retval;
746 vam->regenerate_interface_table = 1;
747 vam->sw_if_index = ntohl (mp->sw_if_index);
748 vam->result_ready = 1;
751 static void vl_api_create_loopback_reply_t_handler_json
752 (vl_api_create_loopback_reply_t * mp)
754 vat_main_t *vam = &vat_main;
755 vat_json_node_t node;
757 vat_json_init_object (&node);
758 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
759 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
761 vat_json_print (vam->ofp, &node);
762 vat_json_free (&node);
763 vam->retval = ntohl (mp->retval);
764 vam->result_ready = 1;
767 static void vl_api_create_loopback_instance_reply_t_handler
768 (vl_api_create_loopback_instance_reply_t * mp)
770 vat_main_t *vam = &vat_main;
771 i32 retval = ntohl (mp->retval);
773 vam->retval = retval;
774 vam->regenerate_interface_table = 1;
775 vam->sw_if_index = ntohl (mp->sw_if_index);
776 vam->result_ready = 1;
779 static void vl_api_create_loopback_instance_reply_t_handler_json
780 (vl_api_create_loopback_instance_reply_t * mp)
782 vat_main_t *vam = &vat_main;
783 vat_json_node_t node;
785 vat_json_init_object (&node);
786 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
787 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
789 vat_json_print (vam->ofp, &node);
790 vat_json_free (&node);
791 vam->retval = ntohl (mp->retval);
792 vam->result_ready = 1;
795 static void vl_api_af_packet_create_reply_t_handler
796 (vl_api_af_packet_create_reply_t * mp)
798 vat_main_t *vam = &vat_main;
799 i32 retval = ntohl (mp->retval);
801 vam->retval = retval;
802 vam->regenerate_interface_table = 1;
803 vam->sw_if_index = ntohl (mp->sw_if_index);
804 vam->result_ready = 1;
807 static void vl_api_af_packet_create_reply_t_handler_json
808 (vl_api_af_packet_create_reply_t * mp)
810 vat_main_t *vam = &vat_main;
811 vat_json_node_t node;
813 vat_json_init_object (&node);
814 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
815 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
817 vat_json_print (vam->ofp, &node);
818 vat_json_free (&node);
820 vam->retval = ntohl (mp->retval);
821 vam->result_ready = 1;
824 static void vl_api_create_vlan_subif_reply_t_handler
825 (vl_api_create_vlan_subif_reply_t * mp)
827 vat_main_t *vam = &vat_main;
828 i32 retval = ntohl (mp->retval);
830 vam->retval = retval;
831 vam->regenerate_interface_table = 1;
832 vam->sw_if_index = ntohl (mp->sw_if_index);
833 vam->result_ready = 1;
836 static void vl_api_create_vlan_subif_reply_t_handler_json
837 (vl_api_create_vlan_subif_reply_t * mp)
839 vat_main_t *vam = &vat_main;
840 vat_json_node_t node;
842 vat_json_init_object (&node);
843 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
844 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
846 vat_json_print (vam->ofp, &node);
847 vat_json_free (&node);
849 vam->retval = ntohl (mp->retval);
850 vam->result_ready = 1;
853 static void vl_api_create_subif_reply_t_handler
854 (vl_api_create_subif_reply_t * mp)
856 vat_main_t *vam = &vat_main;
857 i32 retval = ntohl (mp->retval);
859 vam->retval = retval;
860 vam->regenerate_interface_table = 1;
861 vam->sw_if_index = ntohl (mp->sw_if_index);
862 vam->result_ready = 1;
865 static void vl_api_create_subif_reply_t_handler_json
866 (vl_api_create_subif_reply_t * mp)
868 vat_main_t *vam = &vat_main;
869 vat_json_node_t node;
871 vat_json_init_object (&node);
872 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
873 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
875 vat_json_print (vam->ofp, &node);
876 vat_json_free (&node);
878 vam->retval = ntohl (mp->retval);
879 vam->result_ready = 1;
882 static void vl_api_interface_name_renumber_reply_t_handler
883 (vl_api_interface_name_renumber_reply_t * mp)
885 vat_main_t *vam = &vat_main;
886 i32 retval = ntohl (mp->retval);
888 vam->retval = retval;
889 vam->regenerate_interface_table = 1;
890 vam->result_ready = 1;
893 static void vl_api_interface_name_renumber_reply_t_handler_json
894 (vl_api_interface_name_renumber_reply_t * mp)
896 vat_main_t *vam = &vat_main;
897 vat_json_node_t node;
899 vat_json_init_object (&node);
900 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
902 vat_json_print (vam->ofp, &node);
903 vat_json_free (&node);
905 vam->retval = ntohl (mp->retval);
906 vam->result_ready = 1;
910 * Special-case: build the interface table, maintain
911 * the next loopback sw_if_index vbl.
913 static void vl_api_sw_interface_details_t_handler
914 (vl_api_sw_interface_details_t * mp)
916 vat_main_t *vam = &vat_main;
917 u8 *s = format (0, "%s%c", mp->interface_name, 0);
919 hash_set_mem (vam->sw_if_index_by_interface_name, s,
920 ntohl (mp->sw_if_index));
922 /* In sub interface case, fill the sub interface table entry */
923 if (mp->sw_if_index != mp->sup_sw_if_index)
925 sw_interface_subif_t *sub = NULL;
927 vec_add2 (vam->sw_if_subif_table, sub, 1);
929 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
930 strncpy ((char *) sub->interface_name, (char *) s,
931 vec_len (sub->interface_name));
932 sub->sw_if_index = ntohl (mp->sw_if_index);
933 sub->sub_id = ntohl (mp->sub_id);
935 sub->sub_dot1ad = mp->sub_dot1ad;
936 sub->sub_number_of_tags = mp->sub_number_of_tags;
937 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
938 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
939 sub->sub_exact_match = mp->sub_exact_match;
940 sub->sub_default = mp->sub_default;
941 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
942 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
944 /* vlan tag rewrite */
945 sub->vtr_op = ntohl (mp->vtr_op);
946 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
947 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
948 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
952 static void vl_api_sw_interface_details_t_handler_json
953 (vl_api_sw_interface_details_t * mp)
955 vat_main_t *vam = &vat_main;
956 vat_json_node_t *node = NULL;
958 if (VAT_JSON_ARRAY != vam->json_tree.type)
960 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
961 vat_json_init_array (&vam->json_tree);
963 node = vat_json_array_add (&vam->json_tree);
965 vat_json_init_object (node);
966 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
967 vat_json_object_add_uint (node, "sup_sw_if_index",
968 ntohl (mp->sup_sw_if_index));
969 vat_json_object_add_uint (node, "l2_address_length",
970 ntohl (mp->l2_address_length));
971 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
972 sizeof (mp->l2_address));
973 vat_json_object_add_string_copy (node, "interface_name",
975 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
976 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
977 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
978 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
979 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
980 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
981 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
982 vat_json_object_add_uint (node, "sub_number_of_tags",
983 mp->sub_number_of_tags);
984 vat_json_object_add_uint (node, "sub_outer_vlan_id",
985 ntohs (mp->sub_outer_vlan_id));
986 vat_json_object_add_uint (node, "sub_inner_vlan_id",
987 ntohs (mp->sub_inner_vlan_id));
988 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
989 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
990 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
991 mp->sub_outer_vlan_id_any);
992 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
993 mp->sub_inner_vlan_id_any);
994 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
995 vat_json_object_add_uint (node, "vtr_push_dot1q",
996 ntohl (mp->vtr_push_dot1q));
997 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
998 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1001 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1003 format_ethernet_address,
1005 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1007 format_ethernet_address,
1009 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1010 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1014 #if VPP_API_TEST_BUILTIN == 0
1015 static void vl_api_sw_interface_set_flags_t_handler
1016 (vl_api_sw_interface_set_flags_t * mp)
1018 vat_main_t *vam = &vat_main;
1019 if (vam->interface_event_display)
1020 errmsg ("interface flags: sw_if_index %d %s %s",
1021 ntohl (mp->sw_if_index),
1022 mp->admin_up_down ? "admin-up" : "admin-down",
1023 mp->link_up_down ? "link-up" : "link-down");
1027 static void vl_api_sw_interface_set_flags_t_handler_json
1028 (vl_api_sw_interface_set_flags_t * mp)
1030 /* JSON output not supported */
1034 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1036 vat_main_t *vam = &vat_main;
1037 i32 retval = ntohl (mp->retval);
1039 vam->retval = retval;
1040 vam->shmem_result = (u8 *) mp->reply_in_shmem;
1041 vam->result_ready = 1;
1045 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1047 vat_main_t *vam = &vat_main;
1048 vat_json_node_t node;
1049 api_main_t *am = &api_main;
1053 vat_json_init_object (&node);
1054 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1055 vat_json_object_add_uint (&node, "reply_in_shmem",
1056 ntohl (mp->reply_in_shmem));
1057 /* Toss the shared-memory original... */
1058 pthread_mutex_lock (&am->vlib_rp->mutex);
1059 oldheap = svm_push_data_heap (am->vlib_rp);
1061 reply = (u8 *) (mp->reply_in_shmem);
1064 svm_pop_heap (oldheap);
1065 pthread_mutex_unlock (&am->vlib_rp->mutex);
1067 vat_json_print (vam->ofp, &node);
1068 vat_json_free (&node);
1070 vam->retval = ntohl (mp->retval);
1071 vam->result_ready = 1;
1075 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1077 vat_main_t *vam = &vat_main;
1078 i32 retval = ntohl (mp->retval);
1080 vam->retval = retval;
1081 vam->cmd_reply = mp->reply;
1082 vam->result_ready = 1;
1086 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1088 vat_main_t *vam = &vat_main;
1089 vat_json_node_t node;
1091 vat_json_init_object (&node);
1092 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1093 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1095 vat_json_print (vam->ofp, &node);
1096 vat_json_free (&node);
1098 vam->retval = ntohl (mp->retval);
1099 vam->result_ready = 1;
1102 static void vl_api_classify_add_del_table_reply_t_handler
1103 (vl_api_classify_add_del_table_reply_t * mp)
1105 vat_main_t *vam = &vat_main;
1106 i32 retval = ntohl (mp->retval);
1107 if (vam->async_mode)
1109 vam->async_errors += (retval < 0);
1113 vam->retval = retval;
1115 ((mp->new_table_index != 0xFFFFFFFF) ||
1116 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1117 (mp->match_n_vectors != 0xFFFFFFFF)))
1119 * Note: this is just barely thread-safe, depends on
1120 * the main thread spinning waiting for an answer...
1122 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1123 ntohl (mp->new_table_index),
1124 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1125 vam->result_ready = 1;
1129 static void vl_api_classify_add_del_table_reply_t_handler_json
1130 (vl_api_classify_add_del_table_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, "new_table_index",
1138 ntohl (mp->new_table_index));
1139 vat_json_object_add_uint (&node, "skip_n_vectors",
1140 ntohl (mp->skip_n_vectors));
1141 vat_json_object_add_uint (&node, "match_n_vectors",
1142 ntohl (mp->match_n_vectors));
1144 vat_json_print (vam->ofp, &node);
1145 vat_json_free (&node);
1147 vam->retval = ntohl (mp->retval);
1148 vam->result_ready = 1;
1151 static void vl_api_get_node_index_reply_t_handler
1152 (vl_api_get_node_index_reply_t * mp)
1154 vat_main_t *vam = &vat_main;
1155 i32 retval = ntohl (mp->retval);
1156 if (vam->async_mode)
1158 vam->async_errors += (retval < 0);
1162 vam->retval = retval;
1164 errmsg ("node index %d", ntohl (mp->node_index));
1165 vam->result_ready = 1;
1169 static void vl_api_get_node_index_reply_t_handler_json
1170 (vl_api_get_node_index_reply_t * mp)
1172 vat_main_t *vam = &vat_main;
1173 vat_json_node_t node;
1175 vat_json_init_object (&node);
1176 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1177 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1179 vat_json_print (vam->ofp, &node);
1180 vat_json_free (&node);
1182 vam->retval = ntohl (mp->retval);
1183 vam->result_ready = 1;
1186 static void vl_api_get_next_index_reply_t_handler
1187 (vl_api_get_next_index_reply_t * mp)
1189 vat_main_t *vam = &vat_main;
1190 i32 retval = ntohl (mp->retval);
1191 if (vam->async_mode)
1193 vam->async_errors += (retval < 0);
1197 vam->retval = retval;
1199 errmsg ("next node index %d", ntohl (mp->next_index));
1200 vam->result_ready = 1;
1204 static void vl_api_get_next_index_reply_t_handler_json
1205 (vl_api_get_next_index_reply_t * mp)
1207 vat_main_t *vam = &vat_main;
1208 vat_json_node_t node;
1210 vat_json_init_object (&node);
1211 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1212 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1214 vat_json_print (vam->ofp, &node);
1215 vat_json_free (&node);
1217 vam->retval = ntohl (mp->retval);
1218 vam->result_ready = 1;
1221 static void vl_api_add_node_next_reply_t_handler
1222 (vl_api_add_node_next_reply_t * mp)
1224 vat_main_t *vam = &vat_main;
1225 i32 retval = ntohl (mp->retval);
1226 if (vam->async_mode)
1228 vam->async_errors += (retval < 0);
1232 vam->retval = retval;
1234 errmsg ("next index %d", ntohl (mp->next_index));
1235 vam->result_ready = 1;
1239 static void vl_api_add_node_next_reply_t_handler_json
1240 (vl_api_add_node_next_reply_t * mp)
1242 vat_main_t *vam = &vat_main;
1243 vat_json_node_t node;
1245 vat_json_init_object (&node);
1246 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1247 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1249 vat_json_print (vam->ofp, &node);
1250 vat_json_free (&node);
1252 vam->retval = ntohl (mp->retval);
1253 vam->result_ready = 1;
1256 static void vl_api_show_version_reply_t_handler
1257 (vl_api_show_version_reply_t * mp)
1259 vat_main_t *vam = &vat_main;
1260 i32 retval = ntohl (mp->retval);
1264 errmsg (" program: %s", mp->program);
1265 errmsg (" version: %s", mp->version);
1266 errmsg (" build date: %s", mp->build_date);
1267 errmsg ("build directory: %s", mp->build_directory);
1269 vam->retval = retval;
1270 vam->result_ready = 1;
1273 static void vl_api_show_version_reply_t_handler_json
1274 (vl_api_show_version_reply_t * mp)
1276 vat_main_t *vam = &vat_main;
1277 vat_json_node_t node;
1279 vat_json_init_object (&node);
1280 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1281 vat_json_object_add_string_copy (&node, "program", mp->program);
1282 vat_json_object_add_string_copy (&node, "version", mp->version);
1283 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1284 vat_json_object_add_string_copy (&node, "build_directory",
1285 mp->build_directory);
1287 vat_json_print (vam->ofp, &node);
1288 vat_json_free (&node);
1290 vam->retval = ntohl (mp->retval);
1291 vam->result_ready = 1;
1295 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1297 u32 sw_if_index = ntohl (mp->sw_if_index);
1298 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1299 mp->mac_ip ? "mac/ip binding" : "address resolution",
1300 ntohl (mp->pid), format_ip4_address, &mp->address,
1301 format_ethernet_address, mp->new_mac, sw_if_index);
1305 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1307 /* JSON output not supported */
1311 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1313 u32 sw_if_index = ntohl (mp->sw_if_index);
1314 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1315 mp->mac_ip ? "mac/ip binding" : "address resolution",
1316 ntohl (mp->pid), format_ip6_address, mp->address,
1317 format_ethernet_address, mp->new_mac, sw_if_index);
1321 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1323 /* JSON output not supported */
1327 * Special-case: build the bridge domain table, maintain
1328 * the next bd id vbl.
1330 static void vl_api_bridge_domain_details_t_handler
1331 (vl_api_bridge_domain_details_t * mp)
1333 vat_main_t *vam = &vat_main;
1334 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1336 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1337 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1339 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1340 ntohl (mp->bd_id), mp->learn, mp->forward,
1341 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1344 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG", "Interface Name");
1347 static void vl_api_bridge_domain_details_t_handler_json
1348 (vl_api_bridge_domain_details_t * mp)
1350 vat_main_t *vam = &vat_main;
1351 vat_json_node_t *node, *array = NULL;
1353 if (VAT_JSON_ARRAY != vam->json_tree.type)
1355 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1356 vat_json_init_array (&vam->json_tree);
1358 node = vat_json_array_add (&vam->json_tree);
1360 vat_json_init_object (node);
1361 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1362 vat_json_object_add_uint (node, "flood", mp->flood);
1363 vat_json_object_add_uint (node, "forward", mp->forward);
1364 vat_json_object_add_uint (node, "learn", mp->learn);
1365 vat_json_object_add_uint (node, "bvi_sw_if_index",
1366 ntohl (mp->bvi_sw_if_index));
1367 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1368 array = vat_json_object_add (node, "sw_if");
1369 vat_json_init_array (array);
1373 * Special-case: build the bridge domain sw if table.
1375 static void vl_api_bridge_domain_sw_if_details_t_handler
1376 (vl_api_bridge_domain_sw_if_details_t * mp)
1378 vat_main_t *vam = &vat_main;
1383 sw_if_index = ntohl (mp->sw_if_index);
1385 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1387 if ((u32) p->value[0] == sw_if_index)
1389 sw_if_name = (u8 *)(p->key);
1395 print (vam->ofp, "%7d %3d %s", sw_if_index,
1396 mp->shg, sw_if_name ? (char *) sw_if_name :
1397 "sw_if_index not found!");
1400 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1401 (vl_api_bridge_domain_sw_if_details_t * mp)
1403 vat_main_t *vam = &vat_main;
1404 vat_json_node_t *node = NULL;
1405 uword last_index = 0;
1407 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1408 ASSERT (vec_len (vam->json_tree.array) >= 1);
1409 last_index = vec_len (vam->json_tree.array) - 1;
1410 node = &vam->json_tree.array[last_index];
1411 node = vat_json_object_get_element (node, "sw_if");
1412 ASSERT (NULL != node);
1413 node = vat_json_array_add (node);
1415 vat_json_init_object (node);
1416 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1417 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1418 vat_json_object_add_uint (node, "shg", mp->shg);
1421 static void vl_api_control_ping_reply_t_handler
1422 (vl_api_control_ping_reply_t * mp)
1424 vat_main_t *vam = &vat_main;
1425 i32 retval = ntohl (mp->retval);
1426 if (vam->async_mode)
1428 vam->async_errors += (retval < 0);
1432 vam->retval = retval;
1433 vam->result_ready = 1;
1437 static void vl_api_control_ping_reply_t_handler_json
1438 (vl_api_control_ping_reply_t * mp)
1440 vat_main_t *vam = &vat_main;
1441 i32 retval = ntohl (mp->retval);
1443 if (VAT_JSON_NONE != vam->json_tree.type)
1445 vat_json_print (vam->ofp, &vam->json_tree);
1446 vat_json_free (&vam->json_tree);
1447 vam->json_tree.type = VAT_JSON_NONE;
1452 vat_json_init_array (&vam->json_tree);
1453 vat_json_print (vam->ofp, &vam->json_tree);
1454 vam->json_tree.type = VAT_JSON_NONE;
1457 vam->retval = retval;
1458 vam->result_ready = 1;
1462 vl_api_bridge_domain_set_mac_age_reply_t_handler
1463 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1465 vat_main_t *vam = &vat_main;
1466 i32 retval = ntohl (mp->retval);
1467 if (vam->async_mode)
1469 vam->async_errors += (retval < 0);
1473 vam->retval = retval;
1474 vam->result_ready = 1;
1478 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1479 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1481 vat_main_t *vam = &vat_main;
1482 vat_json_node_t node;
1484 vat_json_init_object (&node);
1485 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1487 vat_json_print (vam->ofp, &node);
1488 vat_json_free (&node);
1490 vam->retval = ntohl (mp->retval);
1491 vam->result_ready = 1;
1495 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1497 vat_main_t *vam = &vat_main;
1498 i32 retval = ntohl (mp->retval);
1499 if (vam->async_mode)
1501 vam->async_errors += (retval < 0);
1505 vam->retval = retval;
1506 vam->result_ready = 1;
1510 static void vl_api_l2_flags_reply_t_handler_json
1511 (vl_api_l2_flags_reply_t * mp)
1513 vat_main_t *vam = &vat_main;
1514 vat_json_node_t node;
1516 vat_json_init_object (&node);
1517 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1518 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1519 ntohl (mp->resulting_feature_bitmap));
1521 vat_json_print (vam->ofp, &node);
1522 vat_json_free (&node);
1524 vam->retval = ntohl (mp->retval);
1525 vam->result_ready = 1;
1528 static void vl_api_bridge_flags_reply_t_handler
1529 (vl_api_bridge_flags_reply_t * mp)
1531 vat_main_t *vam = &vat_main;
1532 i32 retval = ntohl (mp->retval);
1533 if (vam->async_mode)
1535 vam->async_errors += (retval < 0);
1539 vam->retval = retval;
1540 vam->result_ready = 1;
1544 static void vl_api_bridge_flags_reply_t_handler_json
1545 (vl_api_bridge_flags_reply_t * mp)
1547 vat_main_t *vam = &vat_main;
1548 vat_json_node_t node;
1550 vat_json_init_object (&node);
1551 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1552 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1553 ntohl (mp->resulting_feature_bitmap));
1555 vat_json_print (vam->ofp, &node);
1556 vat_json_free (&node);
1558 vam->retval = ntohl (mp->retval);
1559 vam->result_ready = 1;
1562 static void vl_api_tap_connect_reply_t_handler
1563 (vl_api_tap_connect_reply_t * mp)
1565 vat_main_t *vam = &vat_main;
1566 i32 retval = ntohl (mp->retval);
1567 if (vam->async_mode)
1569 vam->async_errors += (retval < 0);
1573 vam->retval = retval;
1574 vam->sw_if_index = ntohl (mp->sw_if_index);
1575 vam->result_ready = 1;
1580 static void vl_api_tap_connect_reply_t_handler_json
1581 (vl_api_tap_connect_reply_t * mp)
1583 vat_main_t *vam = &vat_main;
1584 vat_json_node_t node;
1586 vat_json_init_object (&node);
1587 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1588 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1590 vat_json_print (vam->ofp, &node);
1591 vat_json_free (&node);
1593 vam->retval = ntohl (mp->retval);
1594 vam->result_ready = 1;
1599 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1601 vat_main_t *vam = &vat_main;
1602 i32 retval = ntohl (mp->retval);
1603 if (vam->async_mode)
1605 vam->async_errors += (retval < 0);
1609 vam->retval = retval;
1610 vam->sw_if_index = ntohl (mp->sw_if_index);
1611 vam->result_ready = 1;
1615 static void vl_api_tap_modify_reply_t_handler_json
1616 (vl_api_tap_modify_reply_t * mp)
1618 vat_main_t *vam = &vat_main;
1619 vat_json_node_t node;
1621 vat_json_init_object (&node);
1622 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1623 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1625 vat_json_print (vam->ofp, &node);
1626 vat_json_free (&node);
1628 vam->retval = ntohl (mp->retval);
1629 vam->result_ready = 1;
1633 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1635 vat_main_t *vam = &vat_main;
1636 i32 retval = ntohl (mp->retval);
1637 if (vam->async_mode)
1639 vam->async_errors += (retval < 0);
1643 vam->retval = retval;
1644 vam->result_ready = 1;
1648 static void vl_api_tap_delete_reply_t_handler_json
1649 (vl_api_tap_delete_reply_t * mp)
1651 vat_main_t *vam = &vat_main;
1652 vat_json_node_t node;
1654 vat_json_init_object (&node);
1655 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1657 vat_json_print (vam->ofp, &node);
1658 vat_json_free (&node);
1660 vam->retval = ntohl (mp->retval);
1661 vam->result_ready = 1;
1664 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1665 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1667 vat_main_t *vam = &vat_main;
1668 i32 retval = ntohl (mp->retval);
1669 if (vam->async_mode)
1671 vam->async_errors += (retval < 0);
1675 vam->retval = retval;
1676 vam->result_ready = 1;
1680 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1681 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1683 vat_main_t *vam = &vat_main;
1684 vat_json_node_t node;
1686 vat_json_init_object (&node);
1687 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1688 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1689 ntohl (mp->sw_if_index));
1691 vat_json_print (vam->ofp, &node);
1692 vat_json_free (&node);
1694 vam->retval = ntohl (mp->retval);
1695 vam->result_ready = 1;
1698 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1699 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1701 vat_main_t *vam = &vat_main;
1702 i32 retval = ntohl (mp->retval);
1703 if (vam->async_mode)
1705 vam->async_errors += (retval < 0);
1709 vam->retval = retval;
1710 vam->sw_if_index = ntohl (mp->sw_if_index);
1711 vam->result_ready = 1;
1715 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1716 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1718 vat_main_t *vam = &vat_main;
1719 vat_json_node_t node;
1721 vat_json_init_object (&node);
1722 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1723 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1725 vat_json_print (vam->ofp, &node);
1726 vat_json_free (&node);
1728 vam->retval = ntohl (mp->retval);
1729 vam->result_ready = 1;
1733 static void vl_api_one_add_del_locator_set_reply_t_handler
1734 (vl_api_one_add_del_locator_set_reply_t * mp)
1736 vat_main_t *vam = &vat_main;
1737 i32 retval = ntohl (mp->retval);
1738 if (vam->async_mode)
1740 vam->async_errors += (retval < 0);
1744 vam->retval = retval;
1745 vam->result_ready = 1;
1749 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1750 (vl_api_one_add_del_locator_set_reply_t * mp)
1752 vat_main_t *vam = &vat_main;
1753 vat_json_node_t node;
1755 vat_json_init_object (&node);
1756 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1757 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1759 vat_json_print (vam->ofp, &node);
1760 vat_json_free (&node);
1762 vam->retval = ntohl (mp->retval);
1763 vam->result_ready = 1;
1766 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1767 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1769 vat_main_t *vam = &vat_main;
1770 i32 retval = ntohl (mp->retval);
1771 if (vam->async_mode)
1773 vam->async_errors += (retval < 0);
1777 vam->retval = retval;
1778 vam->sw_if_index = ntohl (mp->sw_if_index);
1779 vam->result_ready = 1;
1783 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1784 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1786 vat_main_t *vam = &vat_main;
1787 vat_json_node_t node;
1789 vat_json_init_object (&node);
1790 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1791 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1793 vat_json_print (vam->ofp, &node);
1794 vat_json_free (&node);
1796 vam->retval = ntohl (mp->retval);
1797 vam->result_ready = 1;
1800 static void vl_api_gre_add_del_tunnel_reply_t_handler
1801 (vl_api_gre_add_del_tunnel_reply_t * mp)
1803 vat_main_t *vam = &vat_main;
1804 i32 retval = ntohl (mp->retval);
1805 if (vam->async_mode)
1807 vam->async_errors += (retval < 0);
1811 vam->retval = retval;
1812 vam->sw_if_index = ntohl (mp->sw_if_index);
1813 vam->result_ready = 1;
1817 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1818 (vl_api_gre_add_del_tunnel_reply_t * mp)
1820 vat_main_t *vam = &vat_main;
1821 vat_json_node_t node;
1823 vat_json_init_object (&node);
1824 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1825 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1827 vat_json_print (vam->ofp, &node);
1828 vat_json_free (&node);
1830 vam->retval = ntohl (mp->retval);
1831 vam->result_ready = 1;
1834 static void vl_api_create_vhost_user_if_reply_t_handler
1835 (vl_api_create_vhost_user_if_reply_t * mp)
1837 vat_main_t *vam = &vat_main;
1838 i32 retval = ntohl (mp->retval);
1839 if (vam->async_mode)
1841 vam->async_errors += (retval < 0);
1845 vam->retval = retval;
1846 vam->sw_if_index = ntohl (mp->sw_if_index);
1847 vam->result_ready = 1;
1851 static void vl_api_create_vhost_user_if_reply_t_handler_json
1852 (vl_api_create_vhost_user_if_reply_t * mp)
1854 vat_main_t *vam = &vat_main;
1855 vat_json_node_t node;
1857 vat_json_init_object (&node);
1858 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1859 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1861 vat_json_print (vam->ofp, &node);
1862 vat_json_free (&node);
1864 vam->retval = ntohl (mp->retval);
1865 vam->result_ready = 1;
1868 static void vl_api_ip_address_details_t_handler
1869 (vl_api_ip_address_details_t * mp)
1871 vat_main_t *vam = &vat_main;
1872 static ip_address_details_t empty_ip_address_details = { {0} };
1873 ip_address_details_t *address = NULL;
1874 ip_details_t *current_ip_details = NULL;
1875 ip_details_t *details = NULL;
1877 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1879 if (!details || vam->current_sw_if_index >= vec_len (details)
1880 || !details[vam->current_sw_if_index].present)
1882 errmsg ("ip address details arrived but not stored");
1883 errmsg ("ip_dump should be called first");
1887 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1889 #define addresses (current_ip_details->addr)
1891 vec_validate_init_empty (addresses, vec_len (addresses),
1892 empty_ip_address_details);
1894 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1896 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1897 address->prefix_length = mp->prefix_length;
1901 static void vl_api_ip_address_details_t_handler_json
1902 (vl_api_ip_address_details_t * mp)
1904 vat_main_t *vam = &vat_main;
1905 vat_json_node_t *node = NULL;
1906 struct in6_addr ip6;
1909 if (VAT_JSON_ARRAY != vam->json_tree.type)
1911 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1912 vat_json_init_array (&vam->json_tree);
1914 node = vat_json_array_add (&vam->json_tree);
1916 vat_json_init_object (node);
1919 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1920 vat_json_object_add_ip6 (node, "ip", ip6);
1924 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1925 vat_json_object_add_ip4 (node, "ip", ip4);
1927 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1931 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1933 vat_main_t *vam = &vat_main;
1934 static ip_details_t empty_ip_details = { 0 };
1935 ip_details_t *ip = NULL;
1936 u32 sw_if_index = ~0;
1938 sw_if_index = ntohl (mp->sw_if_index);
1940 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1941 sw_if_index, empty_ip_details);
1943 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1950 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1952 vat_main_t *vam = &vat_main;
1954 if (VAT_JSON_ARRAY != vam->json_tree.type)
1956 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1957 vat_json_init_array (&vam->json_tree);
1959 vat_json_array_add_uint (&vam->json_tree,
1960 clib_net_to_host_u32 (mp->sw_if_index));
1963 static void vl_api_map_domain_details_t_handler_json
1964 (vl_api_map_domain_details_t * mp)
1966 vat_json_node_t *node = NULL;
1967 vat_main_t *vam = &vat_main;
1968 struct in6_addr ip6;
1971 if (VAT_JSON_ARRAY != vam->json_tree.type)
1973 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1974 vat_json_init_array (&vam->json_tree);
1977 node = vat_json_array_add (&vam->json_tree);
1978 vat_json_init_object (node);
1980 vat_json_object_add_uint (node, "domain_index",
1981 clib_net_to_host_u32 (mp->domain_index));
1982 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1983 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1984 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1985 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1986 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1987 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1988 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1989 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1990 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1991 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1992 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1993 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1994 vat_json_object_add_uint (node, "flags", mp->flags);
1995 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1996 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1999 static void vl_api_map_domain_details_t_handler
2000 (vl_api_map_domain_details_t * mp)
2002 vat_main_t *vam = &vat_main;
2004 if (mp->is_translation)
2007 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2008 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2009 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2010 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2011 clib_net_to_host_u32 (mp->domain_index));
2016 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2017 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2018 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2019 format_ip6_address, mp->ip6_src,
2020 clib_net_to_host_u32 (mp->domain_index));
2022 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2023 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2024 mp->is_translation ? "map-t" : "");
2027 static void vl_api_map_rule_details_t_handler_json
2028 (vl_api_map_rule_details_t * mp)
2030 struct in6_addr ip6;
2031 vat_json_node_t *node = NULL;
2032 vat_main_t *vam = &vat_main;
2034 if (VAT_JSON_ARRAY != vam->json_tree.type)
2036 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2037 vat_json_init_array (&vam->json_tree);
2040 node = vat_json_array_add (&vam->json_tree);
2041 vat_json_init_object (node);
2043 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2044 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2045 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2049 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2051 vat_main_t *vam = &vat_main;
2052 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2053 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2057 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2059 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2060 "router_addr %U host_mac %U",
2061 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2062 format_ip4_address, &mp->host_address,
2063 format_ip4_address, &mp->router_address,
2064 format_ethernet_address, mp->host_mac);
2067 static void vl_api_dhcp_compl_event_t_handler_json
2068 (vl_api_dhcp_compl_event_t * mp)
2070 /* JSON output not supported */
2074 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2077 vat_main_t *vam = &vat_main;
2078 static u64 default_counter = 0;
2080 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2082 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2083 sw_if_index, default_counter);
2084 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2088 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2089 interface_counter_t counter)
2091 vat_main_t *vam = &vat_main;
2092 static interface_counter_t default_counter = { 0, };
2094 vec_validate_init_empty (vam->combined_interface_counters,
2095 vnet_counter_type, NULL);
2096 vec_validate_init_empty (vam->combined_interface_counters
2097 [vnet_counter_type], sw_if_index, default_counter);
2098 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2101 static void vl_api_vnet_interface_counters_t_handler
2102 (vl_api_vnet_interface_counters_t * mp)
2107 static void vl_api_vnet_interface_counters_t_handler_json
2108 (vl_api_vnet_interface_counters_t * mp)
2110 interface_counter_t counter;
2115 u32 first_sw_if_index;
2118 count = ntohl (mp->count);
2119 first_sw_if_index = ntohl (mp->first_sw_if_index);
2121 if (!mp->is_combined)
2123 v_packets = (u64 *) & mp->data;
2124 for (i = 0; i < count; i++)
2127 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2128 set_simple_interface_counter (mp->vnet_counter_type,
2129 first_sw_if_index + i, packets);
2135 v = (vlib_counter_t *) & mp->data;
2136 for (i = 0; i < count; i++)
2139 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2141 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2142 set_combined_interface_counter (mp->vnet_counter_type,
2143 first_sw_if_index + i, counter);
2150 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2152 vat_main_t *vam = &vat_main;
2155 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2157 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2166 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2168 vat_main_t *vam = &vat_main;
2171 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2173 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2181 static void vl_api_vnet_ip4_fib_counters_t_handler
2182 (vl_api_vnet_ip4_fib_counters_t * mp)
2187 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2188 (vl_api_vnet_ip4_fib_counters_t * mp)
2190 vat_main_t *vam = &vat_main;
2191 vl_api_ip4_fib_counter_t *v;
2192 ip4_fib_counter_t *counter;
2199 vrf_id = ntohl (mp->vrf_id);
2200 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2201 if (~0 == vrf_index)
2203 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2204 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2205 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2206 vec_validate (vam->ip4_fib_counters, vrf_index);
2207 vam->ip4_fib_counters[vrf_index] = NULL;
2210 vec_free (vam->ip4_fib_counters[vrf_index]);
2211 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2212 count = ntohl (mp->count);
2213 for (i = 0; i < count; i++)
2215 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2216 counter = &vam->ip4_fib_counters[vrf_index][i];
2217 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2218 counter->address = ip4;
2219 counter->address_length = v->address_length;
2220 counter->packets = clib_net_to_host_u64 (v->packets);
2221 counter->bytes = clib_net_to_host_u64 (v->bytes);
2226 static void vl_api_vnet_ip4_nbr_counters_t_handler
2227 (vl_api_vnet_ip4_nbr_counters_t * mp)
2232 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2233 (vl_api_vnet_ip4_nbr_counters_t * mp)
2235 vat_main_t *vam = &vat_main;
2236 vl_api_ip4_nbr_counter_t *v;
2237 ip4_nbr_counter_t *counter;
2242 sw_if_index = ntohl (mp->sw_if_index);
2243 count = ntohl (mp->count);
2244 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2247 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2249 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2250 for (i = 0; i < count; i++)
2252 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2253 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2254 counter->address.s_addr = v->address;
2255 counter->packets = clib_net_to_host_u64 (v->packets);
2256 counter->bytes = clib_net_to_host_u64 (v->bytes);
2257 counter->linkt = v->link_type;
2262 static void vl_api_vnet_ip6_fib_counters_t_handler
2263 (vl_api_vnet_ip6_fib_counters_t * mp)
2268 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2269 (vl_api_vnet_ip6_fib_counters_t * mp)
2271 vat_main_t *vam = &vat_main;
2272 vl_api_ip6_fib_counter_t *v;
2273 ip6_fib_counter_t *counter;
2274 struct in6_addr ip6;
2280 vrf_id = ntohl (mp->vrf_id);
2281 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2282 if (~0 == vrf_index)
2284 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2285 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2286 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2287 vec_validate (vam->ip6_fib_counters, vrf_index);
2288 vam->ip6_fib_counters[vrf_index] = NULL;
2291 vec_free (vam->ip6_fib_counters[vrf_index]);
2292 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2293 count = ntohl (mp->count);
2294 for (i = 0; i < count; i++)
2296 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2297 counter = &vam->ip6_fib_counters[vrf_index][i];
2298 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2299 counter->address = ip6;
2300 counter->address_length = v->address_length;
2301 counter->packets = clib_net_to_host_u64 (v->packets);
2302 counter->bytes = clib_net_to_host_u64 (v->bytes);
2307 static void vl_api_vnet_ip6_nbr_counters_t_handler
2308 (vl_api_vnet_ip6_nbr_counters_t * mp)
2313 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2314 (vl_api_vnet_ip6_nbr_counters_t * mp)
2316 vat_main_t *vam = &vat_main;
2317 vl_api_ip6_nbr_counter_t *v;
2318 ip6_nbr_counter_t *counter;
2319 struct in6_addr ip6;
2324 sw_if_index = ntohl (mp->sw_if_index);
2325 count = ntohl (mp->count);
2326 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2329 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2331 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2332 for (i = 0; i < count; i++)
2334 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2335 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2336 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2337 counter->address = ip6;
2338 counter->packets = clib_net_to_host_u64 (v->packets);
2339 counter->bytes = clib_net_to_host_u64 (v->bytes);
2344 static void vl_api_get_first_msg_id_reply_t_handler
2345 (vl_api_get_first_msg_id_reply_t * mp)
2347 vat_main_t *vam = &vat_main;
2348 i32 retval = ntohl (mp->retval);
2350 if (vam->async_mode)
2352 vam->async_errors += (retval < 0);
2356 vam->retval = retval;
2357 vam->result_ready = 1;
2361 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2365 static void vl_api_get_first_msg_id_reply_t_handler_json
2366 (vl_api_get_first_msg_id_reply_t * mp)
2368 vat_main_t *vam = &vat_main;
2369 vat_json_node_t node;
2371 vat_json_init_object (&node);
2372 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2373 vat_json_object_add_uint (&node, "first_msg_id",
2374 (uint) ntohs (mp->first_msg_id));
2376 vat_json_print (vam->ofp, &node);
2377 vat_json_free (&node);
2379 vam->retval = ntohl (mp->retval);
2380 vam->result_ready = 1;
2383 static void vl_api_get_node_graph_reply_t_handler
2384 (vl_api_get_node_graph_reply_t * mp)
2386 vat_main_t *vam = &vat_main;
2387 api_main_t *am = &api_main;
2388 i32 retval = ntohl (mp->retval);
2389 u8 *pvt_copy, *reply;
2394 if (vam->async_mode)
2396 vam->async_errors += (retval < 0);
2400 vam->retval = retval;
2401 vam->result_ready = 1;
2404 /* "Should never happen..." */
2408 reply = (u8 *) (mp->reply_in_shmem);
2409 pvt_copy = vec_dup (reply);
2411 /* Toss the shared-memory original... */
2412 pthread_mutex_lock (&am->vlib_rp->mutex);
2413 oldheap = svm_push_data_heap (am->vlib_rp);
2417 svm_pop_heap (oldheap);
2418 pthread_mutex_unlock (&am->vlib_rp->mutex);
2420 if (vam->graph_nodes)
2422 hash_free (vam->graph_node_index_by_name);
2424 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2426 node = vam->graph_nodes[i];
2427 vec_free (node->name);
2428 vec_free (node->next_nodes);
2431 vec_free (vam->graph_nodes);
2434 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2435 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2436 vec_free (pvt_copy);
2438 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2440 node = vam->graph_nodes[i];
2441 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2445 static void vl_api_get_node_graph_reply_t_handler_json
2446 (vl_api_get_node_graph_reply_t * mp)
2448 vat_main_t *vam = &vat_main;
2449 api_main_t *am = &api_main;
2451 vat_json_node_t node;
2454 /* $$$$ make this real? */
2455 vat_json_init_object (&node);
2456 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2457 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2459 reply = (u8 *) (mp->reply_in_shmem);
2461 /* Toss the shared-memory original... */
2462 pthread_mutex_lock (&am->vlib_rp->mutex);
2463 oldheap = svm_push_data_heap (am->vlib_rp);
2467 svm_pop_heap (oldheap);
2468 pthread_mutex_unlock (&am->vlib_rp->mutex);
2470 vat_json_print (vam->ofp, &node);
2471 vat_json_free (&node);
2473 vam->retval = ntohl (mp->retval);
2474 vam->result_ready = 1;
2478 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2480 vat_main_t *vam = &vat_main;
2485 s = format (s, "%=16d%=16d%=16d",
2486 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2490 s = format (s, "%=16U%=16d%=16d",
2491 mp->is_ipv6 ? format_ip6_address :
2493 mp->ip_address, mp->priority, mp->weight);
2496 print (vam->ofp, "%v", s);
2501 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2503 vat_main_t *vam = &vat_main;
2504 vat_json_node_t *node = NULL;
2505 struct in6_addr ip6;
2508 if (VAT_JSON_ARRAY != vam->json_tree.type)
2510 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2511 vat_json_init_array (&vam->json_tree);
2513 node = vat_json_array_add (&vam->json_tree);
2514 vat_json_init_object (node);
2516 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2517 vat_json_object_add_uint (node, "priority", mp->priority);
2518 vat_json_object_add_uint (node, "weight", mp->weight);
2521 vat_json_object_add_uint (node, "sw_if_index",
2522 clib_net_to_host_u32 (mp->sw_if_index));
2527 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2528 vat_json_object_add_ip6 (node, "address", ip6);
2532 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2533 vat_json_object_add_ip4 (node, "address", ip4);
2539 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2542 vat_main_t *vam = &vat_main;
2545 ls_name = format (0, "%s", mp->ls_name);
2547 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2553 vl_api_one_locator_set_details_t_handler_json
2554 (vl_api_one_locator_set_details_t * mp)
2556 vat_main_t *vam = &vat_main;
2557 vat_json_node_t *node = 0;
2560 ls_name = format (0, "%s", mp->ls_name);
2561 vec_add1 (ls_name, 0);
2563 if (VAT_JSON_ARRAY != vam->json_tree.type)
2565 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2566 vat_json_init_array (&vam->json_tree);
2568 node = vat_json_array_add (&vam->json_tree);
2570 vat_json_init_object (node);
2571 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2572 vat_json_object_add_uint (node, "ls_index",
2573 clib_net_to_host_u32 (mp->ls_index));
2578 format_lisp_flat_eid (u8 * s, va_list * args)
2580 u32 type = va_arg (*args, u32);
2581 u8 *eid = va_arg (*args, u8 *);
2582 u32 eid_len = va_arg (*args, u32);
2587 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2589 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2591 return format (s, "%U", format_ethernet_address, eid);
2597 format_lisp_eid_vat (u8 * s, va_list * args)
2599 u32 type = va_arg (*args, u32);
2600 u8 *eid = va_arg (*args, u8 *);
2601 u32 eid_len = va_arg (*args, u32);
2602 u8 *seid = va_arg (*args, u8 *);
2603 u32 seid_len = va_arg (*args, u32);
2604 u32 is_src_dst = va_arg (*args, u32);
2607 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2609 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2615 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2617 vat_main_t *vam = &vat_main;
2618 u8 *s = 0, *eid = 0;
2620 if (~0 == mp->locator_set_index)
2621 s = format (0, "action: %d", mp->action);
2623 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2625 eid = format (0, "%U", format_lisp_eid_vat,
2629 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2632 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2633 clib_net_to_host_u32 (mp->vni),
2635 mp->is_local ? "local" : "remote",
2636 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2637 clib_net_to_host_u16 (mp->key_id), mp->key);
2644 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2647 vat_main_t *vam = &vat_main;
2648 vat_json_node_t *node = 0;
2651 if (VAT_JSON_ARRAY != vam->json_tree.type)
2653 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2654 vat_json_init_array (&vam->json_tree);
2656 node = vat_json_array_add (&vam->json_tree);
2658 vat_json_init_object (node);
2659 if (~0 == mp->locator_set_index)
2660 vat_json_object_add_uint (node, "action", mp->action);
2662 vat_json_object_add_uint (node, "locator_set_index",
2663 clib_net_to_host_u32 (mp->locator_set_index));
2665 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2666 eid = format (0, "%U", format_lisp_eid_vat,
2670 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2672 vat_json_object_add_string_copy (node, "eid", eid);
2673 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2674 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2675 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2679 vat_json_object_add_uint (node, "key_id",
2680 clib_net_to_host_u16 (mp->key_id));
2681 vat_json_object_add_string_copy (node, "key", mp->key);
2687 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
2689 vat_main_t *vam = &vat_main;
2690 u8 *seid = 0, *deid = 0;
2691 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2693 deid = format (0, "%U", format_lisp_eid_vat,
2694 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
2696 seid = format (0, "%U", format_lisp_eid_vat,
2697 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
2703 format_ip_address_fcn = format_ip4_address;
2705 format_ip_address_fcn = format_ip6_address;
2708 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
2709 clib_net_to_host_u32 (mp->vni),
2711 format_ip_address_fcn, mp->lloc,
2712 format_ip_address_fcn, mp->rloc,
2713 clib_net_to_host_u32 (mp->pkt_count),
2714 clib_net_to_host_u32 (mp->bytes));
2721 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
2723 struct in6_addr ip6;
2725 vat_main_t *vam = &vat_main;
2726 vat_json_node_t *node = 0;
2727 u8 *deid = 0, *seid = 0;
2729 if (VAT_JSON_ARRAY != vam->json_tree.type)
2731 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2732 vat_json_init_array (&vam->json_tree);
2734 node = vat_json_array_add (&vam->json_tree);
2736 vat_json_init_object (node);
2737 deid = format (0, "%U", format_lisp_eid_vat,
2738 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
2740 seid = format (0, "%U", format_lisp_eid_vat,
2741 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
2746 vat_json_object_add_string_copy (node, "seid", seid);
2747 vat_json_object_add_string_copy (node, "deid", deid);
2748 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2752 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
2753 vat_json_object_add_ip4 (node, "lloc", ip4);
2754 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
2755 vat_json_object_add_ip4 (node, "rloc", ip4);
2759 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
2760 vat_json_object_add_ip6 (node, "lloc", ip6);
2761 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
2762 vat_json_object_add_ip6 (node, "rloc", ip6);
2764 vat_json_object_add_uint (node, "pkt_count",
2765 clib_net_to_host_u32 (mp->pkt_count));
2766 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
2773 vl_api_one_eid_table_map_details_t_handler
2774 (vl_api_one_eid_table_map_details_t * mp)
2776 vat_main_t *vam = &vat_main;
2778 u8 *line = format (0, "%=10d%=10d",
2779 clib_net_to_host_u32 (mp->vni),
2780 clib_net_to_host_u32 (mp->dp_table));
2781 print (vam->ofp, "%v", line);
2786 vl_api_one_eid_table_map_details_t_handler_json
2787 (vl_api_one_eid_table_map_details_t * mp)
2789 vat_main_t *vam = &vat_main;
2790 vat_json_node_t *node = NULL;
2792 if (VAT_JSON_ARRAY != vam->json_tree.type)
2794 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2795 vat_json_init_array (&vam->json_tree);
2797 node = vat_json_array_add (&vam->json_tree);
2798 vat_json_init_object (node);
2799 vat_json_object_add_uint (node, "dp_table",
2800 clib_net_to_host_u32 (mp->dp_table));
2801 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2805 vl_api_one_eid_table_vni_details_t_handler
2806 (vl_api_one_eid_table_vni_details_t * mp)
2808 vat_main_t *vam = &vat_main;
2810 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2811 print (vam->ofp, "%v", line);
2816 vl_api_one_eid_table_vni_details_t_handler_json
2817 (vl_api_one_eid_table_vni_details_t * mp)
2819 vat_main_t *vam = &vat_main;
2820 vat_json_node_t *node = NULL;
2822 if (VAT_JSON_ARRAY != vam->json_tree.type)
2824 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2825 vat_json_init_array (&vam->json_tree);
2827 node = vat_json_array_add (&vam->json_tree);
2828 vat_json_init_object (node);
2829 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2833 vl_api_show_one_map_register_state_reply_t_handler
2834 (vl_api_show_one_map_register_state_reply_t * mp)
2836 vat_main_t *vam = &vat_main;
2837 int retval = clib_net_to_host_u32 (mp->retval);
2839 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2841 vam->retval = retval;
2842 vam->result_ready = 1;
2846 vl_api_show_one_map_register_state_reply_t_handler_json
2847 (vl_api_show_one_map_register_state_reply_t * mp)
2849 vat_main_t *vam = &vat_main;
2850 vat_json_node_t _node, *node = &_node;
2851 int retval = clib_net_to_host_u32 (mp->retval);
2853 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2855 vat_json_init_object (node);
2856 vat_json_object_add_string_copy (node, "state", s);
2858 vat_json_print (vam->ofp, node);
2859 vat_json_free (node);
2861 vam->retval = retval;
2862 vam->result_ready = 1;
2867 vl_api_show_one_rloc_probe_state_reply_t_handler
2868 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2870 vat_main_t *vam = &vat_main;
2871 int retval = clib_net_to_host_u32 (mp->retval);
2876 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2878 vam->retval = retval;
2879 vam->result_ready = 1;
2883 vl_api_show_one_rloc_probe_state_reply_t_handler_json
2884 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2886 vat_main_t *vam = &vat_main;
2887 vat_json_node_t _node, *node = &_node;
2888 int retval = clib_net_to_host_u32 (mp->retval);
2890 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2891 vat_json_init_object (node);
2892 vat_json_object_add_string_copy (node, "state", s);
2894 vat_json_print (vam->ofp, node);
2895 vat_json_free (node);
2897 vam->retval = retval;
2898 vam->result_ready = 1;
2903 vl_api_show_one_stats_enable_disable_reply_t_handler
2904 (vl_api_show_one_stats_enable_disable_reply_t * mp)
2906 vat_main_t *vam = &vat_main;
2907 int retval = clib_net_to_host_u32 (mp->retval);
2912 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
2914 vam->retval = retval;
2915 vam->result_ready = 1;
2919 vl_api_show_one_stats_enable_disable_reply_t_handler_json
2920 (vl_api_show_one_stats_enable_disable_reply_t * mp)
2922 vat_main_t *vam = &vat_main;
2923 vat_json_node_t _node, *node = &_node;
2924 int retval = clib_net_to_host_u32 (mp->retval);
2926 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
2927 vat_json_init_object (node);
2928 vat_json_object_add_string_copy (node, "state", s);
2930 vat_json_print (vam->ofp, node);
2931 vat_json_free (node);
2933 vam->retval = retval;
2934 vam->result_ready = 1;
2939 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
2941 e->dp_table = clib_net_to_host_u32 (e->dp_table);
2942 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
2946 gpe_fwd_entries_get_reply_t_net_to_host
2947 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2951 mp->count = clib_net_to_host_u32 (mp->count);
2952 for (i = 0; i < mp->count; i++)
2954 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
2959 format_gpe_encap_mode (u8 * s, va_list * args)
2961 u32 mode = va_arg (*args, u32);
2966 return format (s, "lisp");
2968 return format (s, "vxlan");
2974 vl_api_gpe_get_encap_mode_reply_t_handler
2975 (vl_api_gpe_get_encap_mode_reply_t * mp)
2977 vat_main_t *vam = &vat_main;
2979 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
2980 vam->retval = ntohl (mp->retval);
2981 vam->result_ready = 1;
2985 vl_api_gpe_get_encap_mode_reply_t_handler_json
2986 (vl_api_gpe_get_encap_mode_reply_t * mp)
2988 vat_main_t *vam = &vat_main;
2989 vat_json_node_t node;
2991 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
2992 vec_add1 (encap_mode, 0);
2994 vat_json_init_object (&node);
2995 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
2997 vec_free (encap_mode);
2998 vat_json_print (vam->ofp, &node);
2999 vat_json_free (&node);
3001 vam->retval = ntohl (mp->retval);
3002 vam->result_ready = 1;
3006 vl_api_gpe_fwd_entry_path_details_t_handler
3007 (vl_api_gpe_fwd_entry_path_details_t * mp)
3009 vat_main_t *vam = &vat_main;
3010 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3012 if (mp->lcl_loc.is_ip4)
3013 format_ip_address_fcn = format_ip4_address;
3015 format_ip_address_fcn = format_ip6_address;
3017 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3018 format_ip_address_fcn, &mp->lcl_loc,
3019 format_ip_address_fcn, &mp->rmt_loc);
3023 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3025 struct in6_addr ip6;
3030 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3031 vat_json_object_add_ip4 (n, "address", ip4);
3035 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3036 vat_json_object_add_ip6 (n, "address", ip6);
3038 vat_json_object_add_uint (n, "weight", loc->weight);
3042 vl_api_gpe_fwd_entry_path_details_t_handler_json
3043 (vl_api_gpe_fwd_entry_path_details_t * mp)
3045 vat_main_t *vam = &vat_main;
3046 vat_json_node_t *node = NULL;
3047 vat_json_node_t *loc_node;
3049 if (VAT_JSON_ARRAY != vam->json_tree.type)
3051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3052 vat_json_init_array (&vam->json_tree);
3054 node = vat_json_array_add (&vam->json_tree);
3055 vat_json_init_object (node);
3057 loc_node = vat_json_object_add (node, "local_locator");
3058 vat_json_init_object (loc_node);
3059 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3061 loc_node = vat_json_object_add (node, "remote_locator");
3062 vat_json_init_object (loc_node);
3063 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3067 vl_api_gpe_fwd_entries_get_reply_t_handler
3068 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3070 vat_main_t *vam = &vat_main;
3072 int retval = clib_net_to_host_u32 (mp->retval);
3073 vl_api_gpe_fwd_entry_t *e;
3078 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3080 for (i = 0; i < mp->count; i++)
3082 e = &mp->entries[i];
3083 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3084 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3085 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3089 vam->retval = retval;
3090 vam->result_ready = 1;
3094 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3095 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3098 vat_main_t *vam = &vat_main;
3099 vat_json_node_t *e = 0, root;
3101 int retval = clib_net_to_host_u32 (mp->retval);
3102 vl_api_gpe_fwd_entry_t *fwd;
3107 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3108 vat_json_init_array (&root);
3110 for (i = 0; i < mp->count; i++)
3112 e = vat_json_array_add (&root);
3113 fwd = &mp->entries[i];
3115 vat_json_init_object (e);
3116 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3117 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3119 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3120 fwd->leid_prefix_len);
3122 vat_json_object_add_string_copy (e, "leid", s);
3125 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3126 fwd->reid_prefix_len);
3128 vat_json_object_add_string_copy (e, "reid", s);
3132 vat_json_print (vam->ofp, &root);
3133 vat_json_free (&root);
3136 vam->retval = retval;
3137 vam->result_ready = 1;
3141 vl_api_one_adjacencies_get_reply_t_handler
3142 (vl_api_one_adjacencies_get_reply_t * mp)
3144 vat_main_t *vam = &vat_main;
3146 int retval = clib_net_to_host_u32 (mp->retval);
3147 vl_api_one_adjacency_t *a;
3152 n = clib_net_to_host_u32 (mp->count);
3154 for (i = 0; i < n; i++)
3156 a = &mp->adjacencies[i];
3157 print (vam->ofp, "%U %40U",
3158 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3159 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3163 vam->retval = retval;
3164 vam->result_ready = 1;
3168 vl_api_one_adjacencies_get_reply_t_handler_json
3169 (vl_api_one_adjacencies_get_reply_t * mp)
3172 vat_main_t *vam = &vat_main;
3173 vat_json_node_t *e = 0, root;
3175 int retval = clib_net_to_host_u32 (mp->retval);
3176 vl_api_one_adjacency_t *a;
3181 n = clib_net_to_host_u32 (mp->count);
3182 vat_json_init_array (&root);
3184 for (i = 0; i < n; i++)
3186 e = vat_json_array_add (&root);
3187 a = &mp->adjacencies[i];
3189 vat_json_init_object (e);
3190 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3191 a->leid_prefix_len);
3193 vat_json_object_add_string_copy (e, "leid", s);
3196 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3197 a->reid_prefix_len);
3199 vat_json_object_add_string_copy (e, "reid", s);
3203 vat_json_print (vam->ofp, &root);
3204 vat_json_free (&root);
3207 vam->retval = retval;
3208 vam->result_ready = 1;
3212 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3214 vat_main_t *vam = &vat_main;
3216 print (vam->ofp, "%=20U",
3217 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3222 vl_api_one_map_server_details_t_handler_json
3223 (vl_api_one_map_server_details_t * mp)
3225 vat_main_t *vam = &vat_main;
3226 vat_json_node_t *node = NULL;
3227 struct in6_addr ip6;
3230 if (VAT_JSON_ARRAY != vam->json_tree.type)
3232 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3233 vat_json_init_array (&vam->json_tree);
3235 node = vat_json_array_add (&vam->json_tree);
3237 vat_json_init_object (node);
3240 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3241 vat_json_object_add_ip6 (node, "map-server", ip6);
3245 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3246 vat_json_object_add_ip4 (node, "map-server", ip4);
3251 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3254 vat_main_t *vam = &vat_main;
3256 print (vam->ofp, "%=20U",
3257 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3262 vl_api_one_map_resolver_details_t_handler_json
3263 (vl_api_one_map_resolver_details_t * mp)
3265 vat_main_t *vam = &vat_main;
3266 vat_json_node_t *node = NULL;
3267 struct in6_addr ip6;
3270 if (VAT_JSON_ARRAY != vam->json_tree.type)
3272 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3273 vat_json_init_array (&vam->json_tree);
3275 node = vat_json_array_add (&vam->json_tree);
3277 vat_json_init_object (node);
3280 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3281 vat_json_object_add_ip6 (node, "map resolver", ip6);
3285 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3286 vat_json_object_add_ip4 (node, "map resolver", ip4);
3291 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
3293 vat_main_t *vam = &vat_main;
3294 i32 retval = ntohl (mp->retval);
3298 print (vam->ofp, "feature: %s\ngpe: %s",
3299 mp->feature_status ? "enabled" : "disabled",
3300 mp->gpe_status ? "enabled" : "disabled");
3303 vam->retval = retval;
3304 vam->result_ready = 1;
3308 vl_api_show_one_status_reply_t_handler_json
3309 (vl_api_show_one_status_reply_t * mp)
3311 vat_main_t *vam = &vat_main;
3312 vat_json_node_t node;
3313 u8 *gpe_status = NULL;
3314 u8 *feature_status = NULL;
3316 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3317 feature_status = format (0, "%s",
3318 mp->feature_status ? "enabled" : "disabled");
3319 vec_add1 (gpe_status, 0);
3320 vec_add1 (feature_status, 0);
3322 vat_json_init_object (&node);
3323 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3324 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3326 vec_free (gpe_status);
3327 vec_free (feature_status);
3329 vat_json_print (vam->ofp, &node);
3330 vat_json_free (&node);
3332 vam->retval = ntohl (mp->retval);
3333 vam->result_ready = 1;
3337 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
3338 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3340 vat_main_t *vam = &vat_main;
3341 i32 retval = ntohl (mp->retval);
3345 print (vam->ofp, "%=20s", mp->locator_set_name);
3348 vam->retval = retval;
3349 vam->result_ready = 1;
3353 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
3354 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3356 vat_main_t *vam = &vat_main;
3357 vat_json_node_t *node = NULL;
3359 if (VAT_JSON_ARRAY != vam->json_tree.type)
3361 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3362 vat_json_init_array (&vam->json_tree);
3364 node = vat_json_array_add (&vam->json_tree);
3366 vat_json_init_object (node);
3367 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3369 vat_json_print (vam->ofp, node);
3370 vat_json_free (node);
3372 vam->retval = ntohl (mp->retval);
3373 vam->result_ready = 1;
3377 format_lisp_map_request_mode (u8 * s, va_list * args)
3379 u32 mode = va_arg (*args, u32);
3384 return format (0, "dst-only");
3386 return format (0, "src-dst");
3392 vl_api_show_one_map_request_mode_reply_t_handler
3393 (vl_api_show_one_map_request_mode_reply_t * mp)
3395 vat_main_t *vam = &vat_main;
3396 i32 retval = ntohl (mp->retval);
3400 u32 mode = mp->mode;
3401 print (vam->ofp, "map_request_mode: %U",
3402 format_lisp_map_request_mode, mode);
3405 vam->retval = retval;
3406 vam->result_ready = 1;
3410 vl_api_show_one_map_request_mode_reply_t_handler_json
3411 (vl_api_show_one_map_request_mode_reply_t * mp)
3413 vat_main_t *vam = &vat_main;
3414 vat_json_node_t node;
3419 s = format (0, "%U", format_lisp_map_request_mode, mode);
3422 vat_json_init_object (&node);
3423 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3424 vat_json_print (vam->ofp, &node);
3425 vat_json_free (&node);
3428 vam->retval = ntohl (mp->retval);
3429 vam->result_ready = 1;
3433 vl_api_show_one_use_petr_reply_t_handler
3434 (vl_api_show_one_use_petr_reply_t * mp)
3436 vat_main_t *vam = &vat_main;
3437 i32 retval = ntohl (mp->retval);
3441 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
3444 print (vam->ofp, "Proxy-ETR address; %U",
3445 mp->is_ip4 ? format_ip4_address : format_ip6_address,
3450 vam->retval = retval;
3451 vam->result_ready = 1;
3455 vl_api_show_one_use_petr_reply_t_handler_json
3456 (vl_api_show_one_use_petr_reply_t * mp)
3458 vat_main_t *vam = &vat_main;
3459 vat_json_node_t node;
3462 struct in6_addr ip6;
3464 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3465 vec_add1 (status, 0);
3467 vat_json_init_object (&node);
3468 vat_json_object_add_string_copy (&node, "status", status);
3473 clib_memcpy (&ip6, mp->address, sizeof (ip6));
3474 vat_json_object_add_ip6 (&node, "address", ip6);
3478 clib_memcpy (&ip4, mp->address, sizeof (ip4));
3479 vat_json_object_add_ip4 (&node, "address", ip4);
3485 vat_json_print (vam->ofp, &node);
3486 vat_json_free (&node);
3488 vam->retval = ntohl (mp->retval);
3489 vam->result_ready = 1;
3493 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
3495 vat_main_t *vam = &vat_main;
3496 i32 retval = ntohl (mp->retval);
3500 print (vam->ofp, "%-20s%-16s",
3501 mp->status ? "enabled" : "disabled",
3502 mp->status ? (char *) mp->locator_set_name : "");
3505 vam->retval = retval;
3506 vam->result_ready = 1;
3510 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
3512 vat_main_t *vam = &vat_main;
3513 vat_json_node_t node;
3516 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3517 vec_add1 (status, 0);
3519 vat_json_init_object (&node);
3520 vat_json_object_add_string_copy (&node, "status", status);
3523 vat_json_object_add_string_copy (&node, "locator_set",
3524 mp->locator_set_name);
3529 vat_json_print (vam->ofp, &node);
3530 vat_json_free (&node);
3532 vam->retval = ntohl (mp->retval);
3533 vam->result_ready = 1;
3537 format_policer_type (u8 * s, va_list * va)
3539 u32 i = va_arg (*va, u32);
3541 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3542 s = format (s, "1r2c");
3543 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3544 s = format (s, "1r3c");
3545 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
3546 s = format (s, "2r3c-2698");
3547 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
3548 s = format (s, "2r3c-4115");
3549 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
3550 s = format (s, "2r3c-mef5cf1");
3552 s = format (s, "ILLEGAL");
3557 format_policer_rate_type (u8 * s, va_list * va)
3559 u32 i = va_arg (*va, u32);
3561 if (i == SSE2_QOS_RATE_KBPS)
3562 s = format (s, "kbps");
3563 else if (i == SSE2_QOS_RATE_PPS)
3564 s = format (s, "pps");
3566 s = format (s, "ILLEGAL");
3571 format_policer_round_type (u8 * s, va_list * va)
3573 u32 i = va_arg (*va, u32);
3575 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3576 s = format (s, "closest");
3577 else if (i == SSE2_QOS_ROUND_TO_UP)
3578 s = format (s, "up");
3579 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3580 s = format (s, "down");
3582 s = format (s, "ILLEGAL");
3587 format_policer_action_type (u8 * s, va_list * va)
3589 u32 i = va_arg (*va, u32);
3591 if (i == SSE2_QOS_ACTION_DROP)
3592 s = format (s, "drop");
3593 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3594 s = format (s, "transmit");
3595 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3596 s = format (s, "mark-and-transmit");
3598 s = format (s, "ILLEGAL");
3603 format_dscp (u8 * s, va_list * va)
3605 u32 i = va_arg (*va, u32);
3610 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3614 return format (s, "ILLEGAL");
3616 s = format (s, "%s", t);
3621 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3623 vat_main_t *vam = &vat_main;
3624 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3626 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3627 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3629 conform_dscp_str = format (0, "");
3631 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3632 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3634 exceed_dscp_str = format (0, "");
3636 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3637 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3639 violate_dscp_str = format (0, "");
3641 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3642 "rate type %U, round type %U, %s rate, %s color-aware, "
3643 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3644 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3645 "conform action %U%s, exceed action %U%s, violate action %U%s",
3647 format_policer_type, mp->type,
3650 clib_net_to_host_u64 (mp->cb),
3651 clib_net_to_host_u64 (mp->eb),
3652 format_policer_rate_type, mp->rate_type,
3653 format_policer_round_type, mp->round_type,
3654 mp->single_rate ? "single" : "dual",
3655 mp->color_aware ? "is" : "not",
3656 ntohl (mp->cir_tokens_per_period),
3657 ntohl (mp->pir_tokens_per_period),
3659 ntohl (mp->current_limit),
3660 ntohl (mp->current_bucket),
3661 ntohl (mp->extended_limit),
3662 ntohl (mp->extended_bucket),
3663 clib_net_to_host_u64 (mp->last_update_time),
3664 format_policer_action_type, mp->conform_action_type,
3666 format_policer_action_type, mp->exceed_action_type,
3668 format_policer_action_type, mp->violate_action_type,
3671 vec_free (conform_dscp_str);
3672 vec_free (exceed_dscp_str);
3673 vec_free (violate_dscp_str);
3676 static void vl_api_policer_details_t_handler_json
3677 (vl_api_policer_details_t * mp)
3679 vat_main_t *vam = &vat_main;
3680 vat_json_node_t *node;
3681 u8 *rate_type_str, *round_type_str, *type_str;
3682 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3684 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3686 format (0, "%U", format_policer_round_type, mp->round_type);
3687 type_str = format (0, "%U", format_policer_type, mp->type);
3688 conform_action_str = format (0, "%U", format_policer_action_type,
3689 mp->conform_action_type);
3690 exceed_action_str = format (0, "%U", format_policer_action_type,
3691 mp->exceed_action_type);
3692 violate_action_str = format (0, "%U", format_policer_action_type,
3693 mp->violate_action_type);
3695 if (VAT_JSON_ARRAY != vam->json_tree.type)
3697 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3698 vat_json_init_array (&vam->json_tree);
3700 node = vat_json_array_add (&vam->json_tree);
3702 vat_json_init_object (node);
3703 vat_json_object_add_string_copy (node, "name", mp->name);
3704 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3705 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3706 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
3707 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
3708 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3709 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3710 vat_json_object_add_string_copy (node, "type", type_str);
3711 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3712 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3713 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3714 vat_json_object_add_uint (node, "cir_tokens_per_period",
3715 ntohl (mp->cir_tokens_per_period));
3716 vat_json_object_add_uint (node, "eir_tokens_per_period",
3717 ntohl (mp->pir_tokens_per_period));
3718 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3719 vat_json_object_add_uint (node, "current_bucket",
3720 ntohl (mp->current_bucket));
3721 vat_json_object_add_uint (node, "extended_limit",
3722 ntohl (mp->extended_limit));
3723 vat_json_object_add_uint (node, "extended_bucket",
3724 ntohl (mp->extended_bucket));
3725 vat_json_object_add_uint (node, "last_update_time",
3726 ntohl (mp->last_update_time));
3727 vat_json_object_add_string_copy (node, "conform_action",
3728 conform_action_str);
3729 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3731 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3732 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3733 vec_free (dscp_str);
3735 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3736 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3738 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3739 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3740 vec_free (dscp_str);
3742 vat_json_object_add_string_copy (node, "violate_action",
3743 violate_action_str);
3744 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3746 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3747 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3748 vec_free (dscp_str);
3751 vec_free (rate_type_str);
3752 vec_free (round_type_str);
3753 vec_free (type_str);
3754 vec_free (conform_action_str);
3755 vec_free (exceed_action_str);
3756 vec_free (violate_action_str);
3760 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3763 vat_main_t *vam = &vat_main;
3764 int i, count = ntohl (mp->count);
3767 print (vam->ofp, "classify table ids (%d) : ", count);
3768 for (i = 0; i < count; i++)
3770 print (vam->ofp, "%d", ntohl (mp->ids[i]));
3771 print (vam->ofp, (i < count - 1) ? "," : "");
3773 vam->retval = ntohl (mp->retval);
3774 vam->result_ready = 1;
3778 vl_api_classify_table_ids_reply_t_handler_json
3779 (vl_api_classify_table_ids_reply_t * mp)
3781 vat_main_t *vam = &vat_main;
3782 int i, count = ntohl (mp->count);
3786 vat_json_node_t node;
3788 vat_json_init_object (&node);
3789 for (i = 0; i < count; i++)
3791 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3793 vat_json_print (vam->ofp, &node);
3794 vat_json_free (&node);
3796 vam->retval = ntohl (mp->retval);
3797 vam->result_ready = 1;
3801 vl_api_classify_table_by_interface_reply_t_handler
3802 (vl_api_classify_table_by_interface_reply_t * mp)
3804 vat_main_t *vam = &vat_main;
3807 table_id = ntohl (mp->l2_table_id);
3809 print (vam->ofp, "l2 table id : %d", table_id);
3811 print (vam->ofp, "l2 table id : No input ACL tables configured");
3812 table_id = ntohl (mp->ip4_table_id);
3814 print (vam->ofp, "ip4 table id : %d", table_id);
3816 print (vam->ofp, "ip4 table id : No input ACL tables configured");
3817 table_id = ntohl (mp->ip6_table_id);
3819 print (vam->ofp, "ip6 table id : %d", table_id);
3821 print (vam->ofp, "ip6 table id : No input ACL tables configured");
3822 vam->retval = ntohl (mp->retval);
3823 vam->result_ready = 1;
3827 vl_api_classify_table_by_interface_reply_t_handler_json
3828 (vl_api_classify_table_by_interface_reply_t * mp)
3830 vat_main_t *vam = &vat_main;
3831 vat_json_node_t node;
3833 vat_json_init_object (&node);
3835 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3836 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3837 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3839 vat_json_print (vam->ofp, &node);
3840 vat_json_free (&node);
3842 vam->retval = ntohl (mp->retval);
3843 vam->result_ready = 1;
3846 static void vl_api_policer_add_del_reply_t_handler
3847 (vl_api_policer_add_del_reply_t * mp)
3849 vat_main_t *vam = &vat_main;
3850 i32 retval = ntohl (mp->retval);
3851 if (vam->async_mode)
3853 vam->async_errors += (retval < 0);
3857 vam->retval = retval;
3858 vam->result_ready = 1;
3859 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3861 * Note: this is just barely thread-safe, depends on
3862 * the main thread spinning waiting for an answer...
3864 errmsg ("policer index %d", ntohl (mp->policer_index));
3868 static void vl_api_policer_add_del_reply_t_handler_json
3869 (vl_api_policer_add_del_reply_t * mp)
3871 vat_main_t *vam = &vat_main;
3872 vat_json_node_t node;
3874 vat_json_init_object (&node);
3875 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3876 vat_json_object_add_uint (&node, "policer_index",
3877 ntohl (mp->policer_index));
3879 vat_json_print (vam->ofp, &node);
3880 vat_json_free (&node);
3882 vam->retval = ntohl (mp->retval);
3883 vam->result_ready = 1;
3886 /* Format hex dump. */
3888 format_hex_bytes (u8 * s, va_list * va)
3890 u8 *bytes = va_arg (*va, u8 *);
3891 int n_bytes = va_arg (*va, int);
3894 /* Print short or long form depending on byte count. */
3895 uword short_form = n_bytes <= 32;
3896 uword indent = format_get_indent (s);
3901 for (i = 0; i < n_bytes; i++)
3903 if (!short_form && (i % 32) == 0)
3904 s = format (s, "%08x: ", i);
3905 s = format (s, "%02x", bytes[i]);
3906 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3907 s = format (s, "\n%U", format_white_space, indent);
3914 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3917 vat_main_t *vam = &vat_main;
3918 i32 retval = ntohl (mp->retval);
3921 print (vam->ofp, "classify table info :");
3922 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3923 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3924 ntohl (mp->miss_next_index));
3925 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3926 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3927 ntohl (mp->match_n_vectors));
3928 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3929 ntohl (mp->mask_length));
3931 vam->retval = retval;
3932 vam->result_ready = 1;
3936 vl_api_classify_table_info_reply_t_handler_json
3937 (vl_api_classify_table_info_reply_t * mp)
3939 vat_main_t *vam = &vat_main;
3940 vat_json_node_t node;
3942 i32 retval = ntohl (mp->retval);
3945 vat_json_init_object (&node);
3947 vat_json_object_add_int (&node, "sessions",
3948 ntohl (mp->active_sessions));
3949 vat_json_object_add_int (&node, "nexttbl",
3950 ntohl (mp->next_table_index));
3951 vat_json_object_add_int (&node, "nextnode",
3952 ntohl (mp->miss_next_index));
3953 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3954 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3955 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3956 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3957 ntohl (mp->mask_length), 0);
3958 vat_json_object_add_string_copy (&node, "mask", s);
3960 vat_json_print (vam->ofp, &node);
3961 vat_json_free (&node);
3963 vam->retval = ntohl (mp->retval);
3964 vam->result_ready = 1;
3968 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3971 vat_main_t *vam = &vat_main;
3973 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3974 ntohl (mp->hit_next_index), ntohl (mp->advance),
3975 ntohl (mp->opaque_index));
3976 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3977 ntohl (mp->match_length));
3981 vl_api_classify_session_details_t_handler_json
3982 (vl_api_classify_session_details_t * mp)
3984 vat_main_t *vam = &vat_main;
3985 vat_json_node_t *node = NULL;
3987 if (VAT_JSON_ARRAY != vam->json_tree.type)
3989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3990 vat_json_init_array (&vam->json_tree);
3992 node = vat_json_array_add (&vam->json_tree);
3994 vat_json_init_object (node);
3995 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3996 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3997 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3999 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4001 vat_json_object_add_string_copy (node, "match", s);
4004 static void vl_api_pg_create_interface_reply_t_handler
4005 (vl_api_pg_create_interface_reply_t * mp)
4007 vat_main_t *vam = &vat_main;
4009 vam->retval = ntohl (mp->retval);
4010 vam->result_ready = 1;
4013 static void vl_api_pg_create_interface_reply_t_handler_json
4014 (vl_api_pg_create_interface_reply_t * mp)
4016 vat_main_t *vam = &vat_main;
4017 vat_json_node_t node;
4019 i32 retval = ntohl (mp->retval);
4022 vat_json_init_object (&node);
4024 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4026 vat_json_print (vam->ofp, &node);
4027 vat_json_free (&node);
4029 vam->retval = ntohl (mp->retval);
4030 vam->result_ready = 1;
4033 static void vl_api_policer_classify_details_t_handler
4034 (vl_api_policer_classify_details_t * mp)
4036 vat_main_t *vam = &vat_main;
4038 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4039 ntohl (mp->table_index));
4042 static void vl_api_policer_classify_details_t_handler_json
4043 (vl_api_policer_classify_details_t * mp)
4045 vat_main_t *vam = &vat_main;
4046 vat_json_node_t *node;
4048 if (VAT_JSON_ARRAY != vam->json_tree.type)
4050 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4051 vat_json_init_array (&vam->json_tree);
4053 node = vat_json_array_add (&vam->json_tree);
4055 vat_json_init_object (node);
4056 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4057 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4060 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
4061 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4063 vat_main_t *vam = &vat_main;
4064 i32 retval = ntohl (mp->retval);
4065 if (vam->async_mode)
4067 vam->async_errors += (retval < 0);
4071 vam->retval = retval;
4072 vam->sw_if_index = ntohl (mp->sw_if_index);
4073 vam->result_ready = 1;
4077 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
4078 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4080 vat_main_t *vam = &vat_main;
4081 vat_json_node_t node;
4083 vat_json_init_object (&node);
4084 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4085 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
4087 vat_json_print (vam->ofp, &node);
4088 vat_json_free (&node);
4090 vam->retval = ntohl (mp->retval);
4091 vam->result_ready = 1;
4094 static void vl_api_flow_classify_details_t_handler
4095 (vl_api_flow_classify_details_t * mp)
4097 vat_main_t *vam = &vat_main;
4099 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4100 ntohl (mp->table_index));
4103 static void vl_api_flow_classify_details_t_handler_json
4104 (vl_api_flow_classify_details_t * mp)
4106 vat_main_t *vam = &vat_main;
4107 vat_json_node_t *node;
4109 if (VAT_JSON_ARRAY != vam->json_tree.type)
4111 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4112 vat_json_init_array (&vam->json_tree);
4114 node = vat_json_array_add (&vam->json_tree);
4116 vat_json_init_object (node);
4117 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4118 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4123 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
4124 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
4125 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
4126 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
4127 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
4128 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
4129 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
4130 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
4131 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
4132 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
4135 * Generate boilerplate reply handlers, which
4136 * dig the return value out of the xxx_reply_t API message,
4137 * stick it into vam->retval, and set vam->result_ready
4139 * Could also do this by pointing N message decode slots at
4140 * a single function, but that could break in subtle ways.
4143 #define foreach_standard_reply_retval_handler \
4144 _(sw_interface_set_flags_reply) \
4145 _(sw_interface_add_del_address_reply) \
4146 _(sw_interface_set_table_reply) \
4147 _(sw_interface_set_mpls_enable_reply) \
4148 _(sw_interface_set_vpath_reply) \
4149 _(sw_interface_set_vxlan_bypass_reply) \
4150 _(sw_interface_set_l2_bridge_reply) \
4151 _(bridge_domain_add_del_reply) \
4152 _(sw_interface_set_l2_xconnect_reply) \
4153 _(l2fib_add_del_reply) \
4154 _(l2fib_flush_int_reply) \
4155 _(l2fib_flush_bd_reply) \
4156 _(ip_add_del_route_reply) \
4157 _(ip_mroute_add_del_reply) \
4158 _(mpls_route_add_del_reply) \
4159 _(mpls_ip_bind_unbind_reply) \
4160 _(proxy_arp_add_del_reply) \
4161 _(proxy_arp_intfc_enable_disable_reply) \
4162 _(sw_interface_set_unnumbered_reply) \
4163 _(ip_neighbor_add_del_reply) \
4164 _(reset_vrf_reply) \
4165 _(oam_add_del_reply) \
4166 _(reset_fib_reply) \
4167 _(dhcp_proxy_config_reply) \
4168 _(dhcp_proxy_set_vss_reply) \
4169 _(dhcp_client_config_reply) \
4170 _(set_ip_flow_hash_reply) \
4171 _(sw_interface_ip6_enable_disable_reply) \
4172 _(sw_interface_ip6_set_link_local_address_reply) \
4173 _(ip6nd_proxy_add_del_reply) \
4174 _(sw_interface_ip6nd_ra_prefix_reply) \
4175 _(sw_interface_ip6nd_ra_config_reply) \
4176 _(set_arp_neighbor_limit_reply) \
4177 _(l2_patch_add_del_reply) \
4178 _(sr_policy_add_reply) \
4179 _(sr_policy_mod_reply) \
4180 _(sr_policy_del_reply) \
4181 _(sr_localsid_add_del_reply) \
4182 _(sr_steering_add_del_reply) \
4183 _(classify_add_del_session_reply) \
4184 _(classify_set_interface_ip_table_reply) \
4185 _(classify_set_interface_l2_tables_reply) \
4186 _(l2tpv3_set_tunnel_cookies_reply) \
4187 _(l2tpv3_interface_enable_disable_reply) \
4188 _(l2tpv3_set_lookup_key_reply) \
4189 _(l2_fib_clear_table_reply) \
4190 _(l2_interface_efp_filter_reply) \
4191 _(l2_interface_vlan_tag_rewrite_reply) \
4192 _(modify_vhost_user_if_reply) \
4193 _(delete_vhost_user_if_reply) \
4194 _(want_ip4_arp_events_reply) \
4195 _(want_ip6_nd_events_reply) \
4196 _(input_acl_set_interface_reply) \
4197 _(ipsec_spd_add_del_reply) \
4198 _(ipsec_interface_add_del_spd_reply) \
4199 _(ipsec_spd_add_del_entry_reply) \
4200 _(ipsec_sad_add_del_entry_reply) \
4201 _(ipsec_sa_set_key_reply) \
4202 _(ikev2_profile_add_del_reply) \
4203 _(ikev2_profile_set_auth_reply) \
4204 _(ikev2_profile_set_id_reply) \
4205 _(ikev2_profile_set_ts_reply) \
4206 _(ikev2_set_local_key_reply) \
4207 _(ikev2_set_responder_reply) \
4208 _(ikev2_set_ike_transforms_reply) \
4209 _(ikev2_set_esp_transforms_reply) \
4210 _(ikev2_set_sa_lifetime_reply) \
4211 _(ikev2_initiate_sa_init_reply) \
4212 _(ikev2_initiate_del_ike_sa_reply) \
4213 _(ikev2_initiate_del_child_sa_reply) \
4214 _(ikev2_initiate_rekey_child_sa_reply) \
4215 _(delete_loopback_reply) \
4216 _(bd_ip_mac_add_del_reply) \
4217 _(map_del_domain_reply) \
4218 _(map_add_del_rule_reply) \
4219 _(want_interface_events_reply) \
4220 _(want_stats_reply) \
4221 _(cop_interface_enable_disable_reply) \
4222 _(cop_whitelist_enable_disable_reply) \
4223 _(sw_interface_clear_stats_reply) \
4224 _(ioam_enable_reply) \
4225 _(ioam_disable_reply) \
4226 _(one_add_del_locator_reply) \
4227 _(one_add_del_local_eid_reply) \
4228 _(one_add_del_remote_mapping_reply) \
4229 _(one_add_del_adjacency_reply) \
4230 _(one_add_del_map_resolver_reply) \
4231 _(one_add_del_map_server_reply) \
4232 _(one_enable_disable_reply) \
4233 _(one_rloc_probe_enable_disable_reply) \
4234 _(one_map_register_enable_disable_reply) \
4235 _(one_pitr_set_locator_set_reply) \
4236 _(one_map_request_mode_reply) \
4237 _(one_add_del_map_request_itr_rlocs_reply) \
4238 _(one_eid_table_add_del_map_reply) \
4239 _(one_use_petr_reply) \
4240 _(one_stats_enable_disable_reply) \
4241 _(one_stats_flush_reply) \
4242 _(gpe_add_del_fwd_entry_reply) \
4243 _(gpe_enable_disable_reply) \
4244 _(gpe_set_encap_mode_reply) \
4245 _(gpe_add_del_iface_reply) \
4246 _(vxlan_gpe_add_del_tunnel_reply) \
4247 _(af_packet_delete_reply) \
4248 _(policer_classify_set_interface_reply) \
4249 _(netmap_create_reply) \
4250 _(netmap_delete_reply) \
4251 _(set_ipfix_exporter_reply) \
4252 _(set_ipfix_classify_stream_reply) \
4253 _(ipfix_classify_table_add_del_reply) \
4254 _(flow_classify_set_interface_reply) \
4255 _(sw_interface_span_enable_disable_reply) \
4256 _(pg_capture_reply) \
4257 _(pg_enable_disable_reply) \
4258 _(ip_source_and_port_range_check_add_del_reply) \
4259 _(ip_source_and_port_range_check_interface_add_del_reply)\
4260 _(delete_subif_reply) \
4261 _(l2_interface_pbb_tag_rewrite_reply) \
4263 _(feature_enable_disable_reply) \
4264 _(sw_interface_tag_add_del_reply) \
4265 _(sw_interface_set_mtu_reply)
4268 static void vl_api_##n##_t_handler \
4269 (vl_api_##n##_t * mp) \
4271 vat_main_t * vam = &vat_main; \
4272 i32 retval = ntohl(mp->retval); \
4273 if (vam->async_mode) { \
4274 vam->async_errors += (retval < 0); \
4276 vam->retval = retval; \
4277 vam->result_ready = 1; \
4280 foreach_standard_reply_retval_handler;
4284 static void vl_api_##n##_t_handler_json \
4285 (vl_api_##n##_t * mp) \
4287 vat_main_t * vam = &vat_main; \
4288 vat_json_node_t node; \
4289 vat_json_init_object(&node); \
4290 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
4291 vat_json_print(vam->ofp, &node); \
4292 vam->retval = ntohl(mp->retval); \
4293 vam->result_ready = 1; \
4295 foreach_standard_reply_retval_handler;
4299 * Table of message reply handlers, must include boilerplate handlers
4303 #define foreach_vpe_api_reply_msg \
4304 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4305 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
4306 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4307 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4308 _(CONTROL_PING_REPLY, control_ping_reply) \
4309 _(CLI_REPLY, cli_reply) \
4310 _(CLI_INBAND_REPLY, cli_inband_reply) \
4311 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4312 sw_interface_add_del_address_reply) \
4313 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4314 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4315 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4316 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4317 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4318 sw_interface_set_l2_xconnect_reply) \
4319 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4320 sw_interface_set_l2_bridge_reply) \
4321 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4322 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4323 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
4324 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
4325 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4326 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
4327 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
4328 _(L2_FLAGS_REPLY, l2_flags_reply) \
4329 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4330 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4331 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4332 _(TAP_DELETE_REPLY, tap_delete_reply) \
4333 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4334 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4335 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4336 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4337 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4338 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4339 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4340 proxy_arp_intfc_enable_disable_reply) \
4341 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4342 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4343 sw_interface_set_unnumbered_reply) \
4344 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4345 _(RESET_VRF_REPLY, reset_vrf_reply) \
4346 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4347 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4348 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4349 _(RESET_FIB_REPLY, reset_fib_reply) \
4350 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4351 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4352 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4353 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4354 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4355 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4356 sw_interface_ip6_enable_disable_reply) \
4357 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4358 sw_interface_ip6_set_link_local_address_reply) \
4359 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
4360 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
4361 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4362 sw_interface_ip6nd_ra_prefix_reply) \
4363 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4364 sw_interface_ip6nd_ra_config_reply) \
4365 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4366 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4367 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
4368 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
4369 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
4370 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
4371 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
4372 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4373 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4374 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4375 classify_set_interface_ip_table_reply) \
4376 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4377 classify_set_interface_l2_tables_reply) \
4378 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4379 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4380 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4381 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4382 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4383 l2tpv3_interface_enable_disable_reply) \
4384 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4385 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4386 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4387 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4388 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4389 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4390 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4391 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4392 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4393 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4394 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4395 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4396 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4397 _(SHOW_VERSION_REPLY, show_version_reply) \
4398 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4399 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4400 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4401 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4402 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4403 _(IP4_ARP_EVENT, ip4_arp_event) \
4404 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4405 _(IP6_ND_EVENT, ip6_nd_event) \
4406 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4407 _(IP_ADDRESS_DETAILS, ip_address_details) \
4408 _(IP_DETAILS, ip_details) \
4409 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4410 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4411 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4412 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4413 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4414 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4415 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4416 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4417 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4418 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4419 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4420 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4421 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4422 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4423 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4424 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4425 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4426 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4427 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4428 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4429 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4430 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4431 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4432 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4433 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4434 _(MAP_RULE_DETAILS, map_rule_details) \
4435 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4436 _(WANT_STATS_REPLY, want_stats_reply) \
4437 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4438 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4439 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4440 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4441 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4442 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4443 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4444 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4445 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4446 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4447 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4448 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4449 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4450 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4451 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4452 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4453 one_map_register_enable_disable_reply) \
4454 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4455 one_rloc_probe_enable_disable_reply) \
4456 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4457 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
4458 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4459 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4460 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4461 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4462 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4463 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4464 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4465 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4466 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4467 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4468 _(ONE_STATS_DETAILS, one_stats_details) \
4469 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
4470 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
4471 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
4472 show_one_stats_enable_disable_reply) \
4473 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4474 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4475 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4476 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4477 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4478 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4479 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4480 gpe_fwd_entry_path_details) \
4481 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4482 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4483 one_add_del_map_request_itr_rlocs_reply) \
4484 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4485 one_get_map_request_itr_rlocs_reply) \
4486 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4487 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
4488 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4489 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4490 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4491 show_one_map_register_state_reply) \
4492 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4493 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4494 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4495 _(POLICER_DETAILS, policer_details) \
4496 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4497 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4498 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4499 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4500 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4501 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4502 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4503 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4504 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4505 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4506 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4507 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4508 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4509 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4510 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4511 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4512 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4513 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4514 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4515 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4516 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4517 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4518 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4519 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4520 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4521 ip_source_and_port_range_check_add_del_reply) \
4522 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4523 ip_source_and_port_range_check_interface_add_del_reply) \
4524 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4525 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4526 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4527 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4528 _(PUNT_REPLY, punt_reply) \
4529 _(IP_FIB_DETAILS, ip_fib_details) \
4530 _(IP6_FIB_DETAILS, ip6_fib_details) \
4531 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4532 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4533 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4534 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4535 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4536 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4538 #define foreach_standalone_reply_msg \
4539 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
4540 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4541 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4542 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4543 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4544 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
4553 #define STR_VTR_OP_CASE(op) \
4554 case L2_VTR_ ## op: \
4558 str_vtr_op (u32 vtr_op)
4562 STR_VTR_OP_CASE (DISABLED);
4563 STR_VTR_OP_CASE (PUSH_1);
4564 STR_VTR_OP_CASE (PUSH_2);
4565 STR_VTR_OP_CASE (POP_1);
4566 STR_VTR_OP_CASE (POP_2);
4567 STR_VTR_OP_CASE (TRANSLATE_1_1);
4568 STR_VTR_OP_CASE (TRANSLATE_1_2);
4569 STR_VTR_OP_CASE (TRANSLATE_2_1);
4570 STR_VTR_OP_CASE (TRANSLATE_2_2);
4577 dump_sub_interface_table (vat_main_t * vam)
4579 const sw_interface_subif_t *sub = NULL;
4581 if (vam->json_output)
4584 ("JSON output supported only for VPE API calls and dump_stats_table");
4589 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4590 "Interface", "sw_if_index",
4591 "sub id", "dot1ad", "tags", "outer id",
4592 "inner id", "exact", "default", "outer any", "inner any");
4594 vec_foreach (sub, vam->sw_if_subif_table)
4597 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4598 sub->interface_name,
4600 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4601 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4602 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4603 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4604 if (sub->vtr_op != L2_VTR_DISABLED)
4607 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4608 "tag1: %d tag2: %d ]",
4609 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4610 sub->vtr_tag1, sub->vtr_tag2);
4618 name_sort_cmp (void *a1, void *a2)
4620 name_sort_t *n1 = a1;
4621 name_sort_t *n2 = a2;
4623 return strcmp ((char *) n1->name, (char *) n2->name);
4627 dump_interface_table (vat_main_t * vam)
4630 name_sort_t *nses = 0, *ns;
4632 if (vam->json_output)
4635 ("JSON output supported only for VPE API calls and dump_stats_table");
4640 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4642 vec_add2 (nses, ns, 1);
4643 ns->name = (u8 *)(p->key);
4644 ns->value = (u32) p->value[0];
4648 vec_sort_with_function (nses, name_sort_cmp);
4650 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4651 vec_foreach (ns, nses)
4653 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4660 dump_ip_table (vat_main_t * vam, int is_ipv6)
4662 const ip_details_t *det = NULL;
4663 const ip_address_details_t *address = NULL;
4666 print (vam->ofp, "%-12s", "sw_if_index");
4668 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4675 print (vam->ofp, "%-12d", i);
4676 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4681 vec_foreach (address, det->addr)
4685 is_ipv6 ? format_ip6_address : format_ip4_address,
4686 address->ip, address->prefix_length);
4694 dump_ipv4_table (vat_main_t * vam)
4696 if (vam->json_output)
4699 ("JSON output supported only for VPE API calls and dump_stats_table");
4703 return dump_ip_table (vam, 0);
4707 dump_ipv6_table (vat_main_t * vam)
4709 if (vam->json_output)
4712 ("JSON output supported only for VPE API calls and dump_stats_table");
4716 return dump_ip_table (vam, 1);
4720 counter_type_to_str (u8 counter_type, u8 is_combined)
4724 switch (counter_type)
4726 case VNET_INTERFACE_COUNTER_DROP:
4728 case VNET_INTERFACE_COUNTER_PUNT:
4730 case VNET_INTERFACE_COUNTER_IP4:
4732 case VNET_INTERFACE_COUNTER_IP6:
4734 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4736 case VNET_INTERFACE_COUNTER_RX_MISS:
4738 case VNET_INTERFACE_COUNTER_RX_ERROR:
4740 case VNET_INTERFACE_COUNTER_TX_ERROR:
4743 return "INVALID-COUNTER-TYPE";
4748 switch (counter_type)
4750 case VNET_INTERFACE_COUNTER_RX:
4752 case VNET_INTERFACE_COUNTER_TX:
4755 return "INVALID-COUNTER-TYPE";
4761 dump_stats_table (vat_main_t * vam)
4763 vat_json_node_t node;
4764 vat_json_node_t *msg_array;
4765 vat_json_node_t *msg;
4766 vat_json_node_t *counter_array;
4767 vat_json_node_t *counter;
4768 interface_counter_t c;
4770 ip4_fib_counter_t *c4;
4771 ip6_fib_counter_t *c6;
4772 ip4_nbr_counter_t *n4;
4773 ip6_nbr_counter_t *n6;
4776 if (!vam->json_output)
4778 clib_warning ("dump_stats_table supported only in JSON format");
4782 vat_json_init_object (&node);
4784 /* interface counters */
4785 msg_array = vat_json_object_add (&node, "interface_counters");
4786 vat_json_init_array (msg_array);
4787 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4789 msg = vat_json_array_add (msg_array);
4790 vat_json_init_object (msg);
4791 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4792 (u8 *) counter_type_to_str (i, 0));
4793 vat_json_object_add_int (msg, "is_combined", 0);
4794 counter_array = vat_json_object_add (msg, "data");
4795 vat_json_init_array (counter_array);
4796 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4798 packets = vam->simple_interface_counters[i][j];
4799 vat_json_array_add_uint (counter_array, packets);
4802 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4804 msg = vat_json_array_add (msg_array);
4805 vat_json_init_object (msg);
4806 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4807 (u8 *) counter_type_to_str (i, 1));
4808 vat_json_object_add_int (msg, "is_combined", 1);
4809 counter_array = vat_json_object_add (msg, "data");
4810 vat_json_init_array (counter_array);
4811 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4813 c = vam->combined_interface_counters[i][j];
4814 counter = vat_json_array_add (counter_array);
4815 vat_json_init_object (counter);
4816 vat_json_object_add_uint (counter, "packets", c.packets);
4817 vat_json_object_add_uint (counter, "bytes", c.bytes);
4821 /* ip4 fib counters */
4822 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4823 vat_json_init_array (msg_array);
4824 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4826 msg = vat_json_array_add (msg_array);
4827 vat_json_init_object (msg);
4828 vat_json_object_add_uint (msg, "vrf_id",
4829 vam->ip4_fib_counters_vrf_id_by_index[i]);
4830 counter_array = vat_json_object_add (msg, "c");
4831 vat_json_init_array (counter_array);
4832 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4834 counter = vat_json_array_add (counter_array);
4835 vat_json_init_object (counter);
4836 c4 = &vam->ip4_fib_counters[i][j];
4837 vat_json_object_add_ip4 (counter, "address", c4->address);
4838 vat_json_object_add_uint (counter, "address_length",
4839 c4->address_length);
4840 vat_json_object_add_uint (counter, "packets", c4->packets);
4841 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4845 /* ip6 fib counters */
4846 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4847 vat_json_init_array (msg_array);
4848 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4850 msg = vat_json_array_add (msg_array);
4851 vat_json_init_object (msg);
4852 vat_json_object_add_uint (msg, "vrf_id",
4853 vam->ip6_fib_counters_vrf_id_by_index[i]);
4854 counter_array = vat_json_object_add (msg, "c");
4855 vat_json_init_array (counter_array);
4856 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4858 counter = vat_json_array_add (counter_array);
4859 vat_json_init_object (counter);
4860 c6 = &vam->ip6_fib_counters[i][j];
4861 vat_json_object_add_ip6 (counter, "address", c6->address);
4862 vat_json_object_add_uint (counter, "address_length",
4863 c6->address_length);
4864 vat_json_object_add_uint (counter, "packets", c6->packets);
4865 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4869 /* ip4 nbr counters */
4870 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4871 vat_json_init_array (msg_array);
4872 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4874 msg = vat_json_array_add (msg_array);
4875 vat_json_init_object (msg);
4876 vat_json_object_add_uint (msg, "sw_if_index", i);
4877 counter_array = vat_json_object_add (msg, "c");
4878 vat_json_init_array (counter_array);
4879 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4881 counter = vat_json_array_add (counter_array);
4882 vat_json_init_object (counter);
4883 n4 = &vam->ip4_nbr_counters[i][j];
4884 vat_json_object_add_ip4 (counter, "address", n4->address);
4885 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4886 vat_json_object_add_uint (counter, "packets", n4->packets);
4887 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4891 /* ip6 nbr counters */
4892 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4893 vat_json_init_array (msg_array);
4894 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4896 msg = vat_json_array_add (msg_array);
4897 vat_json_init_object (msg);
4898 vat_json_object_add_uint (msg, "sw_if_index", i);
4899 counter_array = vat_json_object_add (msg, "c");
4900 vat_json_init_array (counter_array);
4901 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4903 counter = vat_json_array_add (counter_array);
4904 vat_json_init_object (counter);
4905 n6 = &vam->ip6_nbr_counters[i][j];
4906 vat_json_object_add_ip6 (counter, "address", n6->address);
4907 vat_json_object_add_uint (counter, "packets", n6->packets);
4908 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4912 vat_json_print (vam->ofp, &node);
4913 vat_json_free (&node);
4919 exec (vat_main_t * vam)
4921 api_main_t *am = &api_main;
4922 vl_api_cli_request_t *mp;
4926 unformat_input_t *i = vam->input;
4928 if (vec_len (i->buffer) == 0)
4931 if (vam->exec_mode == 0 && unformat (i, "mode"))
4936 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4943 M (CLI_REQUEST, mp);
4946 * Copy cmd into shared memory.
4947 * In order for the CLI command to work, it
4948 * must be a vector ending in \n, not a C-string ending
4951 pthread_mutex_lock (&am->vlib_rp->mutex);
4952 oldheap = svm_push_data_heap (am->vlib_rp);
4954 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4955 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4957 svm_pop_heap (oldheap);
4958 pthread_mutex_unlock (&am->vlib_rp->mutex);
4960 mp->cmd_in_shmem = (u64) cmd;
4962 timeout = vat_time_now (vam) + 10.0;
4964 while (vat_time_now (vam) < timeout)
4966 if (vam->result_ready == 1)
4969 if (vam->shmem_result != NULL)
4970 print (vam->ofp, "%s", vam->shmem_result);
4971 pthread_mutex_lock (&am->vlib_rp->mutex);
4972 oldheap = svm_push_data_heap (am->vlib_rp);
4974 free_me = (u8 *) vam->shmem_result;
4977 svm_pop_heap (oldheap);
4978 pthread_mutex_unlock (&am->vlib_rp->mutex);
4986 * Future replacement of exec() that passes CLI buffers directly in
4987 * the API messages instead of an additional shared memory area.
4990 exec_inband (vat_main_t * vam)
4992 vl_api_cli_inband_t *mp;
4993 unformat_input_t *i = vam->input;
4996 if (vec_len (i->buffer) == 0)
4999 if (vam->exec_mode == 0 && unformat (i, "mode"))
5004 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5011 * In order for the CLI command to work, it
5012 * must be a vector ending in \n, not a C-string ending
5015 u32 len = vec_len (vam->input->buffer);
5016 M2 (CLI_INBAND, mp, len);
5017 clib_memcpy (mp->cmd, vam->input->buffer, len);
5018 mp->length = htonl (len);
5021 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
5026 api_create_loopback (vat_main_t * vam)
5028 unformat_input_t *i = vam->input;
5029 vl_api_create_loopback_t *mp;
5030 vl_api_create_loopback_instance_t *mp_lbi;
5033 u8 is_specified = 0;
5034 u32 user_instance = 0;
5037 memset (mac_address, 0, sizeof (mac_address));
5039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5041 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5043 if (unformat (i, "instance %d", &user_instance))
5051 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5052 mp_lbi->is_specified = is_specified;
5054 mp_lbi->user_instance = htonl (user_instance);
5056 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5061 /* Construct the API message */
5062 M (CREATE_LOOPBACK, mp);
5064 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5073 api_delete_loopback (vat_main_t * vam)
5075 unformat_input_t *i = vam->input;
5076 vl_api_delete_loopback_t *mp;
5077 u32 sw_if_index = ~0;
5080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5082 if (unformat (i, "sw_if_index %d", &sw_if_index))
5088 if (sw_if_index == ~0)
5090 errmsg ("missing sw_if_index");
5094 /* Construct the API message */
5095 M (DELETE_LOOPBACK, mp);
5096 mp->sw_if_index = ntohl (sw_if_index);
5104 api_want_stats (vat_main_t * vam)
5106 unformat_input_t *i = vam->input;
5107 vl_api_want_stats_t *mp;
5111 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5113 if (unformat (i, "enable"))
5115 else if (unformat (i, "disable"))
5123 errmsg ("missing enable|disable");
5128 mp->enable_disable = enable;
5136 api_want_interface_events (vat_main_t * vam)
5138 unformat_input_t *i = vam->input;
5139 vl_api_want_interface_events_t *mp;
5143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5145 if (unformat (i, "enable"))
5147 else if (unformat (i, "disable"))
5155 errmsg ("missing enable|disable");
5159 M (WANT_INTERFACE_EVENTS, mp);
5160 mp->enable_disable = enable;
5162 vam->interface_event_display = enable;
5170 /* Note: non-static, called once to set up the initial intfc table */
5172 api_sw_interface_dump (vat_main_t * vam)
5174 vl_api_sw_interface_dump_t *mp;
5175 vl_api_control_ping_t *mp_ping;
5177 name_sort_t *nses = 0, *ns;
5178 sw_interface_subif_t *sub = NULL;
5181 /* Toss the old name table */
5183 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5185 vec_add2 (nses, ns, 1);
5186 ns->name = (u8 *)(p->key);
5187 ns->value = (u32) p->value[0];
5191 hash_free (vam->sw_if_index_by_interface_name);
5193 vec_foreach (ns, nses) vec_free (ns->name);
5197 vec_foreach (sub, vam->sw_if_subif_table)
5199 vec_free (sub->interface_name);
5201 vec_free (vam->sw_if_subif_table);
5203 /* recreate the interface name hash table */
5204 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5206 /* Get list of ethernets */
5207 M (SW_INTERFACE_DUMP, mp);
5208 mp->name_filter_valid = 1;
5209 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
5212 /* and local / loopback interfaces */
5213 M (SW_INTERFACE_DUMP, mp);
5214 mp->name_filter_valid = 1;
5215 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
5218 /* and packet-generator interfaces */
5219 M (SW_INTERFACE_DUMP, mp);
5220 mp->name_filter_valid = 1;
5221 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
5224 /* and vxlan-gpe tunnel interfaces */
5225 M (SW_INTERFACE_DUMP, mp);
5226 mp->name_filter_valid = 1;
5227 strncpy ((char *) mp->name_filter, "vxlan_gpe",
5228 sizeof (mp->name_filter) - 1);
5231 /* and vxlan tunnel interfaces */
5232 M (SW_INTERFACE_DUMP, mp);
5233 mp->name_filter_valid = 1;
5234 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
5237 /* and host (af_packet) interfaces */
5238 M (SW_INTERFACE_DUMP, mp);
5239 mp->name_filter_valid = 1;
5240 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
5243 /* and l2tpv3 tunnel interfaces */
5244 M (SW_INTERFACE_DUMP, mp);
5245 mp->name_filter_valid = 1;
5246 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
5247 sizeof (mp->name_filter) - 1);
5250 /* and GRE tunnel interfaces */
5251 M (SW_INTERFACE_DUMP, mp);
5252 mp->name_filter_valid = 1;
5253 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
5256 /* and LISP-GPE interfaces */
5257 M (SW_INTERFACE_DUMP, mp);
5258 mp->name_filter_valid = 1;
5259 strncpy ((char *) mp->name_filter, "lisp_gpe",
5260 sizeof (mp->name_filter) - 1);
5263 /* and IPSEC tunnel interfaces */
5264 M (SW_INTERFACE_DUMP, mp);
5265 mp->name_filter_valid = 1;
5266 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
5269 /* Use a control ping for synchronization */
5270 M (CONTROL_PING, mp_ping);
5278 api_sw_interface_set_flags (vat_main_t * vam)
5280 unformat_input_t *i = vam->input;
5281 vl_api_sw_interface_set_flags_t *mp;
5283 u8 sw_if_index_set = 0;
5284 u8 admin_up = 0, link_up = 0;
5287 /* Parse args required to build the message */
5288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5290 if (unformat (i, "admin-up"))
5292 else if (unformat (i, "admin-down"))
5294 else if (unformat (i, "link-up"))
5296 else if (unformat (i, "link-down"))
5299 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5300 sw_if_index_set = 1;
5301 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5302 sw_if_index_set = 1;
5307 if (sw_if_index_set == 0)
5309 errmsg ("missing interface name or sw_if_index");
5313 /* Construct the API message */
5314 M (SW_INTERFACE_SET_FLAGS, mp);
5315 mp->sw_if_index = ntohl (sw_if_index);
5316 mp->admin_up_down = admin_up;
5317 mp->link_up_down = link_up;
5322 /* Wait for a reply, return the good/bad news... */
5328 api_sw_interface_clear_stats (vat_main_t * vam)
5330 unformat_input_t *i = vam->input;
5331 vl_api_sw_interface_clear_stats_t *mp;
5333 u8 sw_if_index_set = 0;
5336 /* Parse args required to build the message */
5337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5340 sw_if_index_set = 1;
5341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5342 sw_if_index_set = 1;
5347 /* Construct the API message */
5348 M (SW_INTERFACE_CLEAR_STATS, mp);
5350 if (sw_if_index_set == 1)
5351 mp->sw_if_index = ntohl (sw_if_index);
5353 mp->sw_if_index = ~0;
5358 /* Wait for a reply, return the good/bad news... */
5364 api_sw_interface_add_del_address (vat_main_t * vam)
5366 unformat_input_t *i = vam->input;
5367 vl_api_sw_interface_add_del_address_t *mp;
5369 u8 sw_if_index_set = 0;
5370 u8 is_add = 1, del_all = 0;
5371 u32 address_length = 0;
5372 u8 v4_address_set = 0;
5373 u8 v6_address_set = 0;
5374 ip4_address_t v4address;
5375 ip6_address_t v6address;
5378 /* Parse args required to build the message */
5379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5381 if (unformat (i, "del-all"))
5383 else if (unformat (i, "del"))
5386 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5387 sw_if_index_set = 1;
5388 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5389 sw_if_index_set = 1;
5390 else if (unformat (i, "%U/%d",
5391 unformat_ip4_address, &v4address, &address_length))
5393 else if (unformat (i, "%U/%d",
5394 unformat_ip6_address, &v6address, &address_length))
5400 if (sw_if_index_set == 0)
5402 errmsg ("missing interface name or sw_if_index");
5405 if (v4_address_set && v6_address_set)
5407 errmsg ("both v4 and v6 addresses set");
5410 if (!v4_address_set && !v6_address_set && !del_all)
5412 errmsg ("no addresses set");
5416 /* Construct the API message */
5417 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5419 mp->sw_if_index = ntohl (sw_if_index);
5420 mp->is_add = is_add;
5421 mp->del_all = del_all;
5425 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5429 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5431 mp->address_length = address_length;
5436 /* Wait for a reply, return good/bad news */
5442 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5444 unformat_input_t *i = vam->input;
5445 vl_api_sw_interface_set_mpls_enable_t *mp;
5447 u8 sw_if_index_set = 0;
5451 /* Parse args required to build the message */
5452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5454 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5455 sw_if_index_set = 1;
5456 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5457 sw_if_index_set = 1;
5458 else if (unformat (i, "disable"))
5460 else if (unformat (i, "dis"))
5466 if (sw_if_index_set == 0)
5468 errmsg ("missing interface name or sw_if_index");
5472 /* Construct the API message */
5473 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5475 mp->sw_if_index = ntohl (sw_if_index);
5476 mp->enable = enable;
5481 /* Wait for a reply... */
5487 api_sw_interface_set_table (vat_main_t * vam)
5489 unformat_input_t *i = vam->input;
5490 vl_api_sw_interface_set_table_t *mp;
5491 u32 sw_if_index, vrf_id = 0;
5492 u8 sw_if_index_set = 0;
5496 /* Parse args required to build the message */
5497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5499 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5500 sw_if_index_set = 1;
5501 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5502 sw_if_index_set = 1;
5503 else if (unformat (i, "vrf %d", &vrf_id))
5505 else if (unformat (i, "ipv6"))
5511 if (sw_if_index_set == 0)
5513 errmsg ("missing interface name or sw_if_index");
5517 /* Construct the API message */
5518 M (SW_INTERFACE_SET_TABLE, mp);
5520 mp->sw_if_index = ntohl (sw_if_index);
5521 mp->is_ipv6 = is_ipv6;
5522 mp->vrf_id = ntohl (vrf_id);
5527 /* Wait for a reply... */
5532 static void vl_api_sw_interface_get_table_reply_t_handler
5533 (vl_api_sw_interface_get_table_reply_t * mp)
5535 vat_main_t *vam = &vat_main;
5537 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5539 vam->retval = ntohl (mp->retval);
5540 vam->result_ready = 1;
5544 static void vl_api_sw_interface_get_table_reply_t_handler_json
5545 (vl_api_sw_interface_get_table_reply_t * mp)
5547 vat_main_t *vam = &vat_main;
5548 vat_json_node_t node;
5550 vat_json_init_object (&node);
5551 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5552 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5554 vat_json_print (vam->ofp, &node);
5555 vat_json_free (&node);
5557 vam->retval = ntohl (mp->retval);
5558 vam->result_ready = 1;
5562 api_sw_interface_get_table (vat_main_t * vam)
5564 unformat_input_t *i = vam->input;
5565 vl_api_sw_interface_get_table_t *mp;
5567 u8 sw_if_index_set = 0;
5571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5573 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5574 sw_if_index_set = 1;
5575 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5576 sw_if_index_set = 1;
5577 else if (unformat (i, "ipv6"))
5583 if (sw_if_index_set == 0)
5585 errmsg ("missing interface name or sw_if_index");
5589 M (SW_INTERFACE_GET_TABLE, mp);
5590 mp->sw_if_index = htonl (sw_if_index);
5591 mp->is_ipv6 = is_ipv6;
5599 api_sw_interface_set_vpath (vat_main_t * vam)
5601 unformat_input_t *i = vam->input;
5602 vl_api_sw_interface_set_vpath_t *mp;
5603 u32 sw_if_index = 0;
5604 u8 sw_if_index_set = 0;
5608 /* Parse args required to build the message */
5609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5611 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5612 sw_if_index_set = 1;
5613 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5614 sw_if_index_set = 1;
5615 else if (unformat (i, "enable"))
5617 else if (unformat (i, "disable"))
5623 if (sw_if_index_set == 0)
5625 errmsg ("missing interface name or sw_if_index");
5629 /* Construct the API message */
5630 M (SW_INTERFACE_SET_VPATH, mp);
5632 mp->sw_if_index = ntohl (sw_if_index);
5633 mp->enable = is_enable;
5638 /* Wait for a reply... */
5644 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5646 unformat_input_t *i = vam->input;
5647 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5648 u32 sw_if_index = 0;
5649 u8 sw_if_index_set = 0;
5654 /* Parse args required to build the message */
5655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5657 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5658 sw_if_index_set = 1;
5659 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5660 sw_if_index_set = 1;
5661 else if (unformat (i, "enable"))
5663 else if (unformat (i, "disable"))
5665 else if (unformat (i, "ip4"))
5667 else if (unformat (i, "ip6"))
5673 if (sw_if_index_set == 0)
5675 errmsg ("missing interface name or sw_if_index");
5679 /* Construct the API message */
5680 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5682 mp->sw_if_index = ntohl (sw_if_index);
5683 mp->enable = is_enable;
5684 mp->is_ipv6 = is_ipv6;
5689 /* Wait for a reply... */
5695 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5697 unformat_input_t *i = vam->input;
5698 vl_api_sw_interface_set_l2_xconnect_t *mp;
5700 u8 rx_sw_if_index_set = 0;
5702 u8 tx_sw_if_index_set = 0;
5706 /* Parse args required to build the message */
5707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5709 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5710 rx_sw_if_index_set = 1;
5711 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5712 tx_sw_if_index_set = 1;
5713 else if (unformat (i, "rx"))
5715 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5717 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5719 rx_sw_if_index_set = 1;
5724 else if (unformat (i, "tx"))
5726 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5728 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5730 tx_sw_if_index_set = 1;
5735 else if (unformat (i, "enable"))
5737 else if (unformat (i, "disable"))
5743 if (rx_sw_if_index_set == 0)
5745 errmsg ("missing rx interface name or rx_sw_if_index");
5749 if (enable && (tx_sw_if_index_set == 0))
5751 errmsg ("missing tx interface name or tx_sw_if_index");
5755 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5757 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5758 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5759 mp->enable = enable;
5767 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5769 unformat_input_t *i = vam->input;
5770 vl_api_sw_interface_set_l2_bridge_t *mp;
5772 u8 rx_sw_if_index_set = 0;
5780 /* Parse args required to build the message */
5781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5783 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5784 rx_sw_if_index_set = 1;
5785 else if (unformat (i, "bd_id %d", &bd_id))
5789 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5790 rx_sw_if_index_set = 1;
5791 else if (unformat (i, "shg %d", &shg))
5793 else if (unformat (i, "bvi"))
5795 else if (unformat (i, "enable"))
5797 else if (unformat (i, "disable"))
5803 if (rx_sw_if_index_set == 0)
5805 errmsg ("missing rx interface name or sw_if_index");
5809 if (enable && (bd_id_set == 0))
5811 errmsg ("missing bridge domain");
5815 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5817 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5818 mp->bd_id = ntohl (bd_id);
5821 mp->enable = enable;
5829 api_bridge_domain_dump (vat_main_t * vam)
5831 unformat_input_t *i = vam->input;
5832 vl_api_bridge_domain_dump_t *mp;
5833 vl_api_control_ping_t *mp_ping;
5837 /* Parse args required to build the message */
5838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5840 if (unformat (i, "bd_id %d", &bd_id))
5846 M (BRIDGE_DOMAIN_DUMP, mp);
5847 mp->bd_id = ntohl (bd_id);
5850 /* Use a control ping for synchronization */
5851 M (CONTROL_PING, mp_ping);
5859 api_bridge_domain_add_del (vat_main_t * vam)
5861 unformat_input_t *i = vam->input;
5862 vl_api_bridge_domain_add_del_t *mp;
5865 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5869 /* Parse args required to build the message */
5870 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5872 if (unformat (i, "bd_id %d", &bd_id))
5874 else if (unformat (i, "flood %d", &flood))
5876 else if (unformat (i, "uu-flood %d", &uu_flood))
5878 else if (unformat (i, "forward %d", &forward))
5880 else if (unformat (i, "learn %d", &learn))
5882 else if (unformat (i, "arp-term %d", &arp_term))
5884 else if (unformat (i, "mac-age %d", &mac_age))
5886 else if (unformat (i, "del"))
5889 flood = uu_flood = forward = learn = 0;
5897 errmsg ("missing bridge domain");
5903 errmsg ("mac age must be less than 256 ");
5907 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5909 mp->bd_id = ntohl (bd_id);
5911 mp->uu_flood = uu_flood;
5912 mp->forward = forward;
5914 mp->arp_term = arp_term;
5915 mp->is_add = is_add;
5916 mp->mac_age = (u8) mac_age;
5924 api_l2fib_flush_bd (vat_main_t * vam)
5926 unformat_input_t *i = vam->input;
5927 vl_api_l2fib_flush_bd_t *mp;
5931 /* Parse args required to build the message */
5932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5934 if (unformat (i, "bd_id %d", &bd_id));
5941 errmsg ("missing bridge domain");
5945 M (L2FIB_FLUSH_BD, mp);
5947 mp->bd_id = htonl (bd_id);
5955 api_l2fib_flush_int (vat_main_t * vam)
5957 unformat_input_t *i = vam->input;
5958 vl_api_l2fib_flush_int_t *mp;
5959 u32 sw_if_index = ~0;
5962 /* Parse args required to build the message */
5963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5965 if (unformat (i, "sw_if_index %d", &sw_if_index));
5967 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
5972 if (sw_if_index == ~0)
5974 errmsg ("missing interface name or sw_if_index");
5978 M (L2FIB_FLUSH_INT, mp);
5980 mp->sw_if_index = ntohl (sw_if_index);
5988 api_l2fib_add_del (vat_main_t * vam)
5990 unformat_input_t *i = vam->input;
5991 vl_api_l2fib_add_del_t *mp;
5997 u32 sw_if_index = ~0;
5998 u8 sw_if_index_set = 0;
6007 /* Parse args required to build the message */
6008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6010 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
6012 else if (unformat (i, "bd_id %d", &bd_id))
6014 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6015 sw_if_index_set = 1;
6016 else if (unformat (i, "sw_if"))
6018 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6021 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6022 sw_if_index_set = 1;
6027 else if (unformat (i, "static"))
6029 else if (unformat (i, "filter"))
6034 else if (unformat (i, "bvi"))
6039 else if (unformat (i, "del"))
6041 else if (unformat (i, "count %d", &count))
6049 errmsg ("missing mac address");
6055 errmsg ("missing bridge domain");
6059 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6061 errmsg ("missing interface name or sw_if_index");
6067 /* Turn on async mode */
6068 vam->async_mode = 1;
6069 vam->async_errors = 0;
6070 before = vat_time_now (vam);
6073 for (j = 0; j < count; j++)
6075 M (L2FIB_ADD_DEL, mp);
6078 mp->bd_id = ntohl (bd_id);
6079 mp->is_add = is_add;
6083 mp->sw_if_index = ntohl (sw_if_index);
6084 mp->static_mac = static_mac;
6085 mp->filter_mac = filter_mac;
6086 mp->bvi_mac = bvi_mac;
6088 increment_mac_address (&mac);
6095 vl_api_control_ping_t *mp_ping;
6098 /* Shut off async mode */
6099 vam->async_mode = 0;
6101 M (CONTROL_PING, mp_ping);
6104 timeout = vat_time_now (vam) + 1.0;
6105 while (vat_time_now (vam) < timeout)
6106 if (vam->result_ready == 1)
6111 if (vam->retval == -99)
6114 if (vam->async_errors > 0)
6116 errmsg ("%d asynchronous errors", vam->async_errors);
6119 vam->async_errors = 0;
6120 after = vat_time_now (vam);
6122 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6123 count, after - before, count / (after - before));
6129 /* Wait for a reply... */
6133 /* Return the good/bad news */
6134 return (vam->retval);
6138 api_bridge_domain_set_mac_age (vat_main_t * vam)
6140 unformat_input_t *i = vam->input;
6141 vl_api_bridge_domain_set_mac_age_t *mp;
6146 /* Parse args required to build the message */
6147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6149 if (unformat (i, "bd_id %d", &bd_id));
6150 else if (unformat (i, "mac-age %d", &mac_age));
6157 errmsg ("missing bridge domain");
6163 errmsg ("mac age must be less than 256 ");
6167 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6169 mp->bd_id = htonl (bd_id);
6170 mp->mac_age = (u8) mac_age;
6178 api_l2_flags (vat_main_t * vam)
6180 unformat_input_t *i = vam->input;
6181 vl_api_l2_flags_t *mp;
6183 u32 feature_bitmap = 0;
6184 u8 sw_if_index_set = 0;
6187 /* Parse args required to build the message */
6188 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6190 if (unformat (i, "sw_if_index %d", &sw_if_index))
6191 sw_if_index_set = 1;
6192 else if (unformat (i, "sw_if"))
6194 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6197 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6198 sw_if_index_set = 1;
6203 else if (unformat (i, "learn"))
6204 feature_bitmap |= L2INPUT_FEAT_LEARN;
6205 else if (unformat (i, "forward"))
6206 feature_bitmap |= L2INPUT_FEAT_FWD;
6207 else if (unformat (i, "flood"))
6208 feature_bitmap |= L2INPUT_FEAT_FLOOD;
6209 else if (unformat (i, "uu-flood"))
6210 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
6215 if (sw_if_index_set == 0)
6217 errmsg ("missing interface name or sw_if_index");
6223 mp->sw_if_index = ntohl (sw_if_index);
6224 mp->feature_bitmap = ntohl (feature_bitmap);
6232 api_bridge_flags (vat_main_t * vam)
6234 unformat_input_t *i = vam->input;
6235 vl_api_bridge_flags_t *mp;
6242 /* Parse args required to build the message */
6243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6245 if (unformat (i, "bd_id %d", &bd_id))
6247 else if (unformat (i, "learn"))
6249 else if (unformat (i, "forward"))
6251 else if (unformat (i, "flood"))
6253 else if (unformat (i, "uu-flood"))
6254 flags |= L2_UU_FLOOD;
6255 else if (unformat (i, "arp-term"))
6256 flags |= L2_ARP_TERM;
6257 else if (unformat (i, "off"))
6259 else if (unformat (i, "disable"))
6267 errmsg ("missing bridge domain");
6271 M (BRIDGE_FLAGS, mp);
6273 mp->bd_id = ntohl (bd_id);
6274 mp->feature_bitmap = ntohl (flags);
6275 mp->is_set = is_set;
6283 api_bd_ip_mac_add_del (vat_main_t * vam)
6285 unformat_input_t *i = vam->input;
6286 vl_api_bd_ip_mac_add_del_t *mp;
6293 ip4_address_t v4addr;
6294 ip6_address_t v6addr;
6299 /* Parse args required to build the message */
6300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6302 if (unformat (i, "bd_id %d", &bd_id))
6306 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6310 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6315 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6319 else if (unformat (i, "del"))
6327 errmsg ("missing bridge domain");
6330 else if (ip_set == 0)
6332 errmsg ("missing IP address");
6335 else if (mac_set == 0)
6337 errmsg ("missing MAC address");
6341 M (BD_IP_MAC_ADD_DEL, mp);
6343 mp->bd_id = ntohl (bd_id);
6344 mp->is_ipv6 = is_ipv6;
6345 mp->is_add = is_add;
6347 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6349 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6350 clib_memcpy (mp->mac_address, macaddr, 6);
6357 api_tap_connect (vat_main_t * vam)
6359 unformat_input_t *i = vam->input;
6360 vl_api_tap_connect_t *mp;
6366 ip4_address_t ip4_address;
6368 int ip4_address_set = 0;
6369 ip6_address_t ip6_address;
6371 int ip6_address_set = 0;
6374 memset (mac_address, 0, sizeof (mac_address));
6376 /* Parse args required to build the message */
6377 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6379 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6383 else if (unformat (i, "random-mac"))
6385 else if (unformat (i, "tapname %s", &tap_name))
6387 else if (unformat (i, "tag %s", &tag))
6389 else if (unformat (i, "address %U/%d",
6390 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6391 ip4_address_set = 1;
6392 else if (unformat (i, "address %U/%d",
6393 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6394 ip6_address_set = 1;
6401 errmsg ("missing tap name");
6404 if (vec_len (tap_name) > 63)
6406 errmsg ("tap name too long");
6409 vec_add1 (tap_name, 0);
6411 if (vec_len (tag) > 63)
6413 errmsg ("tag too long");
6417 /* Construct the API message */
6418 M (TAP_CONNECT, mp);
6420 mp->use_random_mac = random_mac;
6421 clib_memcpy (mp->mac_address, mac_address, 6);
6422 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6424 clib_memcpy (mp->tag, tag, vec_len (tag));
6426 if (ip4_address_set)
6428 mp->ip4_address_set = 1;
6429 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6430 mp->ip4_mask_width = ip4_mask_width;
6432 if (ip6_address_set)
6434 mp->ip6_address_set = 1;
6435 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6436 mp->ip6_mask_width = ip6_mask_width;
6439 vec_free (tap_name);
6445 /* Wait for a reply... */
6451 api_tap_modify (vat_main_t * vam)
6453 unformat_input_t *i = vam->input;
6454 vl_api_tap_modify_t *mp;
6459 u32 sw_if_index = ~0;
6460 u8 sw_if_index_set = 0;
6463 memset (mac_address, 0, sizeof (mac_address));
6465 /* Parse args required to build the message */
6466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6469 sw_if_index_set = 1;
6470 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6471 sw_if_index_set = 1;
6472 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6476 else if (unformat (i, "random-mac"))
6478 else if (unformat (i, "tapname %s", &tap_name))
6484 if (sw_if_index_set == 0)
6486 errmsg ("missing vpp interface name");
6491 errmsg ("missing tap name");
6494 if (vec_len (tap_name) > 63)
6496 errmsg ("tap name too long");
6498 vec_add1 (tap_name, 0);
6500 /* Construct the API message */
6503 mp->use_random_mac = random_mac;
6504 mp->sw_if_index = ntohl (sw_if_index);
6505 clib_memcpy (mp->mac_address, mac_address, 6);
6506 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6507 vec_free (tap_name);
6512 /* Wait for a reply... */
6518 api_tap_delete (vat_main_t * vam)
6520 unformat_input_t *i = vam->input;
6521 vl_api_tap_delete_t *mp;
6522 u32 sw_if_index = ~0;
6523 u8 sw_if_index_set = 0;
6526 /* Parse args required to build the message */
6527 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6529 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6530 sw_if_index_set = 1;
6531 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6532 sw_if_index_set = 1;
6537 if (sw_if_index_set == 0)
6539 errmsg ("missing vpp interface name");
6543 /* Construct the API message */
6546 mp->sw_if_index = ntohl (sw_if_index);
6551 /* Wait for a reply... */
6557 api_ip_add_del_route (vat_main_t * vam)
6559 unformat_input_t *i = vam->input;
6560 vl_api_ip_add_del_route_t *mp;
6561 u32 sw_if_index = ~0, vrf_id = 0;
6563 u8 is_local = 0, is_drop = 0;
6564 u8 is_unreach = 0, is_prohibit = 0;
6565 u8 create_vrf_if_needed = 0;
6567 u32 next_hop_weight = 1;
6569 u8 is_multipath = 0;
6571 u8 address_length_set = 0;
6572 u32 next_hop_table_id = 0;
6573 u32 resolve_attempts = 0;
6574 u32 dst_address_length = 0;
6575 u8 next_hop_set = 0;
6576 ip4_address_t v4_dst_address, v4_next_hop_address;
6577 ip6_address_t v6_dst_address, v6_next_hop_address;
6581 u32 random_add_del = 0;
6582 u32 *random_vector = 0;
6584 u32 random_seed = 0xdeaddabe;
6585 u32 classify_table_index = ~0;
6587 u8 resolve_host = 0, resolve_attached = 0;
6588 mpls_label_t *next_hop_out_label_stack = NULL;
6589 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6590 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6592 /* Parse args required to build the message */
6593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6595 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6597 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6599 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6604 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6609 else if (unformat (i, "/%d", &dst_address_length))
6611 address_length_set = 1;
6614 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6615 &v4_next_hop_address))
6619 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6620 &v6_next_hop_address))
6624 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6626 else if (unformat (i, "weight %d", &next_hop_weight))
6628 else if (unformat (i, "drop"))
6632 else if (unformat (i, "null-send-unreach"))
6636 else if (unformat (i, "null-send-prohibit"))
6640 else if (unformat (i, "local"))
6644 else if (unformat (i, "classify %d", &classify_table_index))
6648 else if (unformat (i, "del"))
6650 else if (unformat (i, "add"))
6652 else if (unformat (i, "not-last"))
6654 else if (unformat (i, "resolve-via-host"))
6656 else if (unformat (i, "resolve-via-attached"))
6657 resolve_attached = 1;
6658 else if (unformat (i, "multipath"))
6660 else if (unformat (i, "vrf %d", &vrf_id))
6662 else if (unformat (i, "create-vrf"))
6663 create_vrf_if_needed = 1;
6664 else if (unformat (i, "count %d", &count))
6666 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6668 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6670 else if (unformat (i, "out-label %d", &next_hop_out_label))
6671 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6672 else if (unformat (i, "via-label %d", &next_hop_via_label))
6674 else if (unformat (i, "random"))
6676 else if (unformat (i, "seed %d", &random_seed))
6680 clib_warning ("parse error '%U'", format_unformat_error, i);
6685 if (!next_hop_set && !is_drop && !is_local &&
6686 !is_classify && !is_unreach && !is_prohibit &&
6687 MPLS_LABEL_INVALID == next_hop_via_label)
6690 ("next hop / local / drop / unreach / prohibit / classify not set");
6694 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6696 errmsg ("next hop and next-hop via label set");
6699 if (address_set == 0)
6701 errmsg ("missing addresses");
6705 if (address_length_set == 0)
6707 errmsg ("missing address length");
6711 /* Generate a pile of unique, random routes */
6714 u32 this_random_address;
6715 random_hash = hash_create (count, sizeof (uword));
6717 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6718 for (j = 0; j <= count; j++)
6722 this_random_address = random_u32 (&random_seed);
6723 this_random_address =
6724 clib_host_to_net_u32 (this_random_address);
6726 while (hash_get (random_hash, this_random_address));
6727 vec_add1 (random_vector, this_random_address);
6728 hash_set (random_hash, this_random_address, 1);
6730 hash_free (random_hash);
6731 v4_dst_address.as_u32 = random_vector[0];
6736 /* Turn on async mode */
6737 vam->async_mode = 1;
6738 vam->async_errors = 0;
6739 before = vat_time_now (vam);
6742 for (j = 0; j < count; j++)
6744 /* Construct the API message */
6745 M2 (IP_ADD_DEL_ROUTE, mp,
6746 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6748 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6749 mp->table_id = ntohl (vrf_id);
6750 mp->create_vrf_if_needed = create_vrf_if_needed;
6752 mp->is_add = is_add;
6753 mp->is_drop = is_drop;
6754 mp->is_unreach = is_unreach;
6755 mp->is_prohibit = is_prohibit;
6756 mp->is_ipv6 = is_ipv6;
6757 mp->is_local = is_local;
6758 mp->is_classify = is_classify;
6759 mp->is_multipath = is_multipath;
6760 mp->is_resolve_host = resolve_host;
6761 mp->is_resolve_attached = resolve_attached;
6762 mp->not_last = not_last;
6763 mp->next_hop_weight = next_hop_weight;
6764 mp->dst_address_length = dst_address_length;
6765 mp->next_hop_table_id = ntohl (next_hop_table_id);
6766 mp->classify_table_index = ntohl (classify_table_index);
6767 mp->next_hop_via_label = ntohl (next_hop_via_label);
6768 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6769 if (0 != mp->next_hop_n_out_labels)
6771 memcpy (mp->next_hop_out_label_stack,
6772 next_hop_out_label_stack,
6773 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6774 vec_free (next_hop_out_label_stack);
6779 clib_memcpy (mp->dst_address, &v6_dst_address,
6780 sizeof (v6_dst_address));
6782 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6783 sizeof (v6_next_hop_address));
6784 increment_v6_address (&v6_dst_address);
6788 clib_memcpy (mp->dst_address, &v4_dst_address,
6789 sizeof (v4_dst_address));
6791 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6792 sizeof (v4_next_hop_address));
6794 v4_dst_address.as_u32 = random_vector[j + 1];
6796 increment_v4_address (&v4_dst_address);
6800 /* If we receive SIGTERM, stop now... */
6805 /* When testing multiple add/del ops, use a control-ping to sync */
6808 vl_api_control_ping_t *mp_ping;
6812 /* Shut off async mode */
6813 vam->async_mode = 0;
6815 M (CONTROL_PING, mp_ping);
6818 timeout = vat_time_now (vam) + 1.0;
6819 while (vat_time_now (vam) < timeout)
6820 if (vam->result_ready == 1)
6825 if (vam->retval == -99)
6828 if (vam->async_errors > 0)
6830 errmsg ("%d asynchronous errors", vam->async_errors);
6833 vam->async_errors = 0;
6834 after = vat_time_now (vam);
6836 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6840 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6841 count, after - before, count / (after - before));
6847 /* Wait for a reply... */
6852 /* Return the good/bad news */
6853 return (vam->retval);
6857 api_ip_mroute_add_del (vat_main_t * vam)
6859 unformat_input_t *i = vam->input;
6860 vl_api_ip_mroute_add_del_t *mp;
6861 u32 sw_if_index = ~0, vrf_id = 0;
6864 u8 create_vrf_if_needed = 0;
6867 u32 grp_address_length = 0;
6868 ip4_address_t v4_grp_address, v4_src_address;
6869 ip6_address_t v6_grp_address, v6_src_address;
6870 mfib_itf_flags_t iflags = 0;
6871 mfib_entry_flags_t eflags = 0;
6874 /* Parse args required to build the message */
6875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6877 if (unformat (i, "sw_if_index %d", &sw_if_index))
6879 else if (unformat (i, "%U %U",
6880 unformat_ip4_address, &v4_src_address,
6881 unformat_ip4_address, &v4_grp_address))
6883 grp_address_length = 64;
6887 else if (unformat (i, "%U %U",
6888 unformat_ip6_address, &v6_src_address,
6889 unformat_ip6_address, &v6_grp_address))
6891 grp_address_length = 256;
6895 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6897 memset (&v4_src_address, 0, sizeof (v4_src_address));
6898 grp_address_length = 32;
6902 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6904 memset (&v6_src_address, 0, sizeof (v6_src_address));
6905 grp_address_length = 128;
6909 else if (unformat (i, "/%d", &grp_address_length))
6911 else if (unformat (i, "local"))
6915 else if (unformat (i, "del"))
6917 else if (unformat (i, "add"))
6919 else if (unformat (i, "vrf %d", &vrf_id))
6921 else if (unformat (i, "create-vrf"))
6922 create_vrf_if_needed = 1;
6923 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6925 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6929 clib_warning ("parse error '%U'", format_unformat_error, i);
6934 if (address_set == 0)
6936 errmsg ("missing addresses\n");
6940 /* Construct the API message */
6941 M (IP_MROUTE_ADD_DEL, mp);
6943 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6944 mp->table_id = ntohl (vrf_id);
6945 mp->create_vrf_if_needed = create_vrf_if_needed;
6947 mp->is_add = is_add;
6948 mp->is_ipv6 = is_ipv6;
6949 mp->is_local = is_local;
6950 mp->itf_flags = ntohl (iflags);
6951 mp->entry_flags = ntohl (eflags);
6952 mp->grp_address_length = grp_address_length;
6953 mp->grp_address_length = ntohs (mp->grp_address_length);
6957 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6958 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6962 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6963 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6969 /* Wait for a reply... */
6975 api_mpls_route_add_del (vat_main_t * vam)
6977 unformat_input_t *i = vam->input;
6978 vl_api_mpls_route_add_del_t *mp;
6979 u32 sw_if_index = ~0, table_id = 0;
6980 u8 create_table_if_needed = 0;
6982 u32 next_hop_weight = 1;
6983 u8 is_multipath = 0;
6984 u32 next_hop_table_id = 0;
6985 u8 next_hop_set = 0;
6986 ip4_address_t v4_next_hop_address = {
6989 ip6_address_t v6_next_hop_address = { {0} };
6993 u32 classify_table_index = ~0;
6995 u8 resolve_host = 0, resolve_attached = 0;
6996 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6997 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6998 mpls_label_t *next_hop_out_label_stack = NULL;
6999 mpls_label_t local_label = MPLS_LABEL_INVALID;
7001 u8 next_hop_proto_is_ip4 = 1;
7003 /* Parse args required to build the message */
7004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7006 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7008 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7010 else if (unformat (i, "%d", &local_label))
7012 else if (unformat (i, "eos"))
7014 else if (unformat (i, "non-eos"))
7016 else if (unformat (i, "via %U", unformat_ip4_address,
7017 &v4_next_hop_address))
7020 next_hop_proto_is_ip4 = 1;
7022 else if (unformat (i, "via %U", unformat_ip6_address,
7023 &v6_next_hop_address))
7026 next_hop_proto_is_ip4 = 0;
7028 else if (unformat (i, "weight %d", &next_hop_weight))
7030 else if (unformat (i, "create-table"))
7031 create_table_if_needed = 1;
7032 else if (unformat (i, "classify %d", &classify_table_index))
7036 else if (unformat (i, "del"))
7038 else if (unformat (i, "add"))
7040 else if (unformat (i, "resolve-via-host"))
7042 else if (unformat (i, "resolve-via-attached"))
7043 resolve_attached = 1;
7044 else if (unformat (i, "multipath"))
7046 else if (unformat (i, "count %d", &count))
7048 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
7051 next_hop_proto_is_ip4 = 1;
7053 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
7056 next_hop_proto_is_ip4 = 0;
7058 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7060 else if (unformat (i, "via-label %d", &next_hop_via_label))
7062 else if (unformat (i, "out-label %d", &next_hop_out_label))
7063 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7066 clib_warning ("parse error '%U'", format_unformat_error, i);
7071 if (!next_hop_set && !is_classify)
7073 errmsg ("next hop / classify not set");
7077 if (MPLS_LABEL_INVALID == local_label)
7079 errmsg ("missing label");
7085 /* Turn on async mode */
7086 vam->async_mode = 1;
7087 vam->async_errors = 0;
7088 before = vat_time_now (vam);
7091 for (j = 0; j < count; j++)
7093 /* Construct the API message */
7094 M2 (MPLS_ROUTE_ADD_DEL, mp,
7095 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7097 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
7098 mp->mr_table_id = ntohl (table_id);
7099 mp->mr_create_table_if_needed = create_table_if_needed;
7101 mp->mr_is_add = is_add;
7102 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7103 mp->mr_is_classify = is_classify;
7104 mp->mr_is_multipath = is_multipath;
7105 mp->mr_is_resolve_host = resolve_host;
7106 mp->mr_is_resolve_attached = resolve_attached;
7107 mp->mr_next_hop_weight = next_hop_weight;
7108 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
7109 mp->mr_classify_table_index = ntohl (classify_table_index);
7110 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
7111 mp->mr_label = ntohl (local_label);
7112 mp->mr_eos = is_eos;
7114 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7115 if (0 != mp->mr_next_hop_n_out_labels)
7117 memcpy (mp->mr_next_hop_out_label_stack,
7118 next_hop_out_label_stack,
7119 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7120 vec_free (next_hop_out_label_stack);
7125 if (next_hop_proto_is_ip4)
7127 clib_memcpy (mp->mr_next_hop,
7128 &v4_next_hop_address,
7129 sizeof (v4_next_hop_address));
7133 clib_memcpy (mp->mr_next_hop,
7134 &v6_next_hop_address,
7135 sizeof (v6_next_hop_address));
7142 /* If we receive SIGTERM, stop now... */
7147 /* When testing multiple add/del ops, use a control-ping to sync */
7150 vl_api_control_ping_t *mp_ping;
7154 /* Shut off async mode */
7155 vam->async_mode = 0;
7157 M (CONTROL_PING, mp_ping);
7160 timeout = vat_time_now (vam) + 1.0;
7161 while (vat_time_now (vam) < timeout)
7162 if (vam->result_ready == 1)
7167 if (vam->retval == -99)
7170 if (vam->async_errors > 0)
7172 errmsg ("%d asynchronous errors", vam->async_errors);
7175 vam->async_errors = 0;
7176 after = vat_time_now (vam);
7178 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7182 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7183 count, after - before, count / (after - before));
7189 /* Wait for a reply... */
7194 /* Return the good/bad news */
7195 return (vam->retval);
7199 api_mpls_ip_bind_unbind (vat_main_t * vam)
7201 unformat_input_t *i = vam->input;
7202 vl_api_mpls_ip_bind_unbind_t *mp;
7203 u32 ip_table_id = 0;
7204 u8 create_table_if_needed = 0;
7207 ip4_address_t v4_address;
7208 ip6_address_t v6_address;
7211 mpls_label_t local_label = MPLS_LABEL_INVALID;
7214 /* Parse args required to build the message */
7215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7217 if (unformat (i, "%U/%d", unformat_ip4_address,
7218 &v4_address, &address_length))
7223 else if (unformat (i, "%U/%d", unformat_ip6_address,
7224 &v6_address, &address_length))
7229 else if (unformat (i, "%d", &local_label))
7231 else if (unformat (i, "create-table"))
7232 create_table_if_needed = 1;
7233 else if (unformat (i, "table-id %d", &ip_table_id))
7235 else if (unformat (i, "unbind"))
7237 else if (unformat (i, "bind"))
7241 clib_warning ("parse error '%U'", format_unformat_error, i);
7248 errmsg ("IP addres not set");
7252 if (MPLS_LABEL_INVALID == local_label)
7254 errmsg ("missing label");
7258 /* Construct the API message */
7259 M (MPLS_IP_BIND_UNBIND, mp);
7261 mp->mb_create_table_if_needed = create_table_if_needed;
7262 mp->mb_is_bind = is_bind;
7263 mp->mb_is_ip4 = is_ip4;
7264 mp->mb_ip_table_id = ntohl (ip_table_id);
7265 mp->mb_mpls_table_id = 0;
7266 mp->mb_label = ntohl (local_label);
7267 mp->mb_address_length = address_length;
7270 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7272 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7277 /* Wait for a reply... */
7283 api_proxy_arp_add_del (vat_main_t * vam)
7285 unformat_input_t *i = vam->input;
7286 vl_api_proxy_arp_add_del_t *mp;
7289 ip4_address_t lo, hi;
7293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7295 if (unformat (i, "vrf %d", &vrf_id))
7297 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7298 unformat_ip4_address, &hi))
7300 else if (unformat (i, "del"))
7304 clib_warning ("parse error '%U'", format_unformat_error, i);
7311 errmsg ("address range not set");
7315 M (PROXY_ARP_ADD_DEL, mp);
7317 mp->vrf_id = ntohl (vrf_id);
7318 mp->is_add = is_add;
7319 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7320 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7328 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7330 unformat_input_t *i = vam->input;
7331 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7334 u8 sw_if_index_set = 0;
7337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7340 sw_if_index_set = 1;
7341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7342 sw_if_index_set = 1;
7343 else if (unformat (i, "enable"))
7345 else if (unformat (i, "disable"))
7349 clib_warning ("parse error '%U'", format_unformat_error, i);
7354 if (sw_if_index_set == 0)
7356 errmsg ("missing interface name or sw_if_index");
7360 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7362 mp->sw_if_index = ntohl (sw_if_index);
7363 mp->enable_disable = enable;
7371 api_mpls_tunnel_add_del (vat_main_t * vam)
7373 unformat_input_t *i = vam->input;
7374 vl_api_mpls_tunnel_add_del_t *mp;
7378 u32 sw_if_index = ~0;
7379 u32 next_hop_sw_if_index = ~0;
7380 u32 next_hop_proto_is_ip4 = 1;
7382 u32 next_hop_table_id = 0;
7383 ip4_address_t v4_next_hop_address = {
7386 ip6_address_t v6_next_hop_address = { {0} };
7387 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7390 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7392 if (unformat (i, "add"))
7394 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7396 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7398 else if (unformat (i, "via %U",
7399 unformat_ip4_address, &v4_next_hop_address))
7401 next_hop_proto_is_ip4 = 1;
7403 else if (unformat (i, "via %U",
7404 unformat_ip6_address, &v6_next_hop_address))
7406 next_hop_proto_is_ip4 = 0;
7408 else if (unformat (i, "l2-only"))
7410 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7412 else if (unformat (i, "out-label %d", &next_hop_out_label))
7413 vec_add1 (labels, ntohl (next_hop_out_label));
7416 clib_warning ("parse error '%U'", format_unformat_error, i);
7421 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7423 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7424 mp->mt_sw_if_index = ntohl (sw_if_index);
7425 mp->mt_is_add = is_add;
7426 mp->mt_l2_only = l2_only;
7427 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7428 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7430 mp->mt_next_hop_n_out_labels = vec_len (labels);
7432 if (0 != mp->mt_next_hop_n_out_labels)
7434 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7435 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7439 if (next_hop_proto_is_ip4)
7441 clib_memcpy (mp->mt_next_hop,
7442 &v4_next_hop_address, sizeof (v4_next_hop_address));
7446 clib_memcpy (mp->mt_next_hop,
7447 &v6_next_hop_address, sizeof (v6_next_hop_address));
7456 api_sw_interface_set_unnumbered (vat_main_t * vam)
7458 unformat_input_t *i = vam->input;
7459 vl_api_sw_interface_set_unnumbered_t *mp;
7461 u32 unnum_sw_index = ~0;
7463 u8 sw_if_index_set = 0;
7466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7469 sw_if_index_set = 1;
7470 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7471 sw_if_index_set = 1;
7472 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7474 else if (unformat (i, "del"))
7478 clib_warning ("parse error '%U'", format_unformat_error, i);
7483 if (sw_if_index_set == 0)
7485 errmsg ("missing interface name or sw_if_index");
7489 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7491 mp->sw_if_index = ntohl (sw_if_index);
7492 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7493 mp->is_add = is_add;
7501 api_ip_neighbor_add_del (vat_main_t * vam)
7503 unformat_input_t *i = vam->input;
7504 vl_api_ip_neighbor_add_del_t *mp;
7506 u8 sw_if_index_set = 0;
7509 u8 is_no_fib_entry = 0;
7512 u8 v4_address_set = 0;
7513 u8 v6_address_set = 0;
7514 ip4_address_t v4address;
7515 ip6_address_t v6address;
7518 memset (mac_address, 0, sizeof (mac_address));
7520 /* Parse args required to build the message */
7521 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7523 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7527 else if (unformat (i, "del"))
7530 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7531 sw_if_index_set = 1;
7532 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7533 sw_if_index_set = 1;
7534 else if (unformat (i, "is_static"))
7536 else if (unformat (i, "no-fib-entry"))
7537 is_no_fib_entry = 1;
7538 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7540 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7544 clib_warning ("parse error '%U'", format_unformat_error, i);
7549 if (sw_if_index_set == 0)
7551 errmsg ("missing interface name or sw_if_index");
7554 if (v4_address_set && v6_address_set)
7556 errmsg ("both v4 and v6 addresses set");
7559 if (!v4_address_set && !v6_address_set)
7561 errmsg ("no address set");
7565 /* Construct the API message */
7566 M (IP_NEIGHBOR_ADD_DEL, mp);
7568 mp->sw_if_index = ntohl (sw_if_index);
7569 mp->is_add = is_add;
7570 mp->is_static = is_static;
7571 mp->is_no_adj_fib = is_no_fib_entry;
7573 clib_memcpy (mp->mac_address, mac_address, 6);
7577 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7581 /* mp->is_ipv6 = 0; via memset in M macro above */
7582 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7588 /* Wait for a reply, return good/bad news */
7594 api_reset_vrf (vat_main_t * vam)
7596 unformat_input_t *i = vam->input;
7597 vl_api_reset_vrf_t *mp;
7603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7605 if (unformat (i, "vrf %d", &vrf_id))
7607 else if (unformat (i, "ipv6"))
7611 clib_warning ("parse error '%U'", format_unformat_error, i);
7616 if (vrf_id_set == 0)
7618 errmsg ("missing vrf id");
7624 mp->vrf_id = ntohl (vrf_id);
7625 mp->is_ipv6 = is_ipv6;
7633 api_create_vlan_subif (vat_main_t * vam)
7635 unformat_input_t *i = vam->input;
7636 vl_api_create_vlan_subif_t *mp;
7638 u8 sw_if_index_set = 0;
7643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7645 if (unformat (i, "sw_if_index %d", &sw_if_index))
7646 sw_if_index_set = 1;
7648 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7649 sw_if_index_set = 1;
7650 else if (unformat (i, "vlan %d", &vlan_id))
7654 clib_warning ("parse error '%U'", format_unformat_error, i);
7659 if (sw_if_index_set == 0)
7661 errmsg ("missing interface name or sw_if_index");
7665 if (vlan_id_set == 0)
7667 errmsg ("missing vlan_id");
7670 M (CREATE_VLAN_SUBIF, mp);
7672 mp->sw_if_index = ntohl (sw_if_index);
7673 mp->vlan_id = ntohl (vlan_id);
7680 #define foreach_create_subif_bit \
7687 _(outer_vlan_id_any) \
7688 _(inner_vlan_id_any)
7691 api_create_subif (vat_main_t * vam)
7693 unformat_input_t *i = vam->input;
7694 vl_api_create_subif_t *mp;
7696 u8 sw_if_index_set = 0;
7703 u32 exact_match = 0;
7704 u32 default_sub = 0;
7705 u32 outer_vlan_id_any = 0;
7706 u32 inner_vlan_id_any = 0;
7708 u16 outer_vlan_id = 0;
7709 u16 inner_vlan_id = 0;
7712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7714 if (unformat (i, "sw_if_index %d", &sw_if_index))
7715 sw_if_index_set = 1;
7717 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7718 sw_if_index_set = 1;
7719 else if (unformat (i, "sub_id %d", &sub_id))
7721 else if (unformat (i, "outer_vlan_id %d", &tmp))
7722 outer_vlan_id = tmp;
7723 else if (unformat (i, "inner_vlan_id %d", &tmp))
7724 inner_vlan_id = tmp;
7726 #define _(a) else if (unformat (i, #a)) a = 1 ;
7727 foreach_create_subif_bit
7731 clib_warning ("parse error '%U'", format_unformat_error, i);
7736 if (sw_if_index_set == 0)
7738 errmsg ("missing interface name or sw_if_index");
7742 if (sub_id_set == 0)
7744 errmsg ("missing sub_id");
7747 M (CREATE_SUBIF, mp);
7749 mp->sw_if_index = ntohl (sw_if_index);
7750 mp->sub_id = ntohl (sub_id);
7752 #define _(a) mp->a = a;
7753 foreach_create_subif_bit;
7756 mp->outer_vlan_id = ntohs (outer_vlan_id);
7757 mp->inner_vlan_id = ntohs (inner_vlan_id);
7765 api_oam_add_del (vat_main_t * vam)
7767 unformat_input_t *i = vam->input;
7768 vl_api_oam_add_del_t *mp;
7771 ip4_address_t src, dst;
7776 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7778 if (unformat (i, "vrf %d", &vrf_id))
7780 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7782 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7784 else if (unformat (i, "del"))
7788 clib_warning ("parse error '%U'", format_unformat_error, i);
7795 errmsg ("missing src addr");
7801 errmsg ("missing dst addr");
7805 M (OAM_ADD_DEL, mp);
7807 mp->vrf_id = ntohl (vrf_id);
7808 mp->is_add = is_add;
7809 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7810 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7818 api_reset_fib (vat_main_t * vam)
7820 unformat_input_t *i = vam->input;
7821 vl_api_reset_fib_t *mp;
7827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7829 if (unformat (i, "vrf %d", &vrf_id))
7831 else if (unformat (i, "ipv6"))
7835 clib_warning ("parse error '%U'", format_unformat_error, i);
7840 if (vrf_id_set == 0)
7842 errmsg ("missing vrf id");
7848 mp->vrf_id = ntohl (vrf_id);
7849 mp->is_ipv6 = is_ipv6;
7857 api_dhcp_proxy_config (vat_main_t * vam)
7859 unformat_input_t *i = vam->input;
7860 vl_api_dhcp_proxy_config_t *mp;
7862 u32 server_vrf_id = 0;
7864 u8 v4_address_set = 0;
7865 u8 v6_address_set = 0;
7866 ip4_address_t v4address;
7867 ip6_address_t v6address;
7868 u8 v4_src_address_set = 0;
7869 u8 v6_src_address_set = 0;
7870 ip4_address_t v4srcaddress;
7871 ip6_address_t v6srcaddress;
7874 /* Parse args required to build the message */
7875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7877 if (unformat (i, "del"))
7879 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7881 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7883 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7885 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7887 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7888 v4_src_address_set = 1;
7889 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7890 v6_src_address_set = 1;
7895 if (v4_address_set && v6_address_set)
7897 errmsg ("both v4 and v6 server addresses set");
7900 if (!v4_address_set && !v6_address_set)
7902 errmsg ("no server addresses set");
7906 if (v4_src_address_set && v6_src_address_set)
7908 errmsg ("both v4 and v6 src addresses set");
7911 if (!v4_src_address_set && !v6_src_address_set)
7913 errmsg ("no src addresses set");
7917 if (!(v4_src_address_set && v4_address_set) &&
7918 !(v6_src_address_set && v6_address_set))
7920 errmsg ("no matching server and src addresses set");
7924 /* Construct the API message */
7925 M (DHCP_PROXY_CONFIG, mp);
7927 mp->is_add = is_add;
7928 mp->rx_vrf_id = ntohl (rx_vrf_id);
7929 mp->server_vrf_id = ntohl (server_vrf_id);
7933 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7934 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7938 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7939 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7945 /* Wait for a reply, return good/bad news */
7950 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
7951 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
7954 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
7956 vat_main_t *vam = &vat_main;
7957 u32 i, count = mp->count;
7958 vl_api_dhcp_server_t *s;
7962 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7963 ntohl (mp->rx_vrf_id),
7964 format_ip6_address, mp->dhcp_src_address,
7965 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7968 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7969 ntohl (mp->rx_vrf_id),
7970 format_ip4_address, mp->dhcp_src_address,
7971 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7973 for (i = 0; i < count; i++)
7975 s = &mp->servers[i];
7979 " Server Table-ID %d, Server Address %U",
7980 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
7983 " Server Table-ID %d, Server Address %U",
7984 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
7988 static void vl_api_dhcp_proxy_details_t_handler_json
7989 (vl_api_dhcp_proxy_details_t * mp)
7991 vat_main_t *vam = &vat_main;
7992 vat_json_node_t *node = NULL;
7993 u32 i, count = mp->count;
7995 struct in6_addr ip6;
7996 vl_api_dhcp_server_t *s;
7998 if (VAT_JSON_ARRAY != vam->json_tree.type)
8000 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8001 vat_json_init_array (&vam->json_tree);
8003 node = vat_json_array_add (&vam->json_tree);
8005 vat_json_init_object (node);
8006 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
8007 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
8008 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
8012 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
8013 vat_json_object_add_ip6 (node, "src_address", ip6);
8017 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
8018 vat_json_object_add_ip4 (node, "src_address", ip4);
8021 for (i = 0; i < count; i++)
8023 s = &mp->servers[i];
8025 vat_json_object_add_uint (node, "server-table-id",
8026 ntohl (s->server_vrf_id));
8030 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
8031 vat_json_object_add_ip4 (node, "src_address", ip4);
8035 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
8036 vat_json_object_add_ip6 (node, "server_address", ip6);
8042 api_dhcp_proxy_dump (vat_main_t * vam)
8044 unformat_input_t *i = vam->input;
8045 vl_api_control_ping_t *mp_ping;
8046 vl_api_dhcp_proxy_dump_t *mp;
8050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8052 if (unformat (i, "ipv6"))
8056 clib_warning ("parse error '%U'", format_unformat_error, i);
8061 M (DHCP_PROXY_DUMP, mp);
8063 mp->is_ip6 = is_ipv6;
8066 /* Use a control ping for synchronization */
8067 M (CONTROL_PING, mp_ping);
8075 api_dhcp_proxy_set_vss (vat_main_t * vam)
8077 unformat_input_t *i = vam->input;
8078 vl_api_dhcp_proxy_set_vss_t *mp;
8089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8091 if (unformat (i, "tbl_id %d", &tbl_id))
8093 if (unformat (i, "fib_id %d", &fib_id))
8095 if (unformat (i, "oui %d", &oui))
8097 else if (unformat (i, "ipv6"))
8099 else if (unformat (i, "del"))
8103 clib_warning ("parse error '%U'", format_unformat_error, i);
8108 if (tbl_id_set == 0)
8110 errmsg ("missing tbl id");
8114 if (fib_id_set == 0)
8116 errmsg ("missing fib id");
8121 errmsg ("missing oui");
8125 M (DHCP_PROXY_SET_VSS, mp);
8126 mp->tbl_id = ntohl (tbl_id);
8127 mp->fib_id = ntohl (fib_id);
8128 mp->oui = ntohl (oui);
8129 mp->is_ipv6 = is_ipv6;
8130 mp->is_add = is_add;
8138 api_dhcp_client_config (vat_main_t * vam)
8140 unformat_input_t *i = vam->input;
8141 vl_api_dhcp_client_config_t *mp;
8143 u8 sw_if_index_set = 0;
8146 u8 disable_event = 0;
8149 /* Parse args required to build the message */
8150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8152 if (unformat (i, "del"))
8155 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8156 sw_if_index_set = 1;
8157 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8158 sw_if_index_set = 1;
8159 else if (unformat (i, "hostname %s", &hostname))
8161 else if (unformat (i, "disable_event"))
8167 if (sw_if_index_set == 0)
8169 errmsg ("missing interface name or sw_if_index");
8173 if (vec_len (hostname) > 63)
8175 errmsg ("hostname too long");
8177 vec_add1 (hostname, 0);
8179 /* Construct the API message */
8180 M (DHCP_CLIENT_CONFIG, mp);
8182 mp->sw_if_index = htonl (sw_if_index);
8183 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
8184 vec_free (hostname);
8185 mp->is_add = is_add;
8186 mp->want_dhcp_event = disable_event ? 0 : 1;
8187 mp->pid = htonl (getpid ());
8192 /* Wait for a reply, return good/bad news */
8198 api_set_ip_flow_hash (vat_main_t * vam)
8200 unformat_input_t *i = vam->input;
8201 vl_api_set_ip_flow_hash_t *mp;
8213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8215 if (unformat (i, "vrf %d", &vrf_id))
8217 else if (unformat (i, "ipv6"))
8219 else if (unformat (i, "src"))
8221 else if (unformat (i, "dst"))
8223 else if (unformat (i, "sport"))
8225 else if (unformat (i, "dport"))
8227 else if (unformat (i, "proto"))
8229 else if (unformat (i, "reverse"))
8234 clib_warning ("parse error '%U'", format_unformat_error, i);
8239 if (vrf_id_set == 0)
8241 errmsg ("missing vrf id");
8245 M (SET_IP_FLOW_HASH, mp);
8251 mp->reverse = reverse;
8252 mp->vrf_id = ntohl (vrf_id);
8253 mp->is_ipv6 = is_ipv6;
8261 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
8263 unformat_input_t *i = vam->input;
8264 vl_api_sw_interface_ip6_enable_disable_t *mp;
8266 u8 sw_if_index_set = 0;
8270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8272 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8273 sw_if_index_set = 1;
8274 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8275 sw_if_index_set = 1;
8276 else if (unformat (i, "enable"))
8278 else if (unformat (i, "disable"))
8282 clib_warning ("parse error '%U'", format_unformat_error, i);
8287 if (sw_if_index_set == 0)
8289 errmsg ("missing interface name or sw_if_index");
8293 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8295 mp->sw_if_index = ntohl (sw_if_index);
8296 mp->enable = enable;
8304 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8306 unformat_input_t *i = vam->input;
8307 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8309 u8 sw_if_index_set = 0;
8310 u8 v6_address_set = 0;
8311 ip6_address_t v6address;
8314 /* Parse args required to build the message */
8315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8317 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8318 sw_if_index_set = 1;
8319 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8320 sw_if_index_set = 1;
8321 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8327 if (sw_if_index_set == 0)
8329 errmsg ("missing interface name or sw_if_index");
8332 if (!v6_address_set)
8334 errmsg ("no address set");
8338 /* Construct the API message */
8339 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8341 mp->sw_if_index = ntohl (sw_if_index);
8342 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8347 /* Wait for a reply, return good/bad news */
8353 api_ip6nd_proxy_add_del (vat_main_t * vam)
8355 unformat_input_t *i = vam->input;
8356 vl_api_ip6nd_proxy_add_del_t *mp;
8357 u32 sw_if_index = ~0;
8358 u8 v6_address_set = 0;
8359 ip6_address_t v6address;
8363 /* Parse args required to build the message */
8364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8366 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8370 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8372 if (unformat (i, "del"))
8376 clib_warning ("parse error '%U'", format_unformat_error, i);
8381 if (sw_if_index == ~0)
8383 errmsg ("missing interface name or sw_if_index");
8386 if (!v6_address_set)
8388 errmsg ("no address set");
8392 /* Construct the API message */
8393 M (IP6ND_PROXY_ADD_DEL, mp);
8395 mp->is_del = is_del;
8396 mp->sw_if_index = ntohl (sw_if_index);
8397 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8402 /* Wait for a reply, return good/bad news */
8408 api_ip6nd_proxy_dump (vat_main_t * vam)
8410 vl_api_ip6nd_proxy_dump_t *mp;
8411 vl_api_control_ping_t *mp_ping;
8414 M (IP6ND_PROXY_DUMP, mp);
8418 /* Use a control ping for synchronization */
8419 M (CONTROL_PING, mp_ping);
8426 static void vl_api_ip6nd_proxy_details_t_handler
8427 (vl_api_ip6nd_proxy_details_t * mp)
8429 vat_main_t *vam = &vat_main;
8431 print (vam->ofp, "host %U sw_if_index %d",
8432 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
8435 static void vl_api_ip6nd_proxy_details_t_handler_json
8436 (vl_api_ip6nd_proxy_details_t * mp)
8438 vat_main_t *vam = &vat_main;
8439 struct in6_addr ip6;
8440 vat_json_node_t *node = NULL;
8442 if (VAT_JSON_ARRAY != vam->json_tree.type)
8444 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8445 vat_json_init_array (&vam->json_tree);
8447 node = vat_json_array_add (&vam->json_tree);
8449 vat_json_init_object (node);
8450 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8452 clib_memcpy (&ip6, mp->address, sizeof (ip6));
8453 vat_json_object_add_ip6 (node, "host", ip6);
8457 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8459 unformat_input_t *i = vam->input;
8460 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8462 u8 sw_if_index_set = 0;
8463 u32 address_length = 0;
8464 u8 v6_address_set = 0;
8465 ip6_address_t v6address;
8467 u8 no_advertise = 0;
8469 u8 no_autoconfig = 0;
8472 u32 val_lifetime = 0;
8473 u32 pref_lifetime = 0;
8476 /* Parse args required to build the message */
8477 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8479 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8480 sw_if_index_set = 1;
8481 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8482 sw_if_index_set = 1;
8483 else if (unformat (i, "%U/%d",
8484 unformat_ip6_address, &v6address, &address_length))
8486 else if (unformat (i, "val_life %d", &val_lifetime))
8488 else if (unformat (i, "pref_life %d", &pref_lifetime))
8490 else if (unformat (i, "def"))
8492 else if (unformat (i, "noadv"))
8494 else if (unformat (i, "offl"))
8496 else if (unformat (i, "noauto"))
8498 else if (unformat (i, "nolink"))
8500 else if (unformat (i, "isno"))
8504 clib_warning ("parse error '%U'", format_unformat_error, i);
8509 if (sw_if_index_set == 0)
8511 errmsg ("missing interface name or sw_if_index");
8514 if (!v6_address_set)
8516 errmsg ("no address set");
8520 /* Construct the API message */
8521 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8523 mp->sw_if_index = ntohl (sw_if_index);
8524 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8525 mp->address_length = address_length;
8526 mp->use_default = use_default;
8527 mp->no_advertise = no_advertise;
8528 mp->off_link = off_link;
8529 mp->no_autoconfig = no_autoconfig;
8530 mp->no_onlink = no_onlink;
8532 mp->val_lifetime = ntohl (val_lifetime);
8533 mp->pref_lifetime = ntohl (pref_lifetime);
8538 /* Wait for a reply, return good/bad news */
8544 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8546 unformat_input_t *i = vam->input;
8547 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8549 u8 sw_if_index_set = 0;
8554 u8 send_unicast = 0;
8557 u8 default_router = 0;
8558 u32 max_interval = 0;
8559 u32 min_interval = 0;
8561 u32 initial_count = 0;
8562 u32 initial_interval = 0;
8566 /* Parse args required to build the message */
8567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8569 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8570 sw_if_index_set = 1;
8571 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8572 sw_if_index_set = 1;
8573 else if (unformat (i, "maxint %d", &max_interval))
8575 else if (unformat (i, "minint %d", &min_interval))
8577 else if (unformat (i, "life %d", &lifetime))
8579 else if (unformat (i, "count %d", &initial_count))
8581 else if (unformat (i, "interval %d", &initial_interval))
8583 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8585 else if (unformat (i, "managed"))
8587 else if (unformat (i, "other"))
8589 else if (unformat (i, "ll"))
8591 else if (unformat (i, "send"))
8593 else if (unformat (i, "cease"))
8595 else if (unformat (i, "isno"))
8597 else if (unformat (i, "def"))
8601 clib_warning ("parse error '%U'", format_unformat_error, i);
8606 if (sw_if_index_set == 0)
8608 errmsg ("missing interface name or sw_if_index");
8612 /* Construct the API message */
8613 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8615 mp->sw_if_index = ntohl (sw_if_index);
8616 mp->max_interval = ntohl (max_interval);
8617 mp->min_interval = ntohl (min_interval);
8618 mp->lifetime = ntohl (lifetime);
8619 mp->initial_count = ntohl (initial_count);
8620 mp->initial_interval = ntohl (initial_interval);
8621 mp->suppress = suppress;
8622 mp->managed = managed;
8624 mp->ll_option = ll_option;
8625 mp->send_unicast = send_unicast;
8628 mp->default_router = default_router;
8633 /* Wait for a reply, return good/bad news */
8639 api_set_arp_neighbor_limit (vat_main_t * vam)
8641 unformat_input_t *i = vam->input;
8642 vl_api_set_arp_neighbor_limit_t *mp;
8648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8650 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8652 else if (unformat (i, "ipv6"))
8656 clib_warning ("parse error '%U'", format_unformat_error, i);
8663 errmsg ("missing limit value");
8667 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8669 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8670 mp->is_ipv6 = is_ipv6;
8678 api_l2_patch_add_del (vat_main_t * vam)
8680 unformat_input_t *i = vam->input;
8681 vl_api_l2_patch_add_del_t *mp;
8683 u8 rx_sw_if_index_set = 0;
8685 u8 tx_sw_if_index_set = 0;
8689 /* Parse args required to build the message */
8690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8692 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8693 rx_sw_if_index_set = 1;
8694 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8695 tx_sw_if_index_set = 1;
8696 else if (unformat (i, "rx"))
8698 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8700 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8702 rx_sw_if_index_set = 1;
8707 else if (unformat (i, "tx"))
8709 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8711 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8713 tx_sw_if_index_set = 1;
8718 else if (unformat (i, "del"))
8724 if (rx_sw_if_index_set == 0)
8726 errmsg ("missing rx interface name or rx_sw_if_index");
8730 if (tx_sw_if_index_set == 0)
8732 errmsg ("missing tx interface name or tx_sw_if_index");
8736 M (L2_PATCH_ADD_DEL, mp);
8738 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8739 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8740 mp->is_add = is_add;
8748 u8 localsid_addr[16];
8757 api_sr_localsid_add_del (vat_main_t * vam)
8759 unformat_input_t *i = vam->input;
8760 vl_api_sr_localsid_add_del_t *mp;
8763 ip6_address_t localsid;
8767 u32 fib_table = ~(u32) 0;
8768 ip6_address_t next_hop;
8770 bool nexthop_set = 0;
8774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8776 if (unformat (i, "del"))
8778 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
8779 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
8781 else if (unformat (i, "behavior %u", &behavior));
8782 else if (unformat (i, "sw_if_index %u", &sw_if_index));
8783 else if (unformat (i, "fib-table %u", &fib_table));
8784 else if (unformat (i, "end.psp %u", &behavior));
8789 M (SR_LOCALSID_ADD_DEL, mp);
8791 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
8793 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
8794 mp->behavior = behavior;
8795 mp->sw_if_index = ntohl (sw_if_index);
8796 mp->fib_table = ntohl (fib_table);
8797 mp->end_psp = end_psp;
8798 mp->is_del = is_del;
8806 api_ioam_enable (vat_main_t * vam)
8808 unformat_input_t *input = vam->input;
8809 vl_api_ioam_enable_t *mp;
8811 int has_trace_option = 0;
8812 int has_pot_option = 0;
8813 int has_seqno_option = 0;
8814 int has_analyse_option = 0;
8817 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8819 if (unformat (input, "trace"))
8820 has_trace_option = 1;
8821 else if (unformat (input, "pot"))
8823 else if (unformat (input, "seqno"))
8824 has_seqno_option = 1;
8825 else if (unformat (input, "analyse"))
8826 has_analyse_option = 1;
8830 M (IOAM_ENABLE, mp);
8831 mp->id = htons (id);
8832 mp->seqno = has_seqno_option;
8833 mp->analyse = has_analyse_option;
8834 mp->pot_enable = has_pot_option;
8835 mp->trace_enable = has_trace_option;
8844 api_ioam_disable (vat_main_t * vam)
8846 vl_api_ioam_disable_t *mp;
8849 M (IOAM_DISABLE, mp);
8855 #define foreach_tcp_proto_field \
8859 #define foreach_udp_proto_field \
8863 #define foreach_ip4_proto_field \
8875 u16 src_port, dst_port;
8878 #if VPP_API_TEST_BUILTIN == 0
8880 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8882 u8 **maskp = va_arg (*args, u8 **);
8884 u8 found_something = 0;
8887 #define _(a) u8 a=0;
8888 foreach_tcp_proto_field;
8891 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8894 #define _(a) else if (unformat (input, #a)) a=1;
8895 foreach_tcp_proto_field
8901 #define _(a) found_something += a;
8902 foreach_tcp_proto_field;
8905 if (found_something == 0)
8908 vec_validate (mask, sizeof (*tcp) - 1);
8910 tcp = (tcp_header_t *) mask;
8912 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8913 foreach_tcp_proto_field;
8921 unformat_udp_mask (unformat_input_t * input, va_list * args)
8923 u8 **maskp = va_arg (*args, u8 **);
8925 u8 found_something = 0;
8928 #define _(a) u8 a=0;
8929 foreach_udp_proto_field;
8932 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8935 #define _(a) else if (unformat (input, #a)) a=1;
8936 foreach_udp_proto_field
8942 #define _(a) found_something += a;
8943 foreach_udp_proto_field;
8946 if (found_something == 0)
8949 vec_validate (mask, sizeof (*udp) - 1);
8951 udp = (udp_header_t *) mask;
8953 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8954 foreach_udp_proto_field;
8962 unformat_l4_mask (unformat_input_t * input, va_list * args)
8964 u8 **maskp = va_arg (*args, u8 **);
8965 u16 src_port = 0, dst_port = 0;
8966 tcpudp_header_t *tcpudp;
8968 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8970 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8972 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8974 else if (unformat (input, "src_port"))
8976 else if (unformat (input, "dst_port"))
8982 if (!src_port && !dst_port)
8986 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8988 tcpudp = (tcpudp_header_t *) mask;
8989 tcpudp->src_port = src_port;
8990 tcpudp->dst_port = dst_port;
8998 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9000 u8 **maskp = va_arg (*args, u8 **);
9002 u8 found_something = 0;
9005 #define _(a) u8 a=0;
9006 foreach_ip4_proto_field;
9012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9014 if (unformat (input, "version"))
9016 else if (unformat (input, "hdr_length"))
9018 else if (unformat (input, "src"))
9020 else if (unformat (input, "dst"))
9022 else if (unformat (input, "proto"))
9025 #define _(a) else if (unformat (input, #a)) a=1;
9026 foreach_ip4_proto_field
9032 #define _(a) found_something += a;
9033 foreach_ip4_proto_field;
9036 if (found_something == 0)
9039 vec_validate (mask, sizeof (*ip) - 1);
9041 ip = (ip4_header_t *) mask;
9043 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9044 foreach_ip4_proto_field;
9047 ip->ip_version_and_header_length = 0;
9050 ip->ip_version_and_header_length |= 0xF0;
9053 ip->ip_version_and_header_length |= 0x0F;
9059 #define foreach_ip6_proto_field \
9067 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9069 u8 **maskp = va_arg (*args, u8 **);
9071 u8 found_something = 0;
9073 u32 ip_version_traffic_class_and_flow_label;
9075 #define _(a) u8 a=0;
9076 foreach_ip6_proto_field;
9079 u8 traffic_class = 0;
9082 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9084 if (unformat (input, "version"))
9086 else if (unformat (input, "traffic-class"))
9088 else if (unformat (input, "flow-label"))
9090 else if (unformat (input, "src"))
9092 else if (unformat (input, "dst"))
9094 else if (unformat (input, "proto"))
9097 #define _(a) else if (unformat (input, #a)) a=1;
9098 foreach_ip6_proto_field
9104 #define _(a) found_something += a;
9105 foreach_ip6_proto_field;
9108 if (found_something == 0)
9111 vec_validate (mask, sizeof (*ip) - 1);
9113 ip = (ip6_header_t *) mask;
9115 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9116 foreach_ip6_proto_field;
9119 ip_version_traffic_class_and_flow_label = 0;
9122 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9125 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9128 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9130 ip->ip_version_traffic_class_and_flow_label =
9131 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9138 unformat_l3_mask (unformat_input_t * input, va_list * args)
9140 u8 **maskp = va_arg (*args, u8 **);
9142 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9144 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9146 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9155 unformat_l2_mask (unformat_input_t * input, va_list * args)
9157 u8 **maskp = va_arg (*args, u8 **);
9172 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9174 if (unformat (input, "src"))
9176 else if (unformat (input, "dst"))
9178 else if (unformat (input, "proto"))
9180 else if (unformat (input, "tag1"))
9182 else if (unformat (input, "tag2"))
9184 else if (unformat (input, "ignore-tag1"))
9186 else if (unformat (input, "ignore-tag2"))
9188 else if (unformat (input, "cos1"))
9190 else if (unformat (input, "cos2"))
9192 else if (unformat (input, "dot1q"))
9194 else if (unformat (input, "dot1ad"))
9199 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9200 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9203 if (tag1 || ignore_tag1 || cos1 || dot1q)
9205 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9208 vec_validate (mask, len - 1);
9211 memset (mask, 0xff, 6);
9214 memset (mask + 6, 0xff, 6);
9218 /* inner vlan tag */
9227 mask[21] = mask[20] = 0xff;
9248 mask[16] = mask[17] = 0xff;
9258 mask[12] = mask[13] = 0xff;
9265 unformat_classify_mask (unformat_input_t * input, va_list * args)
9267 u8 **maskp = va_arg (*args, u8 **);
9268 u32 *skipp = va_arg (*args, u32 *);
9269 u32 *matchp = va_arg (*args, u32 *);
9277 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9279 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9281 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9283 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9285 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9299 if (mask || l2 || l3 || l4)
9303 /* "With a free Ethernet header in every package" */
9305 vec_validate (l2, 13);
9309 vec_append (mask, l3);
9314 vec_append (mask, l4);
9319 /* Scan forward looking for the first significant mask octet */
9320 for (i = 0; i < vec_len (mask); i++)
9324 /* compute (skip, match) params */
9325 *skipp = i / sizeof (u32x4);
9326 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9328 /* Pad mask to an even multiple of the vector size */
9329 while (vec_len (mask) % sizeof (u32x4))
9332 match = vec_len (mask) / sizeof (u32x4);
9334 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9336 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9337 if (*tmp || *(tmp + 1))
9342 clib_warning ("BUG: match 0");
9344 _vec_len (mask) = match * sizeof (u32x4);
9354 #endif /* VPP_API_TEST_BUILTIN */
9356 #define foreach_l2_next \
9358 _(ethernet, ETHERNET_INPUT) \
9363 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9365 u32 *miss_next_indexp = va_arg (*args, u32 *);
9370 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9374 if (unformat (input, "%d", &tmp))
9383 *miss_next_indexp = next_index;
9387 #define foreach_ip_next \
9393 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9395 u32 *miss_next_indexp = va_arg (*args, u32 *);
9400 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9404 if (unformat (input, "%d", &tmp))
9413 *miss_next_indexp = next_index;
9417 #define foreach_acl_next \
9421 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9423 u32 *miss_next_indexp = va_arg (*args, u32 *);
9428 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9432 if (unformat (input, "permit"))
9437 else if (unformat (input, "%d", &tmp))
9446 *miss_next_indexp = next_index;
9451 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9453 u32 *r = va_arg (*args, u32 *);
9455 if (unformat (input, "conform-color"))
9456 *r = POLICE_CONFORM;
9457 else if (unformat (input, "exceed-color"))
9466 api_classify_add_del_table (vat_main_t * vam)
9468 unformat_input_t *i = vam->input;
9469 vl_api_classify_add_del_table_t *mp;
9476 u32 table_index = ~0;
9477 u32 next_table_index = ~0;
9478 u32 miss_next_index = ~0;
9479 u32 memory_size = 32 << 20;
9481 u32 current_data_flag = 0;
9482 int current_data_offset = 0;
9485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9487 if (unformat (i, "del"))
9489 else if (unformat (i, "del-chain"))
9494 else if (unformat (i, "buckets %d", &nbuckets))
9496 else if (unformat (i, "memory_size %d", &memory_size))
9498 else if (unformat (i, "skip %d", &skip))
9500 else if (unformat (i, "match %d", &match))
9502 else if (unformat (i, "table %d", &table_index))
9504 else if (unformat (i, "mask %U", unformat_classify_mask,
9505 &mask, &skip, &match))
9507 else if (unformat (i, "next-table %d", &next_table_index))
9509 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
9512 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9515 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
9518 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9520 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9526 if (is_add && mask == 0)
9528 errmsg ("Mask required");
9532 if (is_add && skip == ~0)
9534 errmsg ("skip count required");
9538 if (is_add && match == ~0)
9540 errmsg ("match count required");
9544 if (!is_add && table_index == ~0)
9546 errmsg ("table index required for delete");
9550 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9552 mp->is_add = is_add;
9553 mp->del_chain = del_chain;
9554 mp->table_index = ntohl (table_index);
9555 mp->nbuckets = ntohl (nbuckets);
9556 mp->memory_size = ntohl (memory_size);
9557 mp->skip_n_vectors = ntohl (skip);
9558 mp->match_n_vectors = ntohl (match);
9559 mp->next_table_index = ntohl (next_table_index);
9560 mp->miss_next_index = ntohl (miss_next_index);
9561 mp->current_data_flag = ntohl (current_data_flag);
9562 mp->current_data_offset = ntohl (current_data_offset);
9563 clib_memcpy (mp->mask, mask, vec_len (mask));
9572 #if VPP_API_TEST_BUILTIN == 0
9574 unformat_l4_match (unformat_input_t * input, va_list * args)
9576 u8 **matchp = va_arg (*args, u8 **);
9578 u8 *proto_header = 0;
9584 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9586 if (unformat (input, "src_port %d", &src_port))
9588 else if (unformat (input, "dst_port %d", &dst_port))
9594 h.src_port = clib_host_to_net_u16 (src_port);
9595 h.dst_port = clib_host_to_net_u16 (dst_port);
9596 vec_validate (proto_header, sizeof (h) - 1);
9597 memcpy (proto_header, &h, sizeof (h));
9599 *matchp = proto_header;
9605 unformat_ip4_match (unformat_input_t * input, va_list * args)
9607 u8 **matchp = va_arg (*args, u8 **);
9614 int src = 0, dst = 0;
9615 ip4_address_t src_val, dst_val;
9622 int fragment_id = 0;
9623 u32 fragment_id_val;
9629 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9631 if (unformat (input, "version %d", &version_val))
9633 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9635 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9637 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9639 else if (unformat (input, "proto %d", &proto_val))
9641 else if (unformat (input, "tos %d", &tos_val))
9643 else if (unformat (input, "length %d", &length_val))
9645 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9647 else if (unformat (input, "ttl %d", &ttl_val))
9649 else if (unformat (input, "checksum %d", &checksum_val))
9655 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9656 + ttl + checksum == 0)
9660 * Aligned because we use the real comparison functions
9662 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9664 ip = (ip4_header_t *) match;
9666 /* These are realistically matched in practice */
9668 ip->src_address.as_u32 = src_val.as_u32;
9671 ip->dst_address.as_u32 = dst_val.as_u32;
9674 ip->protocol = proto_val;
9677 /* These are not, but they're included for completeness */
9679 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9682 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9688 ip->length = clib_host_to_net_u16 (length_val);
9694 ip->checksum = clib_host_to_net_u16 (checksum_val);
9701 unformat_ip6_match (unformat_input_t * input, va_list * args)
9703 u8 **matchp = va_arg (*args, u8 **);
9708 u8 traffic_class = 0;
9709 u32 traffic_class_val = 0;
9712 int src = 0, dst = 0;
9713 ip6_address_t src_val, dst_val;
9716 int payload_length = 0;
9717 u32 payload_length_val;
9720 u32 ip_version_traffic_class_and_flow_label;
9722 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9724 if (unformat (input, "version %d", &version_val))
9726 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9728 else if (unformat (input, "flow_label %d", &flow_label_val))
9730 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9732 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9734 else if (unformat (input, "proto %d", &proto_val))
9736 else if (unformat (input, "payload_length %d", &payload_length_val))
9738 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9744 if (version + traffic_class + flow_label + src + dst + proto +
9745 payload_length + hop_limit == 0)
9749 * Aligned because we use the real comparison functions
9751 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9753 ip = (ip6_header_t *) match;
9756 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9759 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9762 ip->protocol = proto_val;
9764 ip_version_traffic_class_and_flow_label = 0;
9767 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9770 ip_version_traffic_class_and_flow_label |=
9771 (traffic_class_val & 0xFF) << 20;
9774 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9776 ip->ip_version_traffic_class_and_flow_label =
9777 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9780 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9783 ip->hop_limit = hop_limit_val;
9790 unformat_l3_match (unformat_input_t * input, va_list * args)
9792 u8 **matchp = va_arg (*args, u8 **);
9794 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9796 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9798 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9807 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9809 u8 *tagp = va_arg (*args, u8 *);
9812 if (unformat (input, "%d", &tag))
9814 tagp[0] = (tag >> 8) & 0x0F;
9815 tagp[1] = tag & 0xFF;
9823 unformat_l2_match (unformat_input_t * input, va_list * args)
9825 u8 **matchp = va_arg (*args, u8 **);
9845 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9847 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9850 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9852 else if (unformat (input, "proto %U",
9853 unformat_ethernet_type_host_byte_order, &proto_val))
9855 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9857 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9859 else if (unformat (input, "ignore-tag1"))
9861 else if (unformat (input, "ignore-tag2"))
9863 else if (unformat (input, "cos1 %d", &cos1_val))
9865 else if (unformat (input, "cos2 %d", &cos2_val))
9870 if ((src + dst + proto + tag1 + tag2 +
9871 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9874 if (tag1 || ignore_tag1 || cos1)
9876 if (tag2 || ignore_tag2 || cos2)
9879 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9882 clib_memcpy (match, dst_val, 6);
9885 clib_memcpy (match + 6, src_val, 6);
9889 /* inner vlan tag */
9890 match[19] = tag2_val[1];
9891 match[18] = tag2_val[0];
9893 match[18] |= (cos2_val & 0x7) << 5;
9896 match[21] = proto_val & 0xff;
9897 match[20] = proto_val >> 8;
9901 match[15] = tag1_val[1];
9902 match[14] = tag1_val[0];
9905 match[14] |= (cos1_val & 0x7) << 5;
9911 match[15] = tag1_val[1];
9912 match[14] = tag1_val[0];
9915 match[17] = proto_val & 0xff;
9916 match[16] = proto_val >> 8;
9919 match[14] |= (cos1_val & 0x7) << 5;
9925 match[18] |= (cos2_val & 0x7) << 5;
9927 match[14] |= (cos1_val & 0x7) << 5;
9930 match[13] = proto_val & 0xff;
9931 match[12] = proto_val >> 8;
9940 api_unformat_classify_match (unformat_input_t * input, va_list * args)
9942 u8 **matchp = va_arg (*args, u8 **);
9943 u32 skip_n_vectors = va_arg (*args, u32);
9944 u32 match_n_vectors = va_arg (*args, u32);
9951 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9953 if (unformat (input, "hex %U", unformat_hex_string, &match))
9955 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9957 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9959 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9973 if (match || l2 || l3 || l4)
9977 /* "Win a free Ethernet header in every packet" */
9979 vec_validate_aligned (l2, 13, sizeof (u32x4));
9983 vec_append_aligned (match, l3, sizeof (u32x4));
9988 vec_append_aligned (match, l4, sizeof (u32x4));
9993 /* Make sure the vector is big enough even if key is all 0's */
9994 vec_validate_aligned
9995 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9998 /* Set size, include skipped vectors */
9999 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10010 api_classify_add_del_session (vat_main_t * vam)
10012 unformat_input_t *i = vam->input;
10013 vl_api_classify_add_del_session_t *mp;
10015 u32 table_index = ~0;
10016 u32 hit_next_index = ~0;
10017 u32 opaque_index = ~0;
10020 u32 skip_n_vectors = 0;
10021 u32 match_n_vectors = 0;
10027 * Warning: you have to supply skip_n and match_n
10028 * because the API client cant simply look at the classify
10032 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10034 if (unformat (i, "del"))
10036 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10039 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10042 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10045 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10047 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10049 else if (unformat (i, "opaque-index %d", &opaque_index))
10051 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10053 else if (unformat (i, "match_n %d", &match_n_vectors))
10055 else if (unformat (i, "match %U", api_unformat_classify_match,
10056 &match, skip_n_vectors, match_n_vectors))
10058 else if (unformat (i, "advance %d", &advance))
10060 else if (unformat (i, "table-index %d", &table_index))
10062 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10064 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10066 else if (unformat (i, "action %d", &action))
10068 else if (unformat (i, "metadata %d", &metadata))
10074 if (table_index == ~0)
10076 errmsg ("Table index required");
10080 if (is_add && match == 0)
10082 errmsg ("Match value required");
10086 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10088 mp->is_add = is_add;
10089 mp->table_index = ntohl (table_index);
10090 mp->hit_next_index = ntohl (hit_next_index);
10091 mp->opaque_index = ntohl (opaque_index);
10092 mp->advance = ntohl (advance);
10093 mp->action = action;
10094 mp->metadata = ntohl (metadata);
10095 clib_memcpy (mp->match, match, vec_len (match));
10104 api_classify_set_interface_ip_table (vat_main_t * vam)
10106 unformat_input_t *i = vam->input;
10107 vl_api_classify_set_interface_ip_table_t *mp;
10109 int sw_if_index_set;
10110 u32 table_index = ~0;
10114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10116 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10117 sw_if_index_set = 1;
10118 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10119 sw_if_index_set = 1;
10120 else if (unformat (i, "table %d", &table_index))
10124 clib_warning ("parse error '%U'", format_unformat_error, i);
10129 if (sw_if_index_set == 0)
10131 errmsg ("missing interface name or sw_if_index");
10136 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10138 mp->sw_if_index = ntohl (sw_if_index);
10139 mp->table_index = ntohl (table_index);
10140 mp->is_ipv6 = is_ipv6;
10148 api_classify_set_interface_l2_tables (vat_main_t * vam)
10150 unformat_input_t *i = vam->input;
10151 vl_api_classify_set_interface_l2_tables_t *mp;
10153 int sw_if_index_set;
10154 u32 ip4_table_index = ~0;
10155 u32 ip6_table_index = ~0;
10156 u32 other_table_index = ~0;
10160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10163 sw_if_index_set = 1;
10164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10165 sw_if_index_set = 1;
10166 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10168 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10170 else if (unformat (i, "other-table %d", &other_table_index))
10172 else if (unformat (i, "is-input %d", &is_input))
10176 clib_warning ("parse error '%U'", format_unformat_error, i);
10181 if (sw_if_index_set == 0)
10183 errmsg ("missing interface name or sw_if_index");
10188 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10190 mp->sw_if_index = ntohl (sw_if_index);
10191 mp->ip4_table_index = ntohl (ip4_table_index);
10192 mp->ip6_table_index = ntohl (ip6_table_index);
10193 mp->other_table_index = ntohl (other_table_index);
10194 mp->is_input = (u8) is_input;
10202 api_set_ipfix_exporter (vat_main_t * vam)
10204 unformat_input_t *i = vam->input;
10205 vl_api_set_ipfix_exporter_t *mp;
10206 ip4_address_t collector_address;
10207 u8 collector_address_set = 0;
10208 u32 collector_port = ~0;
10209 ip4_address_t src_address;
10210 u8 src_address_set = 0;
10213 u32 template_interval = ~0;
10214 u8 udp_checksum = 0;
10217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10219 if (unformat (i, "collector_address %U", unformat_ip4_address,
10220 &collector_address))
10221 collector_address_set = 1;
10222 else if (unformat (i, "collector_port %d", &collector_port))
10224 else if (unformat (i, "src_address %U", unformat_ip4_address,
10226 src_address_set = 1;
10227 else if (unformat (i, "vrf_id %d", &vrf_id))
10229 else if (unformat (i, "path_mtu %d", &path_mtu))
10231 else if (unformat (i, "template_interval %d", &template_interval))
10233 else if (unformat (i, "udp_checksum"))
10239 if (collector_address_set == 0)
10241 errmsg ("collector_address required");
10245 if (src_address_set == 0)
10247 errmsg ("src_address required");
10251 M (SET_IPFIX_EXPORTER, mp);
10253 memcpy (mp->collector_address, collector_address.data,
10254 sizeof (collector_address.data));
10255 mp->collector_port = htons ((u16) collector_port);
10256 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10257 mp->vrf_id = htonl (vrf_id);
10258 mp->path_mtu = htonl (path_mtu);
10259 mp->template_interval = htonl (template_interval);
10260 mp->udp_checksum = udp_checksum;
10268 api_set_ipfix_classify_stream (vat_main_t * vam)
10270 unformat_input_t *i = vam->input;
10271 vl_api_set_ipfix_classify_stream_t *mp;
10273 u32 src_port = UDP_DST_PORT_ipfix;
10276 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10278 if (unformat (i, "domain %d", &domain_id))
10280 else if (unformat (i, "src_port %d", &src_port))
10284 errmsg ("unknown input `%U'", format_unformat_error, i);
10289 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10291 mp->domain_id = htonl (domain_id);
10292 mp->src_port = htons ((u16) src_port);
10300 api_ipfix_classify_table_add_del (vat_main_t * vam)
10302 unformat_input_t *i = vam->input;
10303 vl_api_ipfix_classify_table_add_del_t *mp;
10305 u32 classify_table_index = ~0;
10307 u8 transport_protocol = 255;
10310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10312 if (unformat (i, "add"))
10314 else if (unformat (i, "del"))
10316 else if (unformat (i, "table %d", &classify_table_index))
10318 else if (unformat (i, "ip4"))
10320 else if (unformat (i, "ip6"))
10322 else if (unformat (i, "tcp"))
10323 transport_protocol = 6;
10324 else if (unformat (i, "udp"))
10325 transport_protocol = 17;
10328 errmsg ("unknown input `%U'", format_unformat_error, i);
10335 errmsg ("expecting: add|del");
10338 if (classify_table_index == ~0)
10340 errmsg ("classifier table not specified");
10343 if (ip_version == 0)
10345 errmsg ("IP version not specified");
10349 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10351 mp->is_add = is_add;
10352 mp->table_id = htonl (classify_table_index);
10353 mp->ip_version = ip_version;
10354 mp->transport_protocol = transport_protocol;
10362 api_get_node_index (vat_main_t * vam)
10364 unformat_input_t *i = vam->input;
10365 vl_api_get_node_index_t *mp;
10369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10371 if (unformat (i, "node %s", &name))
10378 errmsg ("node name required");
10381 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10383 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10387 M (GET_NODE_INDEX, mp);
10388 clib_memcpy (mp->node_name, name, vec_len (name));
10397 api_get_next_index (vat_main_t * vam)
10399 unformat_input_t *i = vam->input;
10400 vl_api_get_next_index_t *mp;
10401 u8 *node_name = 0, *next_node_name = 0;
10404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10406 if (unformat (i, "node-name %s", &node_name))
10408 else if (unformat (i, "next-node-name %s", &next_node_name))
10412 if (node_name == 0)
10414 errmsg ("node name required");
10417 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10419 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10423 if (next_node_name == 0)
10425 errmsg ("next node name required");
10428 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10430 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10434 M (GET_NEXT_INDEX, mp);
10435 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10436 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10437 vec_free (node_name);
10438 vec_free (next_node_name);
10446 api_add_node_next (vat_main_t * vam)
10448 unformat_input_t *i = vam->input;
10449 vl_api_add_node_next_t *mp;
10454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10456 if (unformat (i, "node %s", &name))
10458 else if (unformat (i, "next %s", &next))
10465 errmsg ("node name required");
10468 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10470 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10475 errmsg ("next node required");
10478 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10480 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10484 M (ADD_NODE_NEXT, mp);
10485 clib_memcpy (mp->node_name, name, vec_len (name));
10486 clib_memcpy (mp->next_name, next, vec_len (next));
10496 api_l2tpv3_create_tunnel (vat_main_t * vam)
10498 unformat_input_t *i = vam->input;
10499 ip6_address_t client_address, our_address;
10500 int client_address_set = 0;
10501 int our_address_set = 0;
10502 u32 local_session_id = 0;
10503 u32 remote_session_id = 0;
10504 u64 local_cookie = 0;
10505 u64 remote_cookie = 0;
10506 u8 l2_sublayer_present = 0;
10507 vl_api_l2tpv3_create_tunnel_t *mp;
10510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10512 if (unformat (i, "client_address %U", unformat_ip6_address,
10514 client_address_set = 1;
10515 else if (unformat (i, "our_address %U", unformat_ip6_address,
10517 our_address_set = 1;
10518 else if (unformat (i, "local_session_id %d", &local_session_id))
10520 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10522 else if (unformat (i, "local_cookie %lld", &local_cookie))
10524 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10526 else if (unformat (i, "l2-sublayer-present"))
10527 l2_sublayer_present = 1;
10532 if (client_address_set == 0)
10534 errmsg ("client_address required");
10538 if (our_address_set == 0)
10540 errmsg ("our_address required");
10544 M (L2TPV3_CREATE_TUNNEL, mp);
10546 clib_memcpy (mp->client_address, client_address.as_u8,
10547 sizeof (mp->client_address));
10549 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10551 mp->local_session_id = ntohl (local_session_id);
10552 mp->remote_session_id = ntohl (remote_session_id);
10553 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10554 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10555 mp->l2_sublayer_present = l2_sublayer_present;
10564 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10566 unformat_input_t *i = vam->input;
10568 u8 sw_if_index_set = 0;
10569 u64 new_local_cookie = 0;
10570 u64 new_remote_cookie = 0;
10571 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10574 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10576 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10577 sw_if_index_set = 1;
10578 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10579 sw_if_index_set = 1;
10580 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10582 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10588 if (sw_if_index_set == 0)
10590 errmsg ("missing interface name or sw_if_index");
10594 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10596 mp->sw_if_index = ntohl (sw_if_index);
10597 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10598 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10606 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10608 unformat_input_t *i = vam->input;
10609 vl_api_l2tpv3_interface_enable_disable_t *mp;
10611 u8 sw_if_index_set = 0;
10612 u8 enable_disable = 1;
10615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10617 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10618 sw_if_index_set = 1;
10619 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10620 sw_if_index_set = 1;
10621 else if (unformat (i, "enable"))
10622 enable_disable = 1;
10623 else if (unformat (i, "disable"))
10624 enable_disable = 0;
10629 if (sw_if_index_set == 0)
10631 errmsg ("missing interface name or sw_if_index");
10635 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10637 mp->sw_if_index = ntohl (sw_if_index);
10638 mp->enable_disable = enable_disable;
10646 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10648 unformat_input_t *i = vam->input;
10649 vl_api_l2tpv3_set_lookup_key_t *mp;
10653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10655 if (unformat (i, "lookup_v6_src"))
10656 key = L2T_LOOKUP_SRC_ADDRESS;
10657 else if (unformat (i, "lookup_v6_dst"))
10658 key = L2T_LOOKUP_DST_ADDRESS;
10659 else if (unformat (i, "lookup_session_id"))
10660 key = L2T_LOOKUP_SESSION_ID;
10665 if (key == (u8) ~ 0)
10667 errmsg ("l2tp session lookup key unset");
10671 M (L2TPV3_SET_LOOKUP_KEY, mp);
10680 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10681 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10683 vat_main_t *vam = &vat_main;
10685 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10686 format_ip6_address, mp->our_address,
10687 format_ip6_address, mp->client_address,
10688 clib_net_to_host_u32 (mp->sw_if_index));
10691 " local cookies %016llx %016llx remote cookie %016llx",
10692 clib_net_to_host_u64 (mp->local_cookie[0]),
10693 clib_net_to_host_u64 (mp->local_cookie[1]),
10694 clib_net_to_host_u64 (mp->remote_cookie));
10696 print (vam->ofp, " local session-id %d remote session-id %d",
10697 clib_net_to_host_u32 (mp->local_session_id),
10698 clib_net_to_host_u32 (mp->remote_session_id));
10700 print (vam->ofp, " l2 specific sublayer %s\n",
10701 mp->l2_sublayer_present ? "preset" : "absent");
10705 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10706 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10708 vat_main_t *vam = &vat_main;
10709 vat_json_node_t *node = NULL;
10710 struct in6_addr addr;
10712 if (VAT_JSON_ARRAY != vam->json_tree.type)
10714 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10715 vat_json_init_array (&vam->json_tree);
10717 node = vat_json_array_add (&vam->json_tree);
10719 vat_json_init_object (node);
10721 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10722 vat_json_object_add_ip6 (node, "our_address", addr);
10723 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10724 vat_json_object_add_ip6 (node, "client_address", addr);
10726 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10727 vat_json_init_array (lc);
10728 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10729 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10730 vat_json_object_add_uint (node, "remote_cookie",
10731 clib_net_to_host_u64 (mp->remote_cookie));
10733 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10734 vat_json_object_add_uint (node, "local_session_id",
10735 clib_net_to_host_u32 (mp->local_session_id));
10736 vat_json_object_add_uint (node, "remote_session_id",
10737 clib_net_to_host_u32 (mp->remote_session_id));
10738 vat_json_object_add_string_copy (node, "l2_sublayer",
10739 mp->l2_sublayer_present ? (u8 *) "present"
10740 : (u8 *) "absent");
10744 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10746 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10747 vl_api_control_ping_t *mp_ping;
10750 /* Get list of l2tpv3-tunnel interfaces */
10751 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10754 /* Use a control ping for synchronization */
10755 M (CONTROL_PING, mp_ping);
10763 static void vl_api_sw_interface_tap_details_t_handler
10764 (vl_api_sw_interface_tap_details_t * mp)
10766 vat_main_t *vam = &vat_main;
10768 print (vam->ofp, "%-16s %d",
10769 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10772 static void vl_api_sw_interface_tap_details_t_handler_json
10773 (vl_api_sw_interface_tap_details_t * mp)
10775 vat_main_t *vam = &vat_main;
10776 vat_json_node_t *node = NULL;
10778 if (VAT_JSON_ARRAY != vam->json_tree.type)
10780 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10781 vat_json_init_array (&vam->json_tree);
10783 node = vat_json_array_add (&vam->json_tree);
10785 vat_json_init_object (node);
10786 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10787 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10791 api_sw_interface_tap_dump (vat_main_t * vam)
10793 vl_api_sw_interface_tap_dump_t *mp;
10794 vl_api_control_ping_t *mp_ping;
10797 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10798 /* Get list of tap interfaces */
10799 M (SW_INTERFACE_TAP_DUMP, mp);
10802 /* Use a control ping for synchronization */
10803 M (CONTROL_PING, mp_ping);
10810 static uword unformat_vxlan_decap_next
10811 (unformat_input_t * input, va_list * args)
10813 u32 *result = va_arg (*args, u32 *);
10816 if (unformat (input, "l2"))
10817 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10818 else if (unformat (input, "%d", &tmp))
10826 api_vxlan_add_del_tunnel (vat_main_t * vam)
10828 unformat_input_t *line_input = vam->input;
10829 vl_api_vxlan_add_del_tunnel_t *mp;
10830 ip46_address_t src, dst;
10832 u8 ipv4_set = 0, ipv6_set = 0;
10836 u32 mcast_sw_if_index = ~0;
10837 u32 encap_vrf_id = 0;
10838 u32 decap_next_index = ~0;
10842 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10843 memset (&src, 0, sizeof src);
10844 memset (&dst, 0, sizeof dst);
10846 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10848 if (unformat (line_input, "del"))
10851 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10857 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10863 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10869 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10874 else if (unformat (line_input, "group %U %U",
10875 unformat_ip4_address, &dst.ip4,
10876 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10878 grp_set = dst_set = 1;
10881 else if (unformat (line_input, "group %U",
10882 unformat_ip4_address, &dst.ip4))
10884 grp_set = dst_set = 1;
10887 else if (unformat (line_input, "group %U %U",
10888 unformat_ip6_address, &dst.ip6,
10889 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10891 grp_set = dst_set = 1;
10894 else if (unformat (line_input, "group %U",
10895 unformat_ip6_address, &dst.ip6))
10897 grp_set = dst_set = 1;
10901 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10903 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10905 else if (unformat (line_input, "decap-next %U",
10906 unformat_vxlan_decap_next, &decap_next_index))
10908 else if (unformat (line_input, "vni %d", &vni))
10912 errmsg ("parse error '%U'", format_unformat_error, line_input);
10919 errmsg ("tunnel src address not specified");
10924 errmsg ("tunnel dst address not specified");
10928 if (grp_set && !ip46_address_is_multicast (&dst))
10930 errmsg ("tunnel group address not multicast");
10933 if (grp_set && mcast_sw_if_index == ~0)
10935 errmsg ("tunnel nonexistent multicast device");
10938 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10940 errmsg ("tunnel dst address must be unicast");
10945 if (ipv4_set && ipv6_set)
10947 errmsg ("both IPv4 and IPv6 addresses specified");
10951 if ((vni == 0) || (vni >> 24))
10953 errmsg ("vni not specified or out of range");
10957 M (VXLAN_ADD_DEL_TUNNEL, mp);
10961 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10962 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10966 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10967 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10969 mp->encap_vrf_id = ntohl (encap_vrf_id);
10970 mp->decap_next_index = ntohl (decap_next_index);
10971 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10972 mp->vni = ntohl (vni);
10973 mp->is_add = is_add;
10974 mp->is_ipv6 = ipv6_set;
10981 static void vl_api_vxlan_tunnel_details_t_handler
10982 (vl_api_vxlan_tunnel_details_t * mp)
10984 vat_main_t *vam = &vat_main;
10985 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
10986 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
10988 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10989 ntohl (mp->sw_if_index),
10990 format_ip46_address, &src, IP46_TYPE_ANY,
10991 format_ip46_address, &dst, IP46_TYPE_ANY,
10992 ntohl (mp->encap_vrf_id),
10993 ntohl (mp->decap_next_index), ntohl (mp->vni),
10994 ntohl (mp->mcast_sw_if_index));
10997 static void vl_api_vxlan_tunnel_details_t_handler_json
10998 (vl_api_vxlan_tunnel_details_t * mp)
11000 vat_main_t *vam = &vat_main;
11001 vat_json_node_t *node = NULL;
11003 if (VAT_JSON_ARRAY != vam->json_tree.type)
11005 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11006 vat_json_init_array (&vam->json_tree);
11008 node = vat_json_array_add (&vam->json_tree);
11010 vat_json_init_object (node);
11011 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11014 struct in6_addr ip6;
11016 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11017 vat_json_object_add_ip6 (node, "src_address", ip6);
11018 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11019 vat_json_object_add_ip6 (node, "dst_address", ip6);
11023 struct in_addr ip4;
11025 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11026 vat_json_object_add_ip4 (node, "src_address", ip4);
11027 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11028 vat_json_object_add_ip4 (node, "dst_address", ip4);
11030 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11031 vat_json_object_add_uint (node, "decap_next_index",
11032 ntohl (mp->decap_next_index));
11033 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11034 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11035 vat_json_object_add_uint (node, "mcast_sw_if_index",
11036 ntohl (mp->mcast_sw_if_index));
11040 api_vxlan_tunnel_dump (vat_main_t * vam)
11042 unformat_input_t *i = vam->input;
11043 vl_api_vxlan_tunnel_dump_t *mp;
11044 vl_api_control_ping_t *mp_ping;
11046 u8 sw_if_index_set = 0;
11049 /* Parse args required to build the message */
11050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11052 if (unformat (i, "sw_if_index %d", &sw_if_index))
11053 sw_if_index_set = 1;
11058 if (sw_if_index_set == 0)
11063 if (!vam->json_output)
11065 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
11066 "sw_if_index", "src_address", "dst_address",
11067 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11070 /* Get list of vxlan-tunnel interfaces */
11071 M (VXLAN_TUNNEL_DUMP, mp);
11073 mp->sw_if_index = htonl (sw_if_index);
11077 /* Use a control ping for synchronization */
11078 M (CONTROL_PING, mp_ping);
11086 api_gre_add_del_tunnel (vat_main_t * vam)
11088 unformat_input_t *line_input = vam->input;
11089 vl_api_gre_add_del_tunnel_t *mp;
11090 ip4_address_t src4, dst4;
11091 ip6_address_t src6, dst6;
11098 u32 outer_fib_id = 0;
11101 memset (&src4, 0, sizeof src4);
11102 memset (&dst4, 0, sizeof dst4);
11103 memset (&src6, 0, sizeof src6);
11104 memset (&dst6, 0, sizeof dst6);
11106 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11108 if (unformat (line_input, "del"))
11110 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
11115 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
11120 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
11125 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
11130 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
11132 else if (unformat (line_input, "teb"))
11136 errmsg ("parse error '%U'", format_unformat_error, line_input);
11143 errmsg ("tunnel src address not specified");
11148 errmsg ("tunnel dst address not specified");
11151 if (ipv4_set && ipv6_set)
11153 errmsg ("both IPv4 and IPv6 addresses specified");
11158 M (GRE_ADD_DEL_TUNNEL, mp);
11162 clib_memcpy (&mp->src_address, &src4, 4);
11163 clib_memcpy (&mp->dst_address, &dst4, 4);
11167 clib_memcpy (&mp->src_address, &src6, 16);
11168 clib_memcpy (&mp->dst_address, &dst6, 16);
11170 mp->outer_fib_id = ntohl (outer_fib_id);
11171 mp->is_add = is_add;
11173 mp->is_ipv6 = ipv6_set;
11180 static void vl_api_gre_tunnel_details_t_handler
11181 (vl_api_gre_tunnel_details_t * mp)
11183 vat_main_t *vam = &vat_main;
11184 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
11185 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
11187 print (vam->ofp, "%11d%24U%24U%6d%14d",
11188 ntohl (mp->sw_if_index),
11189 format_ip46_address, &src, IP46_TYPE_ANY,
11190 format_ip46_address, &dst, IP46_TYPE_ANY,
11191 mp->teb, ntohl (mp->outer_fib_id));
11194 static void vl_api_gre_tunnel_details_t_handler_json
11195 (vl_api_gre_tunnel_details_t * mp)
11197 vat_main_t *vam = &vat_main;
11198 vat_json_node_t *node = NULL;
11199 struct in_addr ip4;
11200 struct in6_addr ip6;
11202 if (VAT_JSON_ARRAY != vam->json_tree.type)
11204 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11205 vat_json_init_array (&vam->json_tree);
11207 node = vat_json_array_add (&vam->json_tree);
11209 vat_json_init_object (node);
11210 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11213 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11214 vat_json_object_add_ip4 (node, "src_address", ip4);
11215 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11216 vat_json_object_add_ip4 (node, "dst_address", ip4);
11220 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
11221 vat_json_object_add_ip6 (node, "src_address", ip6);
11222 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
11223 vat_json_object_add_ip6 (node, "dst_address", ip6);
11225 vat_json_object_add_uint (node, "teb", mp->teb);
11226 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11227 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
11231 api_gre_tunnel_dump (vat_main_t * vam)
11233 unformat_input_t *i = vam->input;
11234 vl_api_gre_tunnel_dump_t *mp;
11235 vl_api_control_ping_t *mp_ping;
11237 u8 sw_if_index_set = 0;
11240 /* Parse args required to build the message */
11241 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11243 if (unformat (i, "sw_if_index %d", &sw_if_index))
11244 sw_if_index_set = 1;
11249 if (sw_if_index_set == 0)
11254 if (!vam->json_output)
11256 print (vam->ofp, "%11s%24s%24s%6s%14s",
11257 "sw_if_index", "src_address", "dst_address", "teb",
11261 /* Get list of gre-tunnel interfaces */
11262 M (GRE_TUNNEL_DUMP, mp);
11264 mp->sw_if_index = htonl (sw_if_index);
11268 /* Use a control ping for synchronization */
11269 M (CONTROL_PING, mp_ping);
11277 api_l2_fib_clear_table (vat_main_t * vam)
11279 // unformat_input_t * i = vam->input;
11280 vl_api_l2_fib_clear_table_t *mp;
11283 M (L2_FIB_CLEAR_TABLE, mp);
11291 api_l2_interface_efp_filter (vat_main_t * vam)
11293 unformat_input_t *i = vam->input;
11294 vl_api_l2_interface_efp_filter_t *mp;
11297 u8 sw_if_index_set = 0;
11300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11302 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11303 sw_if_index_set = 1;
11304 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11305 sw_if_index_set = 1;
11306 else if (unformat (i, "enable"))
11308 else if (unformat (i, "disable"))
11312 clib_warning ("parse error '%U'", format_unformat_error, i);
11317 if (sw_if_index_set == 0)
11319 errmsg ("missing sw_if_index");
11323 M (L2_INTERFACE_EFP_FILTER, mp);
11325 mp->sw_if_index = ntohl (sw_if_index);
11326 mp->enable_disable = enable;
11333 #define foreach_vtr_op \
11334 _("disable", L2_VTR_DISABLED) \
11335 _("push-1", L2_VTR_PUSH_1) \
11336 _("push-2", L2_VTR_PUSH_2) \
11337 _("pop-1", L2_VTR_POP_1) \
11338 _("pop-2", L2_VTR_POP_2) \
11339 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11340 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11341 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11342 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11345 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11347 unformat_input_t *i = vam->input;
11348 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11350 u8 sw_if_index_set = 0;
11353 u32 push_dot1q = 1;
11358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11360 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11361 sw_if_index_set = 1;
11362 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11363 sw_if_index_set = 1;
11364 else if (unformat (i, "vtr_op %d", &vtr_op))
11366 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11369 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11371 else if (unformat (i, "tag1 %d", &tag1))
11373 else if (unformat (i, "tag2 %d", &tag2))
11377 clib_warning ("parse error '%U'", format_unformat_error, i);
11382 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11384 errmsg ("missing vtr operation or sw_if_index");
11388 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11389 mp->sw_if_index = ntohl (sw_if_index);
11390 mp->vtr_op = ntohl (vtr_op);
11391 mp->push_dot1q = ntohl (push_dot1q);
11392 mp->tag1 = ntohl (tag1);
11393 mp->tag2 = ntohl (tag2);
11401 api_create_vhost_user_if (vat_main_t * vam)
11403 unformat_input_t *i = vam->input;
11404 vl_api_create_vhost_user_if_t *mp;
11407 u8 file_name_set = 0;
11408 u32 custom_dev_instance = ~0;
11410 u8 use_custom_mac = 0;
11413 u8 operation_mode = VHOST_USER_POLLING_MODE;
11415 /* Shut up coverity */
11416 memset (hwaddr, 0, sizeof (hwaddr));
11418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11420 if (unformat (i, "socket %s", &file_name))
11424 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11426 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11427 use_custom_mac = 1;
11428 else if (unformat (i, "server"))
11430 else if (unformat (i, "tag %s", &tag))
11432 else if (unformat (i, "mode %U",
11433 api_unformat_vhost_user_operation_mode,
11440 if (file_name_set == 0)
11442 errmsg ("missing socket file name");
11446 if (vec_len (file_name) > 255)
11448 errmsg ("socket file name too long");
11451 vec_add1 (file_name, 0);
11453 M (CREATE_VHOST_USER_IF, mp);
11455 mp->operation_mode = operation_mode;
11456 mp->is_server = is_server;
11457 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11458 vec_free (file_name);
11459 if (custom_dev_instance != ~0)
11462 mp->custom_dev_instance = ntohl (custom_dev_instance);
11464 mp->use_custom_mac = use_custom_mac;
11465 clib_memcpy (mp->mac_address, hwaddr, 6);
11467 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11476 api_modify_vhost_user_if (vat_main_t * vam)
11478 unformat_input_t *i = vam->input;
11479 vl_api_modify_vhost_user_if_t *mp;
11482 u8 file_name_set = 0;
11483 u32 custom_dev_instance = ~0;
11484 u8 sw_if_index_set = 0;
11485 u32 sw_if_index = (u32) ~ 0;
11487 u8 operation_mode = VHOST_USER_POLLING_MODE;
11489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11491 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11492 sw_if_index_set = 1;
11493 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11494 sw_if_index_set = 1;
11495 else if (unformat (i, "socket %s", &file_name))
11499 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11501 else if (unformat (i, "server"))
11503 else if (unformat (i, "mode %U",
11504 api_unformat_vhost_user_operation_mode,
11511 if (sw_if_index_set == 0)
11513 errmsg ("missing sw_if_index or interface name");
11517 if (file_name_set == 0)
11519 errmsg ("missing socket file name");
11523 if (vec_len (file_name) > 255)
11525 errmsg ("socket file name too long");
11528 vec_add1 (file_name, 0);
11530 M (MODIFY_VHOST_USER_IF, mp);
11532 mp->operation_mode = operation_mode;
11533 mp->sw_if_index = ntohl (sw_if_index);
11534 mp->is_server = is_server;
11535 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11536 vec_free (file_name);
11537 if (custom_dev_instance != ~0)
11540 mp->custom_dev_instance = ntohl (custom_dev_instance);
11549 api_delete_vhost_user_if (vat_main_t * vam)
11551 unformat_input_t *i = vam->input;
11552 vl_api_delete_vhost_user_if_t *mp;
11553 u32 sw_if_index = ~0;
11554 u8 sw_if_index_set = 0;
11557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11559 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11560 sw_if_index_set = 1;
11561 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11562 sw_if_index_set = 1;
11567 if (sw_if_index_set == 0)
11569 errmsg ("missing sw_if_index or interface name");
11574 M (DELETE_VHOST_USER_IF, mp);
11576 mp->sw_if_index = ntohl (sw_if_index);
11583 static void vl_api_sw_interface_vhost_user_details_t_handler
11584 (vl_api_sw_interface_vhost_user_details_t * mp)
11586 vat_main_t *vam = &vat_main;
11588 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %U %s",
11589 (char *) mp->interface_name,
11590 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11591 clib_net_to_host_u64 (mp->features), mp->is_server,
11592 ntohl (mp->num_regions), api_format_vhost_user_operation_mode,
11593 mp->operation_mode, (char *) mp->sock_filename);
11594 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11597 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11598 (vl_api_sw_interface_vhost_user_details_t * mp)
11600 vat_main_t *vam = &vat_main;
11601 vat_json_node_t *node = NULL;
11603 if (VAT_JSON_ARRAY != vam->json_tree.type)
11605 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11606 vat_json_init_array (&vam->json_tree);
11608 node = vat_json_array_add (&vam->json_tree);
11610 vat_json_init_object (node);
11611 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11612 vat_json_object_add_string_copy (node, "interface_name",
11613 mp->interface_name);
11614 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11615 ntohl (mp->virtio_net_hdr_sz));
11616 vat_json_object_add_uint (node, "features",
11617 clib_net_to_host_u64 (mp->features));
11618 vat_json_object_add_uint (node, "is_server", mp->is_server);
11619 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11620 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11621 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11622 vat_json_object_add_uint (node, "mode", mp->operation_mode);
11626 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11628 vl_api_sw_interface_vhost_user_dump_t *mp;
11629 vl_api_control_ping_t *mp_ping;
11632 "Interface name idx hdr_sz features server regions mode"
11635 /* Get list of vhost-user interfaces */
11636 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11639 /* Use a control ping for synchronization */
11640 M (CONTROL_PING, mp_ping);
11648 api_show_version (vat_main_t * vam)
11650 vl_api_show_version_t *mp;
11653 M (SHOW_VERSION, mp);
11662 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11664 unformat_input_t *line_input = vam->input;
11665 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11666 ip4_address_t local4, remote4;
11667 ip6_address_t local6, remote6;
11669 u8 ipv4_set = 0, ipv6_set = 0;
11672 u32 encap_vrf_id = 0;
11673 u32 decap_vrf_id = 0;
11679 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11681 if (unformat (line_input, "del"))
11683 else if (unformat (line_input, "local %U",
11684 unformat_ip4_address, &local4))
11689 else if (unformat (line_input, "remote %U",
11690 unformat_ip4_address, &remote4))
11695 else if (unformat (line_input, "local %U",
11696 unformat_ip6_address, &local6))
11701 else if (unformat (line_input, "remote %U",
11702 unformat_ip6_address, &remote6))
11707 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11709 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11711 else if (unformat (line_input, "vni %d", &vni))
11713 else if (unformat (line_input, "next-ip4"))
11715 else if (unformat (line_input, "next-ip6"))
11717 else if (unformat (line_input, "next-ethernet"))
11719 else if (unformat (line_input, "next-nsh"))
11723 errmsg ("parse error '%U'", format_unformat_error, line_input);
11728 if (local_set == 0)
11730 errmsg ("tunnel local address not specified");
11733 if (remote_set == 0)
11735 errmsg ("tunnel remote address not specified");
11738 if (ipv4_set && ipv6_set)
11740 errmsg ("both IPv4 and IPv6 addresses specified");
11746 errmsg ("vni not specified");
11750 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11755 clib_memcpy (&mp->local, &local6, sizeof (local6));
11756 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11760 clib_memcpy (&mp->local, &local4, sizeof (local4));
11761 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11764 mp->encap_vrf_id = ntohl (encap_vrf_id);
11765 mp->decap_vrf_id = ntohl (decap_vrf_id);
11766 mp->protocol = protocol;
11767 mp->vni = ntohl (vni);
11768 mp->is_add = is_add;
11769 mp->is_ipv6 = ipv6_set;
11776 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11777 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11779 vat_main_t *vam = &vat_main;
11781 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11782 ntohl (mp->sw_if_index),
11783 format_ip46_address, &(mp->local[0]),
11784 format_ip46_address, &(mp->remote[0]),
11786 ntohl (mp->protocol),
11787 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11790 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11791 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11793 vat_main_t *vam = &vat_main;
11794 vat_json_node_t *node = NULL;
11795 struct in_addr ip4;
11796 struct in6_addr ip6;
11798 if (VAT_JSON_ARRAY != vam->json_tree.type)
11800 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11801 vat_json_init_array (&vam->json_tree);
11803 node = vat_json_array_add (&vam->json_tree);
11805 vat_json_init_object (node);
11806 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11809 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11810 vat_json_object_add_ip6 (node, "local", ip6);
11811 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11812 vat_json_object_add_ip6 (node, "remote", ip6);
11816 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11817 vat_json_object_add_ip4 (node, "local", ip4);
11818 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11819 vat_json_object_add_ip4 (node, "remote", ip4);
11821 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11822 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11823 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11824 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11825 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11829 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11831 unformat_input_t *i = vam->input;
11832 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11833 vl_api_control_ping_t *mp_ping;
11835 u8 sw_if_index_set = 0;
11838 /* Parse args required to build the message */
11839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11841 if (unformat (i, "sw_if_index %d", &sw_if_index))
11842 sw_if_index_set = 1;
11847 if (sw_if_index_set == 0)
11852 if (!vam->json_output)
11854 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11855 "sw_if_index", "local", "remote", "vni",
11856 "protocol", "encap_vrf_id", "decap_vrf_id");
11859 /* Get list of vxlan-tunnel interfaces */
11860 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11862 mp->sw_if_index = htonl (sw_if_index);
11866 /* Use a control ping for synchronization */
11867 M (CONTROL_PING, mp_ping);
11875 format_l2_fib_mac_address (u8 * s, va_list * args)
11877 u8 *a = va_arg (*args, u8 *);
11879 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11880 a[2], a[3], a[4], a[5], a[6], a[7]);
11883 static void vl_api_l2_fib_table_entry_t_handler
11884 (vl_api_l2_fib_table_entry_t * mp)
11886 vat_main_t *vam = &vat_main;
11888 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11890 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11891 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11895 static void vl_api_l2_fib_table_entry_t_handler_json
11896 (vl_api_l2_fib_table_entry_t * mp)
11898 vat_main_t *vam = &vat_main;
11899 vat_json_node_t *node = NULL;
11901 if (VAT_JSON_ARRAY != vam->json_tree.type)
11903 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11904 vat_json_init_array (&vam->json_tree);
11906 node = vat_json_array_add (&vam->json_tree);
11908 vat_json_init_object (node);
11909 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11910 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11911 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11912 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11913 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11914 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11918 api_l2_fib_table_dump (vat_main_t * vam)
11920 unformat_input_t *i = vam->input;
11921 vl_api_l2_fib_table_dump_t *mp;
11922 vl_api_control_ping_t *mp_ping;
11927 /* Parse args required to build the message */
11928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11930 if (unformat (i, "bd_id %d", &bd_id))
11936 if (bd_id_set == 0)
11938 errmsg ("missing bridge domain");
11942 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11944 /* Get list of l2 fib entries */
11945 M (L2_FIB_TABLE_DUMP, mp);
11947 mp->bd_id = ntohl (bd_id);
11950 /* Use a control ping for synchronization */
11951 M (CONTROL_PING, mp_ping);
11960 api_interface_name_renumber (vat_main_t * vam)
11962 unformat_input_t *line_input = vam->input;
11963 vl_api_interface_name_renumber_t *mp;
11964 u32 sw_if_index = ~0;
11965 u32 new_show_dev_instance = ~0;
11968 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11970 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11973 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11975 else if (unformat (line_input, "new_show_dev_instance %d",
11976 &new_show_dev_instance))
11982 if (sw_if_index == ~0)
11984 errmsg ("missing interface name or sw_if_index");
11988 if (new_show_dev_instance == ~0)
11990 errmsg ("missing new_show_dev_instance");
11994 M (INTERFACE_NAME_RENUMBER, mp);
11996 mp->sw_if_index = ntohl (sw_if_index);
11997 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
12005 api_want_ip4_arp_events (vat_main_t * vam)
12007 unformat_input_t *line_input = vam->input;
12008 vl_api_want_ip4_arp_events_t *mp;
12009 ip4_address_t address;
12010 int address_set = 0;
12011 u32 enable_disable = 1;
12014 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12016 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
12018 else if (unformat (line_input, "del"))
12019 enable_disable = 0;
12024 if (address_set == 0)
12026 errmsg ("missing addresses");
12030 M (WANT_IP4_ARP_EVENTS, mp);
12031 mp->enable_disable = enable_disable;
12032 mp->pid = htonl (getpid ());
12033 mp->address = address.as_u32;
12041 api_want_ip6_nd_events (vat_main_t * vam)
12043 unformat_input_t *line_input = vam->input;
12044 vl_api_want_ip6_nd_events_t *mp;
12045 ip6_address_t address;
12046 int address_set = 0;
12047 u32 enable_disable = 1;
12050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12052 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
12054 else if (unformat (line_input, "del"))
12055 enable_disable = 0;
12060 if (address_set == 0)
12062 errmsg ("missing addresses");
12066 M (WANT_IP6_ND_EVENTS, mp);
12067 mp->enable_disable = enable_disable;
12068 mp->pid = htonl (getpid ());
12069 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
12077 api_input_acl_set_interface (vat_main_t * vam)
12079 unformat_input_t *i = vam->input;
12080 vl_api_input_acl_set_interface_t *mp;
12082 int sw_if_index_set;
12083 u32 ip4_table_index = ~0;
12084 u32 ip6_table_index = ~0;
12085 u32 l2_table_index = ~0;
12089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12091 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12092 sw_if_index_set = 1;
12093 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12094 sw_if_index_set = 1;
12095 else if (unformat (i, "del"))
12097 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12099 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12101 else if (unformat (i, "l2-table %d", &l2_table_index))
12105 clib_warning ("parse error '%U'", format_unformat_error, i);
12110 if (sw_if_index_set == 0)
12112 errmsg ("missing interface name or sw_if_index");
12116 M (INPUT_ACL_SET_INTERFACE, mp);
12118 mp->sw_if_index = ntohl (sw_if_index);
12119 mp->ip4_table_index = ntohl (ip4_table_index);
12120 mp->ip6_table_index = ntohl (ip6_table_index);
12121 mp->l2_table_index = ntohl (l2_table_index);
12122 mp->is_add = is_add;
12130 api_ip_address_dump (vat_main_t * vam)
12132 unformat_input_t *i = vam->input;
12133 vl_api_ip_address_dump_t *mp;
12134 vl_api_control_ping_t *mp_ping;
12135 u32 sw_if_index = ~0;
12136 u8 sw_if_index_set = 0;
12141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12143 if (unformat (i, "sw_if_index %d", &sw_if_index))
12144 sw_if_index_set = 1;
12146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12147 sw_if_index_set = 1;
12148 else if (unformat (i, "ipv4"))
12150 else if (unformat (i, "ipv6"))
12156 if (ipv4_set && ipv6_set)
12158 errmsg ("ipv4 and ipv6 flags cannot be both set");
12162 if ((!ipv4_set) && (!ipv6_set))
12164 errmsg ("no ipv4 nor ipv6 flag set");
12168 if (sw_if_index_set == 0)
12170 errmsg ("missing interface name or sw_if_index");
12174 vam->current_sw_if_index = sw_if_index;
12175 vam->is_ipv6 = ipv6_set;
12177 M (IP_ADDRESS_DUMP, mp);
12178 mp->sw_if_index = ntohl (sw_if_index);
12179 mp->is_ipv6 = ipv6_set;
12182 /* Use a control ping for synchronization */
12183 M (CONTROL_PING, mp_ping);
12191 api_ip_dump (vat_main_t * vam)
12193 vl_api_ip_dump_t *mp;
12194 vl_api_control_ping_t *mp_ping;
12195 unformat_input_t *in = vam->input;
12202 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
12204 if (unformat (in, "ipv4"))
12206 else if (unformat (in, "ipv6"))
12212 if (ipv4_set && ipv6_set)
12214 errmsg ("ipv4 and ipv6 flags cannot be both set");
12218 if ((!ipv4_set) && (!ipv6_set))
12220 errmsg ("no ipv4 nor ipv6 flag set");
12224 is_ipv6 = ipv6_set;
12225 vam->is_ipv6 = is_ipv6;
12227 /* free old data */
12228 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12230 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12232 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12235 mp->is_ipv6 = ipv6_set;
12238 /* Use a control ping for synchronization */
12239 M (CONTROL_PING, mp_ping);
12247 api_ipsec_spd_add_del (vat_main_t * vam)
12249 unformat_input_t *i = vam->input;
12250 vl_api_ipsec_spd_add_del_t *mp;
12255 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12257 if (unformat (i, "spd_id %d", &spd_id))
12259 else if (unformat (i, "del"))
12263 clib_warning ("parse error '%U'", format_unformat_error, i);
12269 errmsg ("spd_id must be set");
12273 M (IPSEC_SPD_ADD_DEL, mp);
12275 mp->spd_id = ntohl (spd_id);
12276 mp->is_add = is_add;
12284 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12286 unformat_input_t *i = vam->input;
12287 vl_api_ipsec_interface_add_del_spd_t *mp;
12289 u8 sw_if_index_set = 0;
12290 u32 spd_id = (u32) ~ 0;
12294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12296 if (unformat (i, "del"))
12298 else if (unformat (i, "spd_id %d", &spd_id))
12301 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12302 sw_if_index_set = 1;
12303 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12304 sw_if_index_set = 1;
12307 clib_warning ("parse error '%U'", format_unformat_error, i);
12313 if (spd_id == (u32) ~ 0)
12315 errmsg ("spd_id must be set");
12319 if (sw_if_index_set == 0)
12321 errmsg ("missing interface name or sw_if_index");
12325 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12327 mp->spd_id = ntohl (spd_id);
12328 mp->sw_if_index = ntohl (sw_if_index);
12329 mp->is_add = is_add;
12337 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12339 unformat_input_t *i = vam->input;
12340 vl_api_ipsec_spd_add_del_entry_t *mp;
12341 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12342 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12344 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12345 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12346 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12347 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12350 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12351 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12352 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12353 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12354 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12355 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12359 if (unformat (i, "del"))
12361 if (unformat (i, "outbound"))
12363 if (unformat (i, "inbound"))
12365 else if (unformat (i, "spd_id %d", &spd_id))
12367 else if (unformat (i, "sa_id %d", &sa_id))
12369 else if (unformat (i, "priority %d", &priority))
12371 else if (unformat (i, "protocol %d", &protocol))
12373 else if (unformat (i, "lport_start %d", &lport_start))
12375 else if (unformat (i, "lport_stop %d", &lport_stop))
12377 else if (unformat (i, "rport_start %d", &rport_start))
12379 else if (unformat (i, "rport_stop %d", &rport_stop))
12383 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12389 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12396 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12402 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12409 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12415 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12422 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12428 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12434 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12436 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12438 clib_warning ("unsupported action: 'resolve'");
12444 clib_warning ("parse error '%U'", format_unformat_error, i);
12450 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12452 mp->spd_id = ntohl (spd_id);
12453 mp->priority = ntohl (priority);
12454 mp->is_outbound = is_outbound;
12456 mp->is_ipv6 = is_ipv6;
12457 if (is_ipv6 || is_ip_any)
12459 clib_memcpy (mp->remote_address_start, &raddr6_start,
12460 sizeof (ip6_address_t));
12461 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12462 sizeof (ip6_address_t));
12463 clib_memcpy (mp->local_address_start, &laddr6_start,
12464 sizeof (ip6_address_t));
12465 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12466 sizeof (ip6_address_t));
12470 clib_memcpy (mp->remote_address_start, &raddr4_start,
12471 sizeof (ip4_address_t));
12472 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12473 sizeof (ip4_address_t));
12474 clib_memcpy (mp->local_address_start, &laddr4_start,
12475 sizeof (ip4_address_t));
12476 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12477 sizeof (ip4_address_t));
12479 mp->protocol = (u8) protocol;
12480 mp->local_port_start = ntohs ((u16) lport_start);
12481 mp->local_port_stop = ntohs ((u16) lport_stop);
12482 mp->remote_port_start = ntohs ((u16) rport_start);
12483 mp->remote_port_stop = ntohs ((u16) rport_stop);
12484 mp->policy = (u8) policy;
12485 mp->sa_id = ntohl (sa_id);
12486 mp->is_add = is_add;
12487 mp->is_ip_any = is_ip_any;
12494 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12496 unformat_input_t *i = vam->input;
12497 vl_api_ipsec_sad_add_del_entry_t *mp;
12498 u32 sad_id = 0, spi = 0;
12499 u8 *ck = 0, *ik = 0;
12502 u8 protocol = IPSEC_PROTOCOL_AH;
12503 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12504 u32 crypto_alg = 0, integ_alg = 0;
12505 ip4_address_t tun_src4;
12506 ip4_address_t tun_dst4;
12507 ip6_address_t tun_src6;
12508 ip6_address_t tun_dst6;
12511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12513 if (unformat (i, "del"))
12515 else if (unformat (i, "sad_id %d", &sad_id))
12517 else if (unformat (i, "spi %d", &spi))
12519 else if (unformat (i, "esp"))
12520 protocol = IPSEC_PROTOCOL_ESP;
12521 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12524 is_tunnel_ipv6 = 0;
12526 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12529 is_tunnel_ipv6 = 0;
12531 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12534 is_tunnel_ipv6 = 1;
12536 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12539 is_tunnel_ipv6 = 1;
12543 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12545 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12546 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12548 clib_warning ("unsupported crypto-alg: '%U'",
12549 format_ipsec_crypto_alg, crypto_alg);
12553 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12557 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12559 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12560 integ_alg >= IPSEC_INTEG_N_ALG)
12562 clib_warning ("unsupported integ-alg: '%U'",
12563 format_ipsec_integ_alg, integ_alg);
12567 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12571 clib_warning ("parse error '%U'", format_unformat_error, i);
12577 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12579 mp->sad_id = ntohl (sad_id);
12580 mp->is_add = is_add;
12581 mp->protocol = protocol;
12582 mp->spi = ntohl (spi);
12583 mp->is_tunnel = is_tunnel;
12584 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12585 mp->crypto_algorithm = crypto_alg;
12586 mp->integrity_algorithm = integ_alg;
12587 mp->crypto_key_length = vec_len (ck);
12588 mp->integrity_key_length = vec_len (ik);
12590 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12591 mp->crypto_key_length = sizeof (mp->crypto_key);
12593 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12594 mp->integrity_key_length = sizeof (mp->integrity_key);
12597 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12599 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12603 if (is_tunnel_ipv6)
12605 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12606 sizeof (ip6_address_t));
12607 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12608 sizeof (ip6_address_t));
12612 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12613 sizeof (ip4_address_t));
12614 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12615 sizeof (ip4_address_t));
12625 api_ipsec_sa_set_key (vat_main_t * vam)
12627 unformat_input_t *i = vam->input;
12628 vl_api_ipsec_sa_set_key_t *mp;
12630 u8 *ck = 0, *ik = 0;
12633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12635 if (unformat (i, "sa_id %d", &sa_id))
12637 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12639 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12643 clib_warning ("parse error '%U'", format_unformat_error, i);
12648 M (IPSEC_SA_SET_KEY, mp);
12650 mp->sa_id = ntohl (sa_id);
12651 mp->crypto_key_length = vec_len (ck);
12652 mp->integrity_key_length = vec_len (ik);
12654 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12655 mp->crypto_key_length = sizeof (mp->crypto_key);
12657 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12658 mp->integrity_key_length = sizeof (mp->integrity_key);
12661 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12663 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12671 api_ikev2_profile_add_del (vat_main_t * vam)
12673 unformat_input_t *i = vam->input;
12674 vl_api_ikev2_profile_add_del_t *mp;
12679 const char *valid_chars = "a-zA-Z0-9_";
12681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12683 if (unformat (i, "del"))
12685 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12686 vec_add1 (name, 0);
12689 errmsg ("parse error '%U'", format_unformat_error, i);
12694 if (!vec_len (name))
12696 errmsg ("profile name must be specified");
12700 if (vec_len (name) > 64)
12702 errmsg ("profile name too long");
12706 M (IKEV2_PROFILE_ADD_DEL, mp);
12708 clib_memcpy (mp->name, name, vec_len (name));
12709 mp->is_add = is_add;
12718 api_ikev2_profile_set_auth (vat_main_t * vam)
12720 unformat_input_t *i = vam->input;
12721 vl_api_ikev2_profile_set_auth_t *mp;
12724 u32 auth_method = 0;
12728 const char *valid_chars = "a-zA-Z0-9_";
12730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12732 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12733 vec_add1 (name, 0);
12734 else if (unformat (i, "auth_method %U",
12735 unformat_ikev2_auth_method, &auth_method))
12737 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12739 else if (unformat (i, "auth_data %v", &data))
12743 errmsg ("parse error '%U'", format_unformat_error, i);
12748 if (!vec_len (name))
12750 errmsg ("profile name must be specified");
12754 if (vec_len (name) > 64)
12756 errmsg ("profile name too long");
12760 if (!vec_len (data))
12762 errmsg ("auth_data must be specified");
12768 errmsg ("auth_method must be specified");
12772 M (IKEV2_PROFILE_SET_AUTH, mp);
12774 mp->is_hex = is_hex;
12775 mp->auth_method = (u8) auth_method;
12776 mp->data_len = vec_len (data);
12777 clib_memcpy (mp->name, name, vec_len (name));
12778 clib_memcpy (mp->data, data, vec_len (data));
12788 api_ikev2_profile_set_id (vat_main_t * vam)
12790 unformat_input_t *i = vam->input;
12791 vl_api_ikev2_profile_set_id_t *mp;
12799 const char *valid_chars = "a-zA-Z0-9_";
12801 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12803 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12804 vec_add1 (name, 0);
12805 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12807 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12809 data = vec_new (u8, 4);
12810 clib_memcpy (data, ip4.as_u8, 4);
12812 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12814 else if (unformat (i, "id_data %v", &data))
12816 else if (unformat (i, "local"))
12818 else if (unformat (i, "remote"))
12822 errmsg ("parse error '%U'", format_unformat_error, i);
12827 if (!vec_len (name))
12829 errmsg ("profile name must be specified");
12833 if (vec_len (name) > 64)
12835 errmsg ("profile name too long");
12839 if (!vec_len (data))
12841 errmsg ("id_data must be specified");
12847 errmsg ("id_type must be specified");
12851 M (IKEV2_PROFILE_SET_ID, mp);
12853 mp->is_local = is_local;
12854 mp->id_type = (u8) id_type;
12855 mp->data_len = vec_len (data);
12856 clib_memcpy (mp->name, name, vec_len (name));
12857 clib_memcpy (mp->data, data, vec_len (data));
12867 api_ikev2_profile_set_ts (vat_main_t * vam)
12869 unformat_input_t *i = vam->input;
12870 vl_api_ikev2_profile_set_ts_t *mp;
12873 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12874 ip4_address_t start_addr, end_addr;
12876 const char *valid_chars = "a-zA-Z0-9_";
12879 start_addr.as_u32 = 0;
12880 end_addr.as_u32 = (u32) ~ 0;
12882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12884 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12885 vec_add1 (name, 0);
12886 else if (unformat (i, "protocol %d", &proto))
12888 else if (unformat (i, "start_port %d", &start_port))
12890 else if (unformat (i, "end_port %d", &end_port))
12893 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12895 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12897 else if (unformat (i, "local"))
12899 else if (unformat (i, "remote"))
12903 errmsg ("parse error '%U'", format_unformat_error, i);
12908 if (!vec_len (name))
12910 errmsg ("profile name must be specified");
12914 if (vec_len (name) > 64)
12916 errmsg ("profile name too long");
12920 M (IKEV2_PROFILE_SET_TS, mp);
12922 mp->is_local = is_local;
12923 mp->proto = (u8) proto;
12924 mp->start_port = (u16) start_port;
12925 mp->end_port = (u16) end_port;
12926 mp->start_addr = start_addr.as_u32;
12927 mp->end_addr = end_addr.as_u32;
12928 clib_memcpy (mp->name, name, vec_len (name));
12937 api_ikev2_set_local_key (vat_main_t * vam)
12939 unformat_input_t *i = vam->input;
12940 vl_api_ikev2_set_local_key_t *mp;
12944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12946 if (unformat (i, "file %v", &file))
12947 vec_add1 (file, 0);
12950 errmsg ("parse error '%U'", format_unformat_error, i);
12955 if (!vec_len (file))
12957 errmsg ("RSA key file must be specified");
12961 if (vec_len (file) > 256)
12963 errmsg ("file name too long");
12967 M (IKEV2_SET_LOCAL_KEY, mp);
12969 clib_memcpy (mp->key_file, file, vec_len (file));
12978 api_ikev2_set_responder (vat_main_t * vam)
12980 unformat_input_t *i = vam->input;
12981 vl_api_ikev2_set_responder_t *mp;
12984 u32 sw_if_index = ~0;
12985 ip4_address_t address;
12987 const char *valid_chars = "a-zA-Z0-9_";
12989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12992 (i, "%U interface %d address %U", unformat_token, valid_chars,
12993 &name, &sw_if_index, unformat_ip4_address, &address))
12994 vec_add1 (name, 0);
12997 errmsg ("parse error '%U'", format_unformat_error, i);
13002 if (!vec_len (name))
13004 errmsg ("profile name must be specified");
13008 if (vec_len (name) > 64)
13010 errmsg ("profile name too long");
13014 M (IKEV2_SET_RESPONDER, mp);
13016 clib_memcpy (mp->name, name, vec_len (name));
13019 mp->sw_if_index = sw_if_index;
13020 clib_memcpy (mp->address, &address, sizeof (address));
13028 api_ikev2_set_ike_transforms (vat_main_t * vam)
13030 unformat_input_t *i = vam->input;
13031 vl_api_ikev2_set_ike_transforms_t *mp;
13034 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13036 const char *valid_chars = "a-zA-Z0-9_";
13038 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13040 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13041 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13042 vec_add1 (name, 0);
13045 errmsg ("parse error '%U'", format_unformat_error, i);
13050 if (!vec_len (name))
13052 errmsg ("profile name must be specified");
13056 if (vec_len (name) > 64)
13058 errmsg ("profile name too long");
13062 M (IKEV2_SET_IKE_TRANSFORMS, mp);
13064 clib_memcpy (mp->name, name, vec_len (name));
13066 mp->crypto_alg = crypto_alg;
13067 mp->crypto_key_size = crypto_key_size;
13068 mp->integ_alg = integ_alg;
13069 mp->dh_group = dh_group;
13078 api_ikev2_set_esp_transforms (vat_main_t * vam)
13080 unformat_input_t *i = vam->input;
13081 vl_api_ikev2_set_esp_transforms_t *mp;
13084 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13086 const char *valid_chars = "a-zA-Z0-9_";
13088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13090 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13091 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13092 vec_add1 (name, 0);
13095 errmsg ("parse error '%U'", format_unformat_error, i);
13100 if (!vec_len (name))
13102 errmsg ("profile name must be specified");
13106 if (vec_len (name) > 64)
13108 errmsg ("profile name too long");
13112 M (IKEV2_SET_ESP_TRANSFORMS, mp);
13114 clib_memcpy (mp->name, name, vec_len (name));
13116 mp->crypto_alg = crypto_alg;
13117 mp->crypto_key_size = crypto_key_size;
13118 mp->integ_alg = integ_alg;
13119 mp->dh_group = dh_group;
13127 api_ikev2_set_sa_lifetime (vat_main_t * vam)
13129 unformat_input_t *i = vam->input;
13130 vl_api_ikev2_set_sa_lifetime_t *mp;
13133 u64 lifetime, lifetime_maxdata;
13134 u32 lifetime_jitter, handover;
13136 const char *valid_chars = "a-zA-Z0-9_";
13138 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13140 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
13141 &lifetime, &lifetime_jitter, &handover,
13142 &lifetime_maxdata))
13143 vec_add1 (name, 0);
13146 errmsg ("parse error '%U'", format_unformat_error, i);
13151 if (!vec_len (name))
13153 errmsg ("profile name must be specified");
13157 if (vec_len (name) > 64)
13159 errmsg ("profile name too long");
13163 M (IKEV2_SET_SA_LIFETIME, mp);
13165 clib_memcpy (mp->name, name, vec_len (name));
13167 mp->lifetime = lifetime;
13168 mp->lifetime_jitter = lifetime_jitter;
13169 mp->handover = handover;
13170 mp->lifetime_maxdata = lifetime_maxdata;
13178 api_ikev2_initiate_sa_init (vat_main_t * vam)
13180 unformat_input_t *i = vam->input;
13181 vl_api_ikev2_initiate_sa_init_t *mp;
13185 const char *valid_chars = "a-zA-Z0-9_";
13187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13189 if (unformat (i, "%U", unformat_token, valid_chars, &name))
13190 vec_add1 (name, 0);
13193 errmsg ("parse error '%U'", format_unformat_error, i);
13198 if (!vec_len (name))
13200 errmsg ("profile name must be specified");
13204 if (vec_len (name) > 64)
13206 errmsg ("profile name too long");
13210 M (IKEV2_INITIATE_SA_INIT, mp);
13212 clib_memcpy (mp->name, name, vec_len (name));
13221 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
13223 unformat_input_t *i = vam->input;
13224 vl_api_ikev2_initiate_del_ike_sa_t *mp;
13229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13231 if (unformat (i, "%lx", &ispi))
13235 errmsg ("parse error '%U'", format_unformat_error, i);
13240 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
13250 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
13252 unformat_input_t *i = vam->input;
13253 vl_api_ikev2_initiate_del_child_sa_t *mp;
13258 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13260 if (unformat (i, "%x", &ispi))
13264 errmsg ("parse error '%U'", format_unformat_error, i);
13269 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
13279 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
13281 unformat_input_t *i = vam->input;
13282 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
13287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13289 if (unformat (i, "%x", &ispi))
13293 errmsg ("parse error '%U'", format_unformat_error, i);
13298 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
13311 api_map_add_domain (vat_main_t * vam)
13313 unformat_input_t *i = vam->input;
13314 vl_api_map_add_domain_t *mp;
13316 ip4_address_t ip4_prefix;
13317 ip6_address_t ip6_prefix;
13318 ip6_address_t ip6_src;
13319 u32 num_m_args = 0;
13320 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
13321 0, psid_length = 0;
13322 u8 is_translation = 0;
13324 u32 ip6_src_len = 128;
13327 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13329 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
13330 &ip4_prefix, &ip4_prefix_len))
13332 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
13333 &ip6_prefix, &ip6_prefix_len))
13337 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
13340 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
13342 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
13344 else if (unformat (i, "psid-offset %d", &psid_offset))
13346 else if (unformat (i, "psid-len %d", &psid_length))
13348 else if (unformat (i, "mtu %d", &mtu))
13350 else if (unformat (i, "map-t"))
13351 is_translation = 1;
13354 clib_warning ("parse error '%U'", format_unformat_error, i);
13359 if (num_m_args < 3)
13361 errmsg ("mandatory argument(s) missing");
13365 /* Construct the API message */
13366 M (MAP_ADD_DOMAIN, mp);
13368 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
13369 mp->ip4_prefix_len = ip4_prefix_len;
13371 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
13372 mp->ip6_prefix_len = ip6_prefix_len;
13374 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
13375 mp->ip6_src_prefix_len = ip6_src_len;
13377 mp->ea_bits_len = ea_bits_len;
13378 mp->psid_offset = psid_offset;
13379 mp->psid_length = psid_length;
13380 mp->is_translation = is_translation;
13381 mp->mtu = htons (mtu);
13386 /* Wait for a reply, return good/bad news */
13392 api_map_del_domain (vat_main_t * vam)
13394 unformat_input_t *i = vam->input;
13395 vl_api_map_del_domain_t *mp;
13397 u32 num_m_args = 0;
13401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13403 if (unformat (i, "index %d", &index))
13407 clib_warning ("parse error '%U'", format_unformat_error, i);
13412 if (num_m_args != 1)
13414 errmsg ("mandatory argument(s) missing");
13418 /* Construct the API message */
13419 M (MAP_DEL_DOMAIN, mp);
13421 mp->index = ntohl (index);
13426 /* Wait for a reply, return good/bad news */
13432 api_map_add_del_rule (vat_main_t * vam)
13434 unformat_input_t *i = vam->input;
13435 vl_api_map_add_del_rule_t *mp;
13437 ip6_address_t ip6_dst;
13438 u32 num_m_args = 0, index, psid = 0;
13441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13443 if (unformat (i, "index %d", &index))
13445 else if (unformat (i, "psid %d", &psid))
13447 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
13449 else if (unformat (i, "del"))
13455 clib_warning ("parse error '%U'", format_unformat_error, i);
13460 /* Construct the API message */
13461 M (MAP_ADD_DEL_RULE, mp);
13463 mp->index = ntohl (index);
13464 mp->is_add = is_add;
13465 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
13466 mp->psid = ntohs (psid);
13471 /* Wait for a reply, return good/bad news */
13477 api_map_domain_dump (vat_main_t * vam)
13479 vl_api_map_domain_dump_t *mp;
13480 vl_api_control_ping_t *mp_ping;
13483 /* Construct the API message */
13484 M (MAP_DOMAIN_DUMP, mp);
13489 /* Use a control ping for synchronization */
13490 M (CONTROL_PING, mp_ping);
13498 api_map_rule_dump (vat_main_t * vam)
13500 unformat_input_t *i = vam->input;
13501 vl_api_map_rule_dump_t *mp;
13502 vl_api_control_ping_t *mp_ping;
13503 u32 domain_index = ~0;
13506 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13508 if (unformat (i, "index %u", &domain_index))
13514 if (domain_index == ~0)
13516 clib_warning ("parse error: domain index expected");
13520 /* Construct the API message */
13521 M (MAP_RULE_DUMP, mp);
13523 mp->domain_index = htonl (domain_index);
13528 /* Use a control ping for synchronization */
13529 M (CONTROL_PING, mp_ping);
13536 static void vl_api_map_add_domain_reply_t_handler
13537 (vl_api_map_add_domain_reply_t * mp)
13539 vat_main_t *vam = &vat_main;
13540 i32 retval = ntohl (mp->retval);
13542 if (vam->async_mode)
13544 vam->async_errors += (retval < 0);
13548 vam->retval = retval;
13549 vam->result_ready = 1;
13553 static void vl_api_map_add_domain_reply_t_handler_json
13554 (vl_api_map_add_domain_reply_t * mp)
13556 vat_main_t *vam = &vat_main;
13557 vat_json_node_t node;
13559 vat_json_init_object (&node);
13560 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13561 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13563 vat_json_print (vam->ofp, &node);
13564 vat_json_free (&node);
13566 vam->retval = ntohl (mp->retval);
13567 vam->result_ready = 1;
13571 api_get_first_msg_id (vat_main_t * vam)
13573 vl_api_get_first_msg_id_t *mp;
13574 unformat_input_t *i = vam->input;
13579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13581 if (unformat (i, "client %s", &name))
13589 errmsg ("missing client name");
13592 vec_add1 (name, 0);
13594 if (vec_len (name) > 63)
13596 errmsg ("client name too long");
13600 M (GET_FIRST_MSG_ID, mp);
13601 clib_memcpy (mp->name, name, vec_len (name));
13608 api_cop_interface_enable_disable (vat_main_t * vam)
13610 unformat_input_t *line_input = vam->input;
13611 vl_api_cop_interface_enable_disable_t *mp;
13612 u32 sw_if_index = ~0;
13613 u8 enable_disable = 1;
13616 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13618 if (unformat (line_input, "disable"))
13619 enable_disable = 0;
13620 if (unformat (line_input, "enable"))
13621 enable_disable = 1;
13622 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13623 vam, &sw_if_index))
13625 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13631 if (sw_if_index == ~0)
13633 errmsg ("missing interface name or sw_if_index");
13637 /* Construct the API message */
13638 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13639 mp->sw_if_index = ntohl (sw_if_index);
13640 mp->enable_disable = enable_disable;
13644 /* Wait for the reply */
13650 api_cop_whitelist_enable_disable (vat_main_t * vam)
13652 unformat_input_t *line_input = vam->input;
13653 vl_api_cop_whitelist_enable_disable_t *mp;
13654 u32 sw_if_index = ~0;
13655 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13659 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13661 if (unformat (line_input, "ip4"))
13663 else if (unformat (line_input, "ip6"))
13665 else if (unformat (line_input, "default"))
13667 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13668 vam, &sw_if_index))
13670 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13672 else if (unformat (line_input, "fib-id %d", &fib_id))
13678 if (sw_if_index == ~0)
13680 errmsg ("missing interface name or sw_if_index");
13684 /* Construct the API message */
13685 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13686 mp->sw_if_index = ntohl (sw_if_index);
13687 mp->fib_id = ntohl (fib_id);
13690 mp->default_cop = default_cop;
13694 /* Wait for the reply */
13700 api_get_node_graph (vat_main_t * vam)
13702 vl_api_get_node_graph_t *mp;
13705 M (GET_NODE_GRAPH, mp);
13709 /* Wait for the reply */
13715 /** Used for parsing LISP eids */
13716 typedef CLIB_PACKED(struct{
13717 u8 addr[16]; /**< eid address */
13718 u32 len; /**< prefix length if IP */
13719 u8 type; /**< type of eid */
13724 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13726 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13728 memset (a, 0, sizeof (a[0]));
13730 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13732 a->type = 0; /* ipv4 type */
13734 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13736 a->type = 1; /* ipv6 type */
13738 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13740 a->type = 2; /* mac type */
13747 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13756 lisp_eid_size_vat (u8 type)
13771 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13773 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13777 api_one_add_del_locator_set (vat_main_t * vam)
13779 unformat_input_t *input = vam->input;
13780 vl_api_one_add_del_locator_set_t *mp;
13782 u8 *locator_set_name = NULL;
13783 u8 locator_set_name_set = 0;
13784 vl_api_local_locator_t locator, *locators = 0;
13785 u32 sw_if_index, priority, weight;
13789 /* Parse args required to build the message */
13790 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13792 if (unformat (input, "del"))
13796 else if (unformat (input, "locator-set %s", &locator_set_name))
13798 locator_set_name_set = 1;
13800 else if (unformat (input, "sw_if_index %u p %u w %u",
13801 &sw_if_index, &priority, &weight))
13803 locator.sw_if_index = htonl (sw_if_index);
13804 locator.priority = priority;
13805 locator.weight = weight;
13806 vec_add1 (locators, locator);
13810 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13811 &sw_if_index, &priority, &weight))
13813 locator.sw_if_index = htonl (sw_if_index);
13814 locator.priority = priority;
13815 locator.weight = weight;
13816 vec_add1 (locators, locator);
13822 if (locator_set_name_set == 0)
13824 errmsg ("missing locator-set name");
13825 vec_free (locators);
13829 if (vec_len (locator_set_name) > 64)
13831 errmsg ("locator-set name too long");
13832 vec_free (locator_set_name);
13833 vec_free (locators);
13836 vec_add1 (locator_set_name, 0);
13838 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13840 /* Construct the API message */
13841 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
13843 mp->is_add = is_add;
13844 clib_memcpy (mp->locator_set_name, locator_set_name,
13845 vec_len (locator_set_name));
13846 vec_free (locator_set_name);
13848 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13850 clib_memcpy (mp->locators, locators, data_len);
13851 vec_free (locators);
13856 /* Wait for a reply... */
13861 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
13864 api_one_add_del_locator (vat_main_t * vam)
13866 unformat_input_t *input = vam->input;
13867 vl_api_one_add_del_locator_t *mp;
13868 u32 tmp_if_index = ~0;
13869 u32 sw_if_index = ~0;
13870 u8 sw_if_index_set = 0;
13871 u8 sw_if_index_if_name_set = 0;
13873 u8 priority_set = 0;
13877 u8 *locator_set_name = NULL;
13878 u8 locator_set_name_set = 0;
13881 /* Parse args required to build the message */
13882 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13884 if (unformat (input, "del"))
13888 else if (unformat (input, "locator-set %s", &locator_set_name))
13890 locator_set_name_set = 1;
13892 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13895 sw_if_index_if_name_set = 1;
13896 sw_if_index = tmp_if_index;
13898 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13900 sw_if_index_set = 1;
13901 sw_if_index = tmp_if_index;
13903 else if (unformat (input, "p %d", &priority))
13907 else if (unformat (input, "w %d", &weight))
13915 if (locator_set_name_set == 0)
13917 errmsg ("missing locator-set name");
13921 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13923 errmsg ("missing sw_if_index");
13924 vec_free (locator_set_name);
13928 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13930 errmsg ("cannot use both params interface name and sw_if_index");
13931 vec_free (locator_set_name);
13935 if (priority_set == 0)
13937 errmsg ("missing locator-set priority");
13938 vec_free (locator_set_name);
13942 if (weight_set == 0)
13944 errmsg ("missing locator-set weight");
13945 vec_free (locator_set_name);
13949 if (vec_len (locator_set_name) > 64)
13951 errmsg ("locator-set name too long");
13952 vec_free (locator_set_name);
13955 vec_add1 (locator_set_name, 0);
13957 /* Construct the API message */
13958 M (ONE_ADD_DEL_LOCATOR, mp);
13960 mp->is_add = is_add;
13961 mp->sw_if_index = ntohl (sw_if_index);
13962 mp->priority = priority;
13963 mp->weight = weight;
13964 clib_memcpy (mp->locator_set_name, locator_set_name,
13965 vec_len (locator_set_name));
13966 vec_free (locator_set_name);
13971 /* Wait for a reply... */
13976 #define api_lisp_add_del_locator api_one_add_del_locator
13979 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13981 u32 *key_id = va_arg (*args, u32 *);
13984 if (unformat (input, "%s", &s))
13986 if (!strcmp ((char *) s, "sha1"))
13987 key_id[0] = HMAC_SHA_1_96;
13988 else if (!strcmp ((char *) s, "sha256"))
13989 key_id[0] = HMAC_SHA_256_128;
13992 clib_warning ("invalid key_id: '%s'", s);
13993 key_id[0] = HMAC_NO_KEY;
14004 api_one_add_del_local_eid (vat_main_t * vam)
14006 unformat_input_t *input = vam->input;
14007 vl_api_one_add_del_local_eid_t *mp;
14010 lisp_eid_vat_t _eid, *eid = &_eid;
14011 u8 *locator_set_name = 0;
14012 u8 locator_set_name_set = 0;
14018 /* Parse args required to build the message */
14019 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14021 if (unformat (input, "del"))
14025 else if (unformat (input, "vni %d", &vni))
14029 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14033 else if (unformat (input, "locator-set %s", &locator_set_name))
14035 locator_set_name_set = 1;
14037 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14039 else if (unformat (input, "secret-key %_%v%_", &key))
14045 if (locator_set_name_set == 0)
14047 errmsg ("missing locator-set name");
14053 errmsg ("EID address not set!");
14054 vec_free (locator_set_name);
14058 if (key && (0 == key_id))
14060 errmsg ("invalid key_id!");
14064 if (vec_len (key) > 64)
14066 errmsg ("key too long");
14071 if (vec_len (locator_set_name) > 64)
14073 errmsg ("locator-set name too long");
14074 vec_free (locator_set_name);
14077 vec_add1 (locator_set_name, 0);
14079 /* Construct the API message */
14080 M (ONE_ADD_DEL_LOCAL_EID, mp);
14082 mp->is_add = is_add;
14083 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14084 mp->eid_type = eid->type;
14085 mp->prefix_len = eid->len;
14086 mp->vni = clib_host_to_net_u32 (vni);
14087 mp->key_id = clib_host_to_net_u16 (key_id);
14088 clib_memcpy (mp->locator_set_name, locator_set_name,
14089 vec_len (locator_set_name));
14090 clib_memcpy (mp->key, key, vec_len (key));
14092 vec_free (locator_set_name);
14098 /* Wait for a reply... */
14103 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14106 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14108 u32 dp_table = 0, vni = 0;;
14109 unformat_input_t *input = vam->input;
14110 vl_api_gpe_add_del_fwd_entry_t *mp;
14112 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14113 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14114 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14115 u32 action = ~0, w;
14116 ip4_address_t rmt_rloc4, lcl_rloc4;
14117 ip6_address_t rmt_rloc6, lcl_rloc6;
14118 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14121 memset (&rloc, 0, sizeof (rloc));
14123 /* Parse args required to build the message */
14124 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14126 if (unformat (input, "del"))
14128 else if (unformat (input, "add"))
14130 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14134 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14138 else if (unformat (input, "vrf %d", &dp_table))
14140 else if (unformat (input, "bd %d", &dp_table))
14142 else if (unformat (input, "vni %d", &vni))
14144 else if (unformat (input, "w %d", &w))
14148 errmsg ("No RLOC configured for setting priority/weight!");
14151 curr_rloc->weight = w;
14153 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14154 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14158 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14160 vec_add1 (lcl_locs, rloc);
14162 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14163 vec_add1 (rmt_locs, rloc);
14164 /* weight saved in rmt loc */
14165 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14167 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14168 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14171 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14173 vec_add1 (lcl_locs, rloc);
14175 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14176 vec_add1 (rmt_locs, rloc);
14177 /* weight saved in rmt loc */
14178 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14180 else if (unformat (input, "action %d", &action))
14186 clib_warning ("parse error '%U'", format_unformat_error, input);
14193 errmsg ("remote eid addresses not set");
14197 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14199 errmsg ("eid types don't match");
14203 if (0 == rmt_locs && (u32) ~ 0 == action)
14205 errmsg ("action not set for negative mapping");
14209 /* Construct the API message */
14210 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14211 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14213 mp->is_add = is_add;
14214 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14215 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14216 mp->eid_type = rmt_eid->type;
14217 mp->dp_table = clib_host_to_net_u32 (dp_table);
14218 mp->vni = clib_host_to_net_u32 (vni);
14219 mp->rmt_len = rmt_eid->len;
14220 mp->lcl_len = lcl_eid->len;
14221 mp->action = action;
14223 if (0 != rmt_locs && 0 != lcl_locs)
14225 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14226 clib_memcpy (mp->locs, lcl_locs,
14227 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14229 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14230 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14231 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14233 vec_free (lcl_locs);
14234 vec_free (rmt_locs);
14239 /* Wait for a reply... */
14245 api_one_add_del_map_server (vat_main_t * vam)
14247 unformat_input_t *input = vam->input;
14248 vl_api_one_add_del_map_server_t *mp;
14252 ip4_address_t ipv4;
14253 ip6_address_t ipv6;
14256 /* Parse args required to build the message */
14257 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14259 if (unformat (input, "del"))
14263 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14267 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14275 if (ipv4_set && ipv6_set)
14277 errmsg ("both eid v4 and v6 addresses set");
14281 if (!ipv4_set && !ipv6_set)
14283 errmsg ("eid addresses not set");
14287 /* Construct the API message */
14288 M (ONE_ADD_DEL_MAP_SERVER, mp);
14290 mp->is_add = is_add;
14294 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14299 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14305 /* Wait for a reply... */
14310 #define api_lisp_add_del_map_server api_one_add_del_map_server
14313 api_one_add_del_map_resolver (vat_main_t * vam)
14315 unformat_input_t *input = vam->input;
14316 vl_api_one_add_del_map_resolver_t *mp;
14320 ip4_address_t ipv4;
14321 ip6_address_t ipv6;
14324 /* Parse args required to build the message */
14325 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14327 if (unformat (input, "del"))
14331 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14335 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14343 if (ipv4_set && ipv6_set)
14345 errmsg ("both eid v4 and v6 addresses set");
14349 if (!ipv4_set && !ipv6_set)
14351 errmsg ("eid addresses not set");
14355 /* Construct the API message */
14356 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14358 mp->is_add = is_add;
14362 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14367 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14373 /* Wait for a reply... */
14378 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14381 api_lisp_gpe_enable_disable (vat_main_t * vam)
14383 unformat_input_t *input = vam->input;
14384 vl_api_gpe_enable_disable_t *mp;
14389 /* Parse args required to build the message */
14390 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14392 if (unformat (input, "enable"))
14397 else if (unformat (input, "disable"))
14408 errmsg ("Value not set");
14412 /* Construct the API message */
14413 M (GPE_ENABLE_DISABLE, mp);
14420 /* Wait for a reply... */
14426 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14428 unformat_input_t *input = vam->input;
14429 vl_api_one_rloc_probe_enable_disable_t *mp;
14434 /* Parse args required to build the message */
14435 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14437 if (unformat (input, "enable"))
14442 else if (unformat (input, "disable"))
14450 errmsg ("Value not set");
14454 /* Construct the API message */
14455 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14457 mp->is_enabled = is_en;
14462 /* Wait for a reply... */
14467 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14470 api_one_map_register_enable_disable (vat_main_t * vam)
14472 unformat_input_t *input = vam->input;
14473 vl_api_one_map_register_enable_disable_t *mp;
14478 /* Parse args required to build the message */
14479 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14481 if (unformat (input, "enable"))
14486 else if (unformat (input, "disable"))
14494 errmsg ("Value not set");
14498 /* Construct the API message */
14499 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14501 mp->is_enabled = is_en;
14506 /* Wait for a reply... */
14511 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14514 api_one_enable_disable (vat_main_t * vam)
14516 unformat_input_t *input = vam->input;
14517 vl_api_one_enable_disable_t *mp;
14522 /* Parse args required to build the message */
14523 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14525 if (unformat (input, "enable"))
14530 else if (unformat (input, "disable"))
14540 errmsg ("Value not set");
14544 /* Construct the API message */
14545 M (ONE_ENABLE_DISABLE, mp);
14552 /* Wait for a reply... */
14557 #define api_lisp_enable_disable api_one_enable_disable
14560 api_show_one_map_register_state (vat_main_t * vam)
14562 vl_api_show_one_map_register_state_t *mp;
14565 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
14570 /* wait for reply */
14575 #define api_show_lisp_map_register_state api_show_one_map_register_state
14578 api_show_one_rloc_probe_state (vat_main_t * vam)
14580 vl_api_show_one_rloc_probe_state_t *mp;
14583 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
14588 /* wait for reply */
14593 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
14596 api_one_stats_enable_disable (vat_main_t * vam)
14598 vl_api_one_stats_enable_disable_t *mp;
14599 unformat_input_t *input = vam->input;
14604 /* Parse args required to build the message */
14605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14607 if (unformat (input, "enable"))
14612 else if (unformat (input, "disable"))
14622 errmsg ("Value not set");
14626 M (ONE_STATS_ENABLE_DISABLE, mp);
14632 /* wait for reply */
14638 api_show_one_stats_enable_disable (vat_main_t * vam)
14640 vl_api_show_one_stats_enable_disable_t *mp;
14643 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
14648 /* wait for reply */
14654 api_show_one_map_request_mode (vat_main_t * vam)
14656 vl_api_show_one_map_request_mode_t *mp;
14659 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
14664 /* wait for reply */
14669 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
14672 api_one_map_request_mode (vat_main_t * vam)
14674 unformat_input_t *input = vam->input;
14675 vl_api_one_map_request_mode_t *mp;
14679 /* Parse args required to build the message */
14680 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14682 if (unformat (input, "dst-only"))
14684 else if (unformat (input, "src-dst"))
14688 errmsg ("parse error '%U'", format_unformat_error, input);
14693 M (ONE_MAP_REQUEST_MODE, mp);
14700 /* wait for reply */
14705 #define api_lisp_map_request_mode api_one_map_request_mode
14708 * Enable/disable ONE proxy ITR.
14710 * @param vam vpp API test context
14711 * @return return code
14714 api_one_pitr_set_locator_set (vat_main_t * vam)
14716 u8 ls_name_set = 0;
14717 unformat_input_t *input = vam->input;
14718 vl_api_one_pitr_set_locator_set_t *mp;
14723 /* Parse args required to build the message */
14724 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14726 if (unformat (input, "del"))
14728 else if (unformat (input, "locator-set %s", &ls_name))
14732 errmsg ("parse error '%U'", format_unformat_error, input);
14739 errmsg ("locator-set name not set!");
14743 M (ONE_PITR_SET_LOCATOR_SET, mp);
14745 mp->is_add = is_add;
14746 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14747 vec_free (ls_name);
14752 /* wait for reply */
14757 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
14760 api_show_one_pitr (vat_main_t * vam)
14762 vl_api_show_one_pitr_t *mp;
14765 if (!vam->json_output)
14767 print (vam->ofp, "%=20s", "lisp status:");
14770 M (SHOW_ONE_PITR, mp);
14774 /* Wait for a reply... */
14779 #define api_show_lisp_pitr api_show_one_pitr
14782 api_one_use_petr (vat_main_t * vam)
14784 unformat_input_t *input = vam->input;
14785 vl_api_one_use_petr_t *mp;
14790 memset (&ip, 0, sizeof (ip));
14792 /* Parse args required to build the message */
14793 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14795 if (unformat (input, "disable"))
14798 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
14801 ip_addr_version (&ip) = IP4;
14804 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
14807 ip_addr_version (&ip) = IP6;
14811 errmsg ("parse error '%U'", format_unformat_error, input);
14816 M (ONE_USE_PETR, mp);
14818 mp->is_add = is_add;
14821 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
14823 clib_memcpy (mp->address, &ip, 4);
14825 clib_memcpy (mp->address, &ip, 16);
14831 /* wait for reply */
14836 #define api_lisp_use_petr api_one_use_petr
14839 api_show_one_use_petr (vat_main_t * vam)
14841 vl_api_show_one_use_petr_t *mp;
14844 if (!vam->json_output)
14846 print (vam->ofp, "%=20s", "Proxy-ETR status:");
14849 M (SHOW_ONE_USE_PETR, mp);
14853 /* Wait for a reply... */
14858 #define api_show_lisp_use_petr api_show_one_use_petr
14861 * Add/delete mapping between vni and vrf
14864 api_one_eid_table_add_del_map (vat_main_t * vam)
14866 unformat_input_t *input = vam->input;
14867 vl_api_one_eid_table_add_del_map_t *mp;
14868 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14869 u32 vni, vrf, bd_index;
14872 /* Parse args required to build the message */
14873 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14875 if (unformat (input, "del"))
14877 else if (unformat (input, "vrf %d", &vrf))
14879 else if (unformat (input, "bd_index %d", &bd_index))
14881 else if (unformat (input, "vni %d", &vni))
14887 if (!vni_set || (!vrf_set && !bd_index_set))
14889 errmsg ("missing arguments!");
14893 if (vrf_set && bd_index_set)
14895 errmsg ("error: both vrf and bd entered!");
14899 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
14901 mp->is_add = is_add;
14902 mp->vni = htonl (vni);
14903 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14904 mp->is_l2 = bd_index_set;
14909 /* wait for reply */
14914 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
14917 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14919 u32 *action = va_arg (*args, u32 *);
14922 if (unformat (input, "%s", &s))
14924 if (!strcmp ((char *) s, "no-action"))
14926 else if (!strcmp ((char *) s, "natively-forward"))
14928 else if (!strcmp ((char *) s, "send-map-request"))
14930 else if (!strcmp ((char *) s, "drop"))
14934 clib_warning ("invalid action: '%s'", s);
14946 * Add/del remote mapping to/from ONE control plane
14948 * @param vam vpp API test context
14949 * @return return code
14952 api_one_add_del_remote_mapping (vat_main_t * vam)
14954 unformat_input_t *input = vam->input;
14955 vl_api_one_add_del_remote_mapping_t *mp;
14957 lisp_eid_vat_t _eid, *eid = &_eid;
14958 lisp_eid_vat_t _seid, *seid = &_seid;
14959 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14960 u32 action = ~0, p, w, data_len;
14961 ip4_address_t rloc4;
14962 ip6_address_t rloc6;
14963 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14966 memset (&rloc, 0, sizeof (rloc));
14968 /* Parse args required to build the message */
14969 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14971 if (unformat (input, "del-all"))
14975 else if (unformat (input, "del"))
14979 else if (unformat (input, "add"))
14983 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14987 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14991 else if (unformat (input, "vni %d", &vni))
14995 else if (unformat (input, "p %d w %d", &p, &w))
14999 errmsg ("No RLOC configured for setting priority/weight!");
15002 curr_rloc->priority = p;
15003 curr_rloc->weight = w;
15005 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15008 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15009 vec_add1 (rlocs, rloc);
15010 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15012 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15015 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15016 vec_add1 (rlocs, rloc);
15017 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15019 else if (unformat (input, "action %U",
15020 unformat_negative_mapping_action, &action))
15026 clib_warning ("parse error '%U'", format_unformat_error, input);
15033 errmsg ("missing params!");
15037 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15039 errmsg ("no action set for negative map-reply!");
15043 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15045 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15046 mp->is_add = is_add;
15047 mp->vni = htonl (vni);
15048 mp->action = (u8) action;
15049 mp->is_src_dst = seid_set;
15050 mp->eid_len = eid->len;
15051 mp->seid_len = seid->len;
15052 mp->del_all = del_all;
15053 mp->eid_type = eid->type;
15054 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15055 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15057 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15058 clib_memcpy (mp->rlocs, rlocs, data_len);
15064 /* Wait for a reply... */
15069 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15072 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15073 * forwarding entries in data-plane accordingly.
15075 * @param vam vpp API test context
15076 * @return return code
15079 api_one_add_del_adjacency (vat_main_t * vam)
15081 unformat_input_t *input = vam->input;
15082 vl_api_one_add_del_adjacency_t *mp;
15084 ip4_address_t leid4, reid4;
15085 ip6_address_t leid6, reid6;
15086 u8 reid_mac[6] = { 0 };
15087 u8 leid_mac[6] = { 0 };
15088 u8 reid_type, leid_type;
15089 u32 leid_len = 0, reid_len = 0, len;
15093 leid_type = reid_type = (u8) ~ 0;
15095 /* Parse args required to build the message */
15096 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15098 if (unformat (input, "del"))
15102 else if (unformat (input, "add"))
15106 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15109 reid_type = 0; /* ipv4 */
15112 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15115 reid_type = 1; /* ipv6 */
15118 else if (unformat (input, "reid %U", unformat_ethernet_address,
15121 reid_type = 2; /* mac */
15123 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15126 leid_type = 0; /* ipv4 */
15129 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15132 leid_type = 1; /* ipv6 */
15135 else if (unformat (input, "leid %U", unformat_ethernet_address,
15138 leid_type = 2; /* mac */
15140 else if (unformat (input, "vni %d", &vni))
15146 errmsg ("parse error '%U'", format_unformat_error, input);
15151 if ((u8) ~ 0 == reid_type)
15153 errmsg ("missing params!");
15157 if (leid_type != reid_type)
15159 errmsg ("remote and local EIDs are of different types!");
15163 M (ONE_ADD_DEL_ADJACENCY, mp);
15164 mp->is_add = is_add;
15165 mp->vni = htonl (vni);
15166 mp->leid_len = leid_len;
15167 mp->reid_len = reid_len;
15168 mp->eid_type = reid_type;
15170 switch (mp->eid_type)
15173 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
15174 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
15177 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
15178 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
15181 clib_memcpy (mp->leid, leid_mac, 6);
15182 clib_memcpy (mp->reid, reid_mac, 6);
15185 errmsg ("unknown EID type %d!", mp->eid_type);
15192 /* Wait for a reply... */
15197 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
15200 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
15202 u32 *mode = va_arg (*args, u32 *);
15204 if (unformat (input, "lisp"))
15206 else if (unformat (input, "vxlan"))
15215 api_gpe_get_encap_mode (vat_main_t * vam)
15217 vl_api_gpe_get_encap_mode_t *mp;
15220 /* Construct the API message */
15221 M (GPE_GET_ENCAP_MODE, mp);
15226 /* Wait for a reply... */
15232 api_gpe_set_encap_mode (vat_main_t * vam)
15234 unformat_input_t *input = vam->input;
15235 vl_api_gpe_set_encap_mode_t *mp;
15239 /* Parse args required to build the message */
15240 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15242 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
15248 /* Construct the API message */
15249 M (GPE_SET_ENCAP_MODE, mp);
15256 /* Wait for a reply... */
15262 api_lisp_gpe_add_del_iface (vat_main_t * vam)
15264 unformat_input_t *input = vam->input;
15265 vl_api_gpe_add_del_iface_t *mp;
15266 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
15267 u32 dp_table = 0, vni = 0;
15270 /* Parse args required to build the message */
15271 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15273 if (unformat (input, "up"))
15278 else if (unformat (input, "down"))
15283 else if (unformat (input, "table_id %d", &dp_table))
15287 else if (unformat (input, "bd_id %d", &dp_table))
15292 else if (unformat (input, "vni %d", &vni))
15300 if (action_set == 0)
15302 errmsg ("Action not set");
15305 if (dp_table_set == 0 || vni_set == 0)
15307 errmsg ("vni and dp_table must be set");
15311 /* Construct the API message */
15312 M (GPE_ADD_DEL_IFACE, mp);
15314 mp->is_add = is_add;
15315 mp->dp_table = dp_table;
15322 /* Wait for a reply... */
15328 * Add/del map request itr rlocs from ONE control plane and updates
15330 * @param vam vpp API test context
15331 * @return return code
15334 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
15336 unformat_input_t *input = vam->input;
15337 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
15338 u8 *locator_set_name = 0;
15339 u8 locator_set_name_set = 0;
15343 /* Parse args required to build the message */
15344 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15346 if (unformat (input, "del"))
15350 else if (unformat (input, "%_%v%_", &locator_set_name))
15352 locator_set_name_set = 1;
15356 clib_warning ("parse error '%U'", format_unformat_error, input);
15361 if (is_add && !locator_set_name_set)
15363 errmsg ("itr-rloc is not set!");
15367 if (is_add && vec_len (locator_set_name) > 64)
15369 errmsg ("itr-rloc locator-set name too long");
15370 vec_free (locator_set_name);
15374 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
15375 mp->is_add = is_add;
15378 clib_memcpy (mp->locator_set_name, locator_set_name,
15379 vec_len (locator_set_name));
15383 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
15385 vec_free (locator_set_name);
15390 /* Wait for a reply... */
15395 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
15398 api_one_locator_dump (vat_main_t * vam)
15400 unformat_input_t *input = vam->input;
15401 vl_api_one_locator_dump_t *mp;
15402 vl_api_control_ping_t *mp_ping;
15403 u8 is_index_set = 0, is_name_set = 0;
15408 /* Parse args required to build the message */
15409 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15411 if (unformat (input, "ls_name %_%v%_", &ls_name))
15415 else if (unformat (input, "ls_index %d", &ls_index))
15421 errmsg ("parse error '%U'", format_unformat_error, input);
15426 if (!is_index_set && !is_name_set)
15428 errmsg ("error: expected one of index or name!");
15432 if (is_index_set && is_name_set)
15434 errmsg ("error: only one param expected!");
15438 if (vec_len (ls_name) > 62)
15440 errmsg ("error: locator set name too long!");
15444 if (!vam->json_output)
15446 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
15449 M (ONE_LOCATOR_DUMP, mp);
15450 mp->is_index_set = is_index_set;
15453 mp->ls_index = clib_host_to_net_u32 (ls_index);
15456 vec_add1 (ls_name, 0);
15457 strncpy ((char *) mp->ls_name, (char *) ls_name,
15458 sizeof (mp->ls_name) - 1);
15464 /* Use a control ping for synchronization */
15465 M (CONTROL_PING, mp_ping);
15468 /* Wait for a reply... */
15473 #define api_lisp_locator_dump api_one_locator_dump
15476 api_one_locator_set_dump (vat_main_t * vam)
15478 vl_api_one_locator_set_dump_t *mp;
15479 vl_api_control_ping_t *mp_ping;
15480 unformat_input_t *input = vam->input;
15484 /* Parse args required to build the message */
15485 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15487 if (unformat (input, "local"))
15491 else if (unformat (input, "remote"))
15497 errmsg ("parse error '%U'", format_unformat_error, input);
15502 if (!vam->json_output)
15504 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
15507 M (ONE_LOCATOR_SET_DUMP, mp);
15509 mp->filter = filter;
15514 /* Use a control ping for synchronization */
15515 M (CONTROL_PING, mp_ping);
15518 /* Wait for a reply... */
15523 #define api_lisp_locator_set_dump api_one_locator_set_dump
15526 api_one_eid_table_map_dump (vat_main_t * vam)
15530 unformat_input_t *input = vam->input;
15531 vl_api_one_eid_table_map_dump_t *mp;
15532 vl_api_control_ping_t *mp_ping;
15535 /* Parse args required to build the message */
15536 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15538 if (unformat (input, "l2"))
15543 else if (unformat (input, "l3"))
15550 errmsg ("parse error '%U'", format_unformat_error, input);
15557 errmsg ("expected one of 'l2' or 'l3' parameter!");
15561 if (!vam->json_output)
15563 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
15566 M (ONE_EID_TABLE_MAP_DUMP, mp);
15572 /* Use a control ping for synchronization */
15573 M (CONTROL_PING, mp_ping);
15576 /* Wait for a reply... */
15581 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
15584 api_one_eid_table_vni_dump (vat_main_t * vam)
15586 vl_api_one_eid_table_vni_dump_t *mp;
15587 vl_api_control_ping_t *mp_ping;
15590 if (!vam->json_output)
15592 print (vam->ofp, "VNI");
15595 M (ONE_EID_TABLE_VNI_DUMP, mp);
15600 /* Use a control ping for synchronization */
15601 M (CONTROL_PING, mp_ping);
15604 /* Wait for a reply... */
15609 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
15612 api_one_eid_table_dump (vat_main_t * vam)
15614 unformat_input_t *i = vam->input;
15615 vl_api_one_eid_table_dump_t *mp;
15616 vl_api_control_ping_t *mp_ping;
15617 struct in_addr ip4;
15618 struct in6_addr ip6;
15620 u8 eid_type = ~0, eid_set = 0;
15621 u32 prefix_length = ~0, t, vni = 0;
15625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15627 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
15633 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
15639 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
15644 else if (unformat (i, "vni %d", &t))
15648 else if (unformat (i, "local"))
15652 else if (unformat (i, "remote"))
15658 errmsg ("parse error '%U'", format_unformat_error, i);
15663 if (!vam->json_output)
15665 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
15666 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
15669 M (ONE_EID_TABLE_DUMP, mp);
15671 mp->filter = filter;
15675 mp->vni = htonl (vni);
15676 mp->eid_type = eid_type;
15680 mp->prefix_length = prefix_length;
15681 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
15684 mp->prefix_length = prefix_length;
15685 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
15688 clib_memcpy (mp->eid, mac, sizeof (mac));
15691 errmsg ("unknown EID type %d!", eid_type);
15699 /* Use a control ping for synchronization */
15700 M (CONTROL_PING, mp_ping);
15703 /* Wait for a reply... */
15708 #define api_lisp_eid_table_dump api_one_eid_table_dump
15711 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15713 unformat_input_t *i = vam->input;
15714 vl_api_gpe_fwd_entries_get_t *mp;
15719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15721 if (unformat (i, "vni %d", &vni))
15727 errmsg ("parse error '%U'", format_unformat_error, i);
15734 errmsg ("vni not set!");
15738 if (!vam->json_output)
15740 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15744 M (GPE_FWD_ENTRIES_GET, mp);
15745 mp->vni = clib_host_to_net_u32 (vni);
15750 /* Wait for a reply... */
15755 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15756 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15757 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15758 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
15761 api_one_adjacencies_get (vat_main_t * vam)
15763 unformat_input_t *i = vam->input;
15764 vl_api_one_adjacencies_get_t *mp;
15769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15771 if (unformat (i, "vni %d", &vni))
15777 errmsg ("parse error '%U'", format_unformat_error, i);
15784 errmsg ("vni not set!");
15788 if (!vam->json_output)
15790 print (vam->ofp, "%s %40s", "leid", "reid");
15793 M (ONE_ADJACENCIES_GET, mp);
15794 mp->vni = clib_host_to_net_u32 (vni);
15799 /* Wait for a reply... */
15804 #define api_lisp_adjacencies_get api_one_adjacencies_get
15807 api_one_map_server_dump (vat_main_t * vam)
15809 vl_api_one_map_server_dump_t *mp;
15810 vl_api_control_ping_t *mp_ping;
15813 if (!vam->json_output)
15815 print (vam->ofp, "%=20s", "Map server");
15818 M (ONE_MAP_SERVER_DUMP, mp);
15822 /* Use a control ping for synchronization */
15823 M (CONTROL_PING, mp_ping);
15826 /* Wait for a reply... */
15831 #define api_lisp_map_server_dump api_one_map_server_dump
15834 api_one_map_resolver_dump (vat_main_t * vam)
15836 vl_api_one_map_resolver_dump_t *mp;
15837 vl_api_control_ping_t *mp_ping;
15840 if (!vam->json_output)
15842 print (vam->ofp, "%=20s", "Map resolver");
15845 M (ONE_MAP_RESOLVER_DUMP, mp);
15849 /* Use a control ping for synchronization */
15850 M (CONTROL_PING, mp_ping);
15853 /* Wait for a reply... */
15858 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
15861 api_one_stats_flush (vat_main_t * vam)
15863 vl_api_one_stats_flush_t *mp;
15866 M (ONE_STATS_FLUSH, mp);
15873 api_one_stats_dump (vat_main_t * vam)
15875 vl_api_one_stats_dump_t *mp;
15876 vl_api_control_ping_t *mp_ping;
15879 M (ONE_STATS_DUMP, mp);
15883 /* Use a control ping for synchronization */
15884 M (CONTROL_PING, mp_ping);
15887 /* Wait for a reply... */
15893 api_show_one_status (vat_main_t * vam)
15895 vl_api_show_one_status_t *mp;
15898 if (!vam->json_output)
15900 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
15903 M (SHOW_ONE_STATUS, mp);
15906 /* Wait for a reply... */
15911 #define api_show_lisp_status api_show_one_status
15914 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15916 vl_api_gpe_fwd_entry_path_dump_t *mp;
15917 vl_api_control_ping_t *mp_ping;
15918 unformat_input_t *i = vam->input;
15919 u32 fwd_entry_index = ~0;
15922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15924 if (unformat (i, "index %d", &fwd_entry_index))
15930 if (~0 == fwd_entry_index)
15932 errmsg ("no index specified!");
15936 if (!vam->json_output)
15938 print (vam->ofp, "first line");
15941 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
15945 /* Use a control ping for synchronization */
15946 M (CONTROL_PING, mp_ping);
15949 /* Wait for a reply... */
15955 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
15957 vl_api_one_get_map_request_itr_rlocs_t *mp;
15960 if (!vam->json_output)
15962 print (vam->ofp, "%=20s", "itr-rlocs:");
15965 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
15968 /* Wait for a reply... */
15973 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
15976 api_af_packet_create (vat_main_t * vam)
15978 unformat_input_t *i = vam->input;
15979 vl_api_af_packet_create_t *mp;
15980 u8 *host_if_name = 0;
15982 u8 random_hw_addr = 1;
15985 memset (hw_addr, 0, sizeof (hw_addr));
15987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15989 if (unformat (i, "name %s", &host_if_name))
15990 vec_add1 (host_if_name, 0);
15991 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15992 random_hw_addr = 0;
15997 if (!vec_len (host_if_name))
15999 errmsg ("host-interface name must be specified");
16003 if (vec_len (host_if_name) > 64)
16005 errmsg ("host-interface name too long");
16009 M (AF_PACKET_CREATE, mp);
16011 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
16012 clib_memcpy (mp->hw_addr, hw_addr, 6);
16013 mp->use_random_hw_addr = random_hw_addr;
16014 vec_free (host_if_name);
16022 fprintf (vam->ofp ? vam->ofp : stderr,
16023 " new sw_if_index = %d\n", vam->sw_if_index);
16030 api_af_packet_delete (vat_main_t * vam)
16032 unformat_input_t *i = vam->input;
16033 vl_api_af_packet_delete_t *mp;
16034 u8 *host_if_name = 0;
16037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16039 if (unformat (i, "name %s", &host_if_name))
16040 vec_add1 (host_if_name, 0);
16045 if (!vec_len (host_if_name))
16047 errmsg ("host-interface name must be specified");
16051 if (vec_len (host_if_name) > 64)
16053 errmsg ("host-interface name too long");
16057 M (AF_PACKET_DELETE, mp);
16059 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
16060 vec_free (host_if_name);
16068 api_policer_add_del (vat_main_t * vam)
16070 unformat_input_t *i = vam->input;
16071 vl_api_policer_add_del_t *mp;
16081 u8 color_aware = 0;
16082 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
16085 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
16086 conform_action.dscp = 0;
16087 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
16088 exceed_action.dscp = 0;
16089 violate_action.action_type = SSE2_QOS_ACTION_DROP;
16090 violate_action.dscp = 0;
16092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16094 if (unformat (i, "del"))
16096 else if (unformat (i, "name %s", &name))
16097 vec_add1 (name, 0);
16098 else if (unformat (i, "cir %u", &cir))
16100 else if (unformat (i, "eir %u", &eir))
16102 else if (unformat (i, "cb %u", &cb))
16104 else if (unformat (i, "eb %u", &eb))
16106 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
16109 else if (unformat (i, "round_type %U", unformat_policer_round_type,
16112 else if (unformat (i, "type %U", unformat_policer_type, &type))
16114 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
16117 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
16120 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
16123 else if (unformat (i, "color-aware"))
16129 if (!vec_len (name))
16131 errmsg ("policer name must be specified");
16135 if (vec_len (name) > 64)
16137 errmsg ("policer name too long");
16141 M (POLICER_ADD_DEL, mp);
16143 clib_memcpy (mp->name, name, vec_len (name));
16145 mp->is_add = is_add;
16150 mp->rate_type = rate_type;
16151 mp->round_type = round_type;
16153 mp->conform_action_type = conform_action.action_type;
16154 mp->conform_dscp = conform_action.dscp;
16155 mp->exceed_action_type = exceed_action.action_type;
16156 mp->exceed_dscp = exceed_action.dscp;
16157 mp->violate_action_type = violate_action.action_type;
16158 mp->violate_dscp = violate_action.dscp;
16159 mp->color_aware = color_aware;
16167 api_policer_dump (vat_main_t * vam)
16169 unformat_input_t *i = vam->input;
16170 vl_api_policer_dump_t *mp;
16171 vl_api_control_ping_t *mp_ping;
16172 u8 *match_name = 0;
16173 u8 match_name_valid = 0;
16176 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16178 if (unformat (i, "name %s", &match_name))
16180 vec_add1 (match_name, 0);
16181 match_name_valid = 1;
16187 M (POLICER_DUMP, mp);
16188 mp->match_name_valid = match_name_valid;
16189 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
16190 vec_free (match_name);
16194 /* Use a control ping for synchronization */
16195 M (CONTROL_PING, mp_ping);
16198 /* Wait for a reply... */
16204 api_policer_classify_set_interface (vat_main_t * vam)
16206 unformat_input_t *i = vam->input;
16207 vl_api_policer_classify_set_interface_t *mp;
16209 int sw_if_index_set;
16210 u32 ip4_table_index = ~0;
16211 u32 ip6_table_index = ~0;
16212 u32 l2_table_index = ~0;
16216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16218 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16219 sw_if_index_set = 1;
16220 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16221 sw_if_index_set = 1;
16222 else if (unformat (i, "del"))
16224 else if (unformat (i, "ip4-table %d", &ip4_table_index))
16226 else if (unformat (i, "ip6-table %d", &ip6_table_index))
16228 else if (unformat (i, "l2-table %d", &l2_table_index))
16232 clib_warning ("parse error '%U'", format_unformat_error, i);
16237 if (sw_if_index_set == 0)
16239 errmsg ("missing interface name or sw_if_index");
16243 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
16245 mp->sw_if_index = ntohl (sw_if_index);
16246 mp->ip4_table_index = ntohl (ip4_table_index);
16247 mp->ip6_table_index = ntohl (ip6_table_index);
16248 mp->l2_table_index = ntohl (l2_table_index);
16249 mp->is_add = is_add;
16257 api_policer_classify_dump (vat_main_t * vam)
16259 unformat_input_t *i = vam->input;
16260 vl_api_policer_classify_dump_t *mp;
16261 vl_api_control_ping_t *mp_ping;
16262 u8 type = POLICER_CLASSIFY_N_TABLES;
16265 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
16269 errmsg ("classify table type must be specified");
16273 if (!vam->json_output)
16275 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
16278 M (POLICER_CLASSIFY_DUMP, mp);
16283 /* Use a control ping for synchronization */
16284 M (CONTROL_PING, mp_ping);
16287 /* Wait for a reply... */
16293 api_netmap_create (vat_main_t * vam)
16295 unformat_input_t *i = vam->input;
16296 vl_api_netmap_create_t *mp;
16299 u8 random_hw_addr = 1;
16304 memset (hw_addr, 0, sizeof (hw_addr));
16306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16308 if (unformat (i, "name %s", &if_name))
16309 vec_add1 (if_name, 0);
16310 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
16311 random_hw_addr = 0;
16312 else if (unformat (i, "pipe"))
16314 else if (unformat (i, "master"))
16316 else if (unformat (i, "slave"))
16322 if (!vec_len (if_name))
16324 errmsg ("interface name must be specified");
16328 if (vec_len (if_name) > 64)
16330 errmsg ("interface name too long");
16334 M (NETMAP_CREATE, mp);
16336 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
16337 clib_memcpy (mp->hw_addr, hw_addr, 6);
16338 mp->use_random_hw_addr = random_hw_addr;
16339 mp->is_pipe = is_pipe;
16340 mp->is_master = is_master;
16341 vec_free (if_name);
16349 api_netmap_delete (vat_main_t * vam)
16351 unformat_input_t *i = vam->input;
16352 vl_api_netmap_delete_t *mp;
16356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16358 if (unformat (i, "name %s", &if_name))
16359 vec_add1 (if_name, 0);
16364 if (!vec_len (if_name))
16366 errmsg ("interface name must be specified");
16370 if (vec_len (if_name) > 64)
16372 errmsg ("interface name too long");
16376 M (NETMAP_DELETE, mp);
16378 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
16379 vec_free (if_name);
16387 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
16389 if (fp->afi == IP46_TYPE_IP6)
16391 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16392 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16393 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16394 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16395 format_ip6_address, fp->next_hop);
16396 else if (fp->afi == IP46_TYPE_IP4)
16398 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16399 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16400 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16401 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16402 format_ip4_address, fp->next_hop);
16406 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
16407 vl_api_fib_path2_t * fp)
16409 struct in_addr ip4;
16410 struct in6_addr ip6;
16412 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16413 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16414 vat_json_object_add_uint (node, "is_local", fp->is_local);
16415 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16416 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16417 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16418 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16419 if (fp->afi == IP46_TYPE_IP4)
16421 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16422 vat_json_object_add_ip4 (node, "next_hop", ip4);
16424 else if (fp->afi == IP46_TYPE_IP6)
16426 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16427 vat_json_object_add_ip6 (node, "next_hop", ip6);
16432 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
16434 vat_main_t *vam = &vat_main;
16435 int count = ntohl (mp->mt_count);
16436 vl_api_fib_path2_t *fp;
16439 print (vam->ofp, "[%d]: sw_if_index %d via:",
16440 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
16442 for (i = 0; i < count; i++)
16444 vl_api_mpls_fib_path_print (vam, fp);
16448 print (vam->ofp, "");
16451 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
16452 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
16455 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
16457 vat_main_t *vam = &vat_main;
16458 vat_json_node_t *node = NULL;
16459 int count = ntohl (mp->mt_count);
16460 vl_api_fib_path2_t *fp;
16463 if (VAT_JSON_ARRAY != vam->json_tree.type)
16465 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16466 vat_json_init_array (&vam->json_tree);
16468 node = vat_json_array_add (&vam->json_tree);
16470 vat_json_init_object (node);
16471 vat_json_object_add_uint (node, "tunnel_index",
16472 ntohl (mp->mt_tunnel_index));
16473 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
16475 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
16478 for (i = 0; i < count; i++)
16480 vl_api_mpls_fib_path_json_print (node, fp);
16486 api_mpls_tunnel_dump (vat_main_t * vam)
16488 vl_api_mpls_tunnel_dump_t *mp;
16489 vl_api_control_ping_t *mp_ping;
16493 /* Parse args required to build the message */
16494 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
16496 if (!unformat (vam->input, "tunnel_index %d", &index))
16503 print (vam->ofp, " tunnel_index %d", index);
16505 M (MPLS_TUNNEL_DUMP, mp);
16506 mp->tunnel_index = htonl (index);
16509 /* Use a control ping for synchronization */
16510 M (CONTROL_PING, mp_ping);
16517 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
16518 #define vl_api_mpls_fib_details_t_print vl_noop_handler
16522 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
16524 vat_main_t *vam = &vat_main;
16525 int count = ntohl (mp->count);
16526 vl_api_fib_path2_t *fp;
16530 "table-id %d, label %u, ess_bit %u",
16531 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
16533 for (i = 0; i < count; i++)
16535 vl_api_mpls_fib_path_print (vam, fp);
16540 static void vl_api_mpls_fib_details_t_handler_json
16541 (vl_api_mpls_fib_details_t * mp)
16543 vat_main_t *vam = &vat_main;
16544 int count = ntohl (mp->count);
16545 vat_json_node_t *node = NULL;
16546 vl_api_fib_path2_t *fp;
16549 if (VAT_JSON_ARRAY != vam->json_tree.type)
16551 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16552 vat_json_init_array (&vam->json_tree);
16554 node = vat_json_array_add (&vam->json_tree);
16556 vat_json_init_object (node);
16557 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16558 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
16559 vat_json_object_add_uint (node, "label", ntohl (mp->label));
16560 vat_json_object_add_uint (node, "path_count", count);
16562 for (i = 0; i < count; i++)
16564 vl_api_mpls_fib_path_json_print (node, fp);
16570 api_mpls_fib_dump (vat_main_t * vam)
16572 vl_api_mpls_fib_dump_t *mp;
16573 vl_api_control_ping_t *mp_ping;
16576 M (MPLS_FIB_DUMP, mp);
16579 /* Use a control ping for synchronization */
16580 M (CONTROL_PING, mp_ping);
16587 #define vl_api_ip_fib_details_t_endian vl_noop_handler
16588 #define vl_api_ip_fib_details_t_print vl_noop_handler
16591 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
16593 vat_main_t *vam = &vat_main;
16594 int count = ntohl (mp->count);
16595 vl_api_fib_path_t *fp;
16599 "table-id %d, prefix %U/%d",
16600 ntohl (mp->table_id), format_ip4_address, mp->address,
16601 mp->address_length);
16603 for (i = 0; i < count; i++)
16605 if (fp->afi == IP46_TYPE_IP6)
16607 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16608 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16609 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16610 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16611 format_ip6_address, fp->next_hop);
16612 else if (fp->afi == IP46_TYPE_IP4)
16614 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16615 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16616 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16617 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16618 format_ip4_address, fp->next_hop);
16623 static void vl_api_ip_fib_details_t_handler_json
16624 (vl_api_ip_fib_details_t * mp)
16626 vat_main_t *vam = &vat_main;
16627 int count = ntohl (mp->count);
16628 vat_json_node_t *node = NULL;
16629 struct in_addr ip4;
16630 struct in6_addr ip6;
16631 vl_api_fib_path_t *fp;
16634 if (VAT_JSON_ARRAY != vam->json_tree.type)
16636 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16637 vat_json_init_array (&vam->json_tree);
16639 node = vat_json_array_add (&vam->json_tree);
16641 vat_json_init_object (node);
16642 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16643 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
16644 vat_json_object_add_ip4 (node, "prefix", ip4);
16645 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16646 vat_json_object_add_uint (node, "path_count", count);
16648 for (i = 0; i < count; i++)
16650 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16651 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16652 vat_json_object_add_uint (node, "is_local", fp->is_local);
16653 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16654 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16655 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16656 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16657 if (fp->afi == IP46_TYPE_IP4)
16659 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16660 vat_json_object_add_ip4 (node, "next_hop", ip4);
16662 else if (fp->afi == IP46_TYPE_IP6)
16664 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16665 vat_json_object_add_ip6 (node, "next_hop", ip6);
16671 api_ip_fib_dump (vat_main_t * vam)
16673 vl_api_ip_fib_dump_t *mp;
16674 vl_api_control_ping_t *mp_ping;
16677 M (IP_FIB_DUMP, mp);
16680 /* Use a control ping for synchronization */
16681 M (CONTROL_PING, mp_ping);
16689 api_ip_mfib_dump (vat_main_t * vam)
16691 vl_api_ip_mfib_dump_t *mp;
16692 vl_api_control_ping_t *mp_ping;
16695 M (IP_MFIB_DUMP, mp);
16698 /* Use a control ping for synchronization */
16699 M (CONTROL_PING, mp_ping);
16706 static void vl_api_ip_neighbor_details_t_handler
16707 (vl_api_ip_neighbor_details_t * mp)
16709 vat_main_t *vam = &vat_main;
16711 print (vam->ofp, "%c %U %U",
16712 (mp->is_static) ? 'S' : 'D',
16713 format_ethernet_address, &mp->mac_address,
16714 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
16718 static void vl_api_ip_neighbor_details_t_handler_json
16719 (vl_api_ip_neighbor_details_t * mp)
16722 vat_main_t *vam = &vat_main;
16723 vat_json_node_t *node;
16724 struct in_addr ip4;
16725 struct in6_addr ip6;
16727 if (VAT_JSON_ARRAY != vam->json_tree.type)
16729 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16730 vat_json_init_array (&vam->json_tree);
16732 node = vat_json_array_add (&vam->json_tree);
16734 vat_json_init_object (node);
16735 vat_json_object_add_string_copy (node, "flag",
16736 (mp->is_static) ? (u8 *) "static" : (u8 *)
16739 vat_json_object_add_string_copy (node, "link_layer",
16740 format (0, "%U", format_ethernet_address,
16741 &mp->mac_address));
16745 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
16746 vat_json_object_add_ip6 (node, "ip_address", ip6);
16750 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
16751 vat_json_object_add_ip4 (node, "ip_address", ip4);
16756 api_ip_neighbor_dump (vat_main_t * vam)
16758 unformat_input_t *i = vam->input;
16759 vl_api_ip_neighbor_dump_t *mp;
16760 vl_api_control_ping_t *mp_ping;
16762 u32 sw_if_index = ~0;
16765 /* Parse args required to build the message */
16766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16768 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16770 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16772 else if (unformat (i, "ip6"))
16778 if (sw_if_index == ~0)
16780 errmsg ("missing interface name or sw_if_index");
16784 M (IP_NEIGHBOR_DUMP, mp);
16785 mp->is_ipv6 = (u8) is_ipv6;
16786 mp->sw_if_index = ntohl (sw_if_index);
16789 /* Use a control ping for synchronization */
16790 M (CONTROL_PING, mp_ping);
16797 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16798 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16801 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16803 vat_main_t *vam = &vat_main;
16804 int count = ntohl (mp->count);
16805 vl_api_fib_path_t *fp;
16809 "table-id %d, prefix %U/%d",
16810 ntohl (mp->table_id), format_ip6_address, mp->address,
16811 mp->address_length);
16813 for (i = 0; i < count; i++)
16815 if (fp->afi == IP46_TYPE_IP6)
16817 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16818 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16819 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16820 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16821 format_ip6_address, fp->next_hop);
16822 else if (fp->afi == IP46_TYPE_IP4)
16824 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16825 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16826 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16827 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16828 format_ip4_address, fp->next_hop);
16833 static void vl_api_ip6_fib_details_t_handler_json
16834 (vl_api_ip6_fib_details_t * mp)
16836 vat_main_t *vam = &vat_main;
16837 int count = ntohl (mp->count);
16838 vat_json_node_t *node = NULL;
16839 struct in_addr ip4;
16840 struct in6_addr ip6;
16841 vl_api_fib_path_t *fp;
16844 if (VAT_JSON_ARRAY != vam->json_tree.type)
16846 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16847 vat_json_init_array (&vam->json_tree);
16849 node = vat_json_array_add (&vam->json_tree);
16851 vat_json_init_object (node);
16852 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16853 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16854 vat_json_object_add_ip6 (node, "prefix", ip6);
16855 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16856 vat_json_object_add_uint (node, "path_count", count);
16858 for (i = 0; i < count; i++)
16860 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16861 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16862 vat_json_object_add_uint (node, "is_local", fp->is_local);
16863 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16864 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16865 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16866 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16867 if (fp->afi == IP46_TYPE_IP4)
16869 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16870 vat_json_object_add_ip4 (node, "next_hop", ip4);
16872 else if (fp->afi == IP46_TYPE_IP6)
16874 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16875 vat_json_object_add_ip6 (node, "next_hop", ip6);
16881 api_ip6_fib_dump (vat_main_t * vam)
16883 vl_api_ip6_fib_dump_t *mp;
16884 vl_api_control_ping_t *mp_ping;
16887 M (IP6_FIB_DUMP, mp);
16890 /* Use a control ping for synchronization */
16891 M (CONTROL_PING, mp_ping);
16899 api_ip6_mfib_dump (vat_main_t * vam)
16901 vl_api_ip6_mfib_dump_t *mp;
16902 vl_api_control_ping_t *mp_ping;
16905 M (IP6_MFIB_DUMP, mp);
16908 /* Use a control ping for synchronization */
16909 M (CONTROL_PING, mp_ping);
16917 api_classify_table_ids (vat_main_t * vam)
16919 vl_api_classify_table_ids_t *mp;
16922 /* Construct the API message */
16923 M (CLASSIFY_TABLE_IDS, mp);
16932 api_classify_table_by_interface (vat_main_t * vam)
16934 unformat_input_t *input = vam->input;
16935 vl_api_classify_table_by_interface_t *mp;
16937 u32 sw_if_index = ~0;
16939 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16941 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16943 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16948 if (sw_if_index == ~0)
16950 errmsg ("missing interface name or sw_if_index");
16954 /* Construct the API message */
16955 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16957 mp->sw_if_index = ntohl (sw_if_index);
16965 api_classify_table_info (vat_main_t * vam)
16967 unformat_input_t *input = vam->input;
16968 vl_api_classify_table_info_t *mp;
16972 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16974 if (unformat (input, "table_id %d", &table_id))
16979 if (table_id == ~0)
16981 errmsg ("missing table id");
16985 /* Construct the API message */
16986 M (CLASSIFY_TABLE_INFO, mp);
16988 mp->table_id = ntohl (table_id);
16996 api_classify_session_dump (vat_main_t * vam)
16998 unformat_input_t *input = vam->input;
16999 vl_api_classify_session_dump_t *mp;
17000 vl_api_control_ping_t *mp_ping;
17004 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17006 if (unformat (input, "table_id %d", &table_id))
17011 if (table_id == ~0)
17013 errmsg ("missing table id");
17017 /* Construct the API message */
17018 M (CLASSIFY_SESSION_DUMP, mp);
17020 mp->table_id = ntohl (table_id);
17023 /* Use a control ping for synchronization */
17024 M (CONTROL_PING, mp_ping);
17032 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
17034 vat_main_t *vam = &vat_main;
17036 print (vam->ofp, "collector_address %U, collector_port %d, "
17037 "src_address %U, vrf_id %d, path_mtu %u, "
17038 "template_interval %u, udp_checksum %d",
17039 format_ip4_address, mp->collector_address,
17040 ntohs (mp->collector_port),
17041 format_ip4_address, mp->src_address,
17042 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
17043 ntohl (mp->template_interval), mp->udp_checksum);
17046 vam->result_ready = 1;
17050 vl_api_ipfix_exporter_details_t_handler_json
17051 (vl_api_ipfix_exporter_details_t * mp)
17053 vat_main_t *vam = &vat_main;
17054 vat_json_node_t node;
17055 struct in_addr collector_address;
17056 struct in_addr src_address;
17058 vat_json_init_object (&node);
17059 clib_memcpy (&collector_address, &mp->collector_address,
17060 sizeof (collector_address));
17061 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
17062 vat_json_object_add_uint (&node, "collector_port",
17063 ntohs (mp->collector_port));
17064 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
17065 vat_json_object_add_ip4 (&node, "src_address", src_address);
17066 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
17067 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
17068 vat_json_object_add_uint (&node, "template_interval",
17069 ntohl (mp->template_interval));
17070 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
17072 vat_json_print (vam->ofp, &node);
17073 vat_json_free (&node);
17075 vam->result_ready = 1;
17079 api_ipfix_exporter_dump (vat_main_t * vam)
17081 vl_api_ipfix_exporter_dump_t *mp;
17084 /* Construct the API message */
17085 M (IPFIX_EXPORTER_DUMP, mp);
17094 api_ipfix_classify_stream_dump (vat_main_t * vam)
17096 vl_api_ipfix_classify_stream_dump_t *mp;
17099 /* Construct the API message */
17100 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
17111 vl_api_ipfix_classify_stream_details_t_handler
17112 (vl_api_ipfix_classify_stream_details_t * mp)
17114 vat_main_t *vam = &vat_main;
17115 print (vam->ofp, "domain_id %d, src_port %d",
17116 ntohl (mp->domain_id), ntohs (mp->src_port));
17118 vam->result_ready = 1;
17122 vl_api_ipfix_classify_stream_details_t_handler_json
17123 (vl_api_ipfix_classify_stream_details_t * mp)
17125 vat_main_t *vam = &vat_main;
17126 vat_json_node_t node;
17128 vat_json_init_object (&node);
17129 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
17130 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
17132 vat_json_print (vam->ofp, &node);
17133 vat_json_free (&node);
17135 vam->result_ready = 1;
17139 api_ipfix_classify_table_dump (vat_main_t * vam)
17141 vl_api_ipfix_classify_table_dump_t *mp;
17142 vl_api_control_ping_t *mp_ping;
17145 if (!vam->json_output)
17147 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
17148 "transport_protocol");
17151 /* Construct the API message */
17152 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
17157 /* Use a control ping for synchronization */
17158 M (CONTROL_PING, mp_ping);
17166 vl_api_ipfix_classify_table_details_t_handler
17167 (vl_api_ipfix_classify_table_details_t * mp)
17169 vat_main_t *vam = &vat_main;
17170 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
17171 mp->transport_protocol);
17175 vl_api_ipfix_classify_table_details_t_handler_json
17176 (vl_api_ipfix_classify_table_details_t * mp)
17178 vat_json_node_t *node = NULL;
17179 vat_main_t *vam = &vat_main;
17181 if (VAT_JSON_ARRAY != vam->json_tree.type)
17183 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17184 vat_json_init_array (&vam->json_tree);
17187 node = vat_json_array_add (&vam->json_tree);
17188 vat_json_init_object (node);
17190 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
17191 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
17192 vat_json_object_add_uint (node, "transport_protocol",
17193 mp->transport_protocol);
17197 api_sw_interface_span_enable_disable (vat_main_t * vam)
17199 unformat_input_t *i = vam->input;
17200 vl_api_sw_interface_span_enable_disable_t *mp;
17201 u32 src_sw_if_index = ~0;
17202 u32 dst_sw_if_index = ~0;
17206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17209 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
17211 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
17215 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
17217 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
17219 else if (unformat (i, "disable"))
17221 else if (unformat (i, "rx"))
17223 else if (unformat (i, "tx"))
17225 else if (unformat (i, "both"))
17231 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
17233 mp->sw_if_index_from = htonl (src_sw_if_index);
17234 mp->sw_if_index_to = htonl (dst_sw_if_index);
17243 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
17246 vat_main_t *vam = &vat_main;
17247 u8 *sw_if_from_name = 0;
17248 u8 *sw_if_to_name = 0;
17249 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
17250 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
17251 char *states[] = { "none", "rx", "tx", "both" };
17255 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
17257 if ((u32) p->value[0] == sw_if_index_from)
17259 sw_if_from_name = (u8 *)(p->key);
17263 if ((u32) p->value[0] == sw_if_index_to)
17265 sw_if_to_name = (u8 *)(p->key);
17266 if (sw_if_from_name)
17271 print (vam->ofp, "%20s => %20s (%s)",
17272 sw_if_from_name, sw_if_to_name, states[mp->state]);
17276 vl_api_sw_interface_span_details_t_handler_json
17277 (vl_api_sw_interface_span_details_t * mp)
17279 vat_main_t *vam = &vat_main;
17280 vat_json_node_t *node = NULL;
17281 u8 *sw_if_from_name = 0;
17282 u8 *sw_if_to_name = 0;
17283 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
17284 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
17288 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
17290 if ((u32) p->value[0] == sw_if_index_from)
17292 sw_if_from_name = (u8 *)(p->key);
17296 if ((u32) p->value[0] == sw_if_index_to)
17298 sw_if_to_name = (u8 *)(p->key);
17299 if (sw_if_from_name)
17305 if (VAT_JSON_ARRAY != vam->json_tree.type)
17307 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17308 vat_json_init_array (&vam->json_tree);
17310 node = vat_json_array_add (&vam->json_tree);
17312 vat_json_init_object (node);
17313 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
17314 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
17315 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
17316 if (0 != sw_if_to_name)
17318 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
17320 vat_json_object_add_uint (node, "state", mp->state);
17324 api_sw_interface_span_dump (vat_main_t * vam)
17326 vl_api_sw_interface_span_dump_t *mp;
17327 vl_api_control_ping_t *mp_ping;
17330 M (SW_INTERFACE_SPAN_DUMP, mp);
17333 /* Use a control ping for synchronization */
17334 M (CONTROL_PING, mp_ping);
17342 api_pg_create_interface (vat_main_t * vam)
17344 unformat_input_t *input = vam->input;
17345 vl_api_pg_create_interface_t *mp;
17349 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17351 if (unformat (input, "if_id %d", &if_id))
17358 errmsg ("missing pg interface index");
17362 /* Construct the API message */
17363 M (PG_CREATE_INTERFACE, mp);
17365 mp->interface_id = ntohl (if_id);
17373 api_pg_capture (vat_main_t * vam)
17375 unformat_input_t *input = vam->input;
17376 vl_api_pg_capture_t *mp;
17381 u8 pcap_file_set = 0;
17384 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17386 if (unformat (input, "if_id %d", &if_id))
17388 else if (unformat (input, "pcap %s", &pcap_file))
17390 else if (unformat (input, "count %d", &count))
17392 else if (unformat (input, "disable"))
17399 errmsg ("missing pg interface index");
17402 if (pcap_file_set > 0)
17404 if (vec_len (pcap_file) > 255)
17406 errmsg ("pcap file name is too long");
17411 u32 name_len = vec_len (pcap_file);
17412 /* Construct the API message */
17413 M (PG_CAPTURE, mp);
17415 mp->interface_id = ntohl (if_id);
17416 mp->is_enabled = enable;
17417 mp->count = ntohl (count);
17418 mp->pcap_name_length = ntohl (name_len);
17419 if (pcap_file_set != 0)
17421 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
17423 vec_free (pcap_file);
17431 api_pg_enable_disable (vat_main_t * vam)
17433 unformat_input_t *input = vam->input;
17434 vl_api_pg_enable_disable_t *mp;
17437 u8 stream_name_set = 0;
17438 u8 *stream_name = 0;
17440 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17442 if (unformat (input, "stream %s", &stream_name))
17443 stream_name_set = 1;
17444 else if (unformat (input, "disable"))
17450 if (stream_name_set > 0)
17452 if (vec_len (stream_name) > 255)
17454 errmsg ("stream name too long");
17459 u32 name_len = vec_len (stream_name);
17460 /* Construct the API message */
17461 M (PG_ENABLE_DISABLE, mp);
17463 mp->is_enabled = enable;
17464 if (stream_name_set != 0)
17466 mp->stream_name_length = ntohl (name_len);
17467 clib_memcpy (mp->stream_name, stream_name, name_len);
17469 vec_free (stream_name);
17477 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
17479 unformat_input_t *input = vam->input;
17480 vl_api_ip_source_and_port_range_check_add_del_t *mp;
17482 u16 *low_ports = 0;
17483 u16 *high_ports = 0;
17486 ip4_address_t ip4_addr;
17487 ip6_address_t ip6_addr;
17496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17498 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
17504 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
17509 else if (unformat (input, "vrf %d", &vrf_id))
17511 else if (unformat (input, "del"))
17513 else if (unformat (input, "port %d", &tmp))
17515 if (tmp == 0 || tmp > 65535)
17517 errmsg ("port %d out of range", tmp);
17521 this_hi = this_low + 1;
17522 vec_add1 (low_ports, this_low);
17523 vec_add1 (high_ports, this_hi);
17525 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
17527 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
17529 errmsg ("incorrect range parameters");
17533 /* Note: in debug CLI +1 is added to high before
17534 passing to real fn that does "the work"
17535 (ip_source_and_port_range_check_add_del).
17536 This fn is a wrapper around the binary API fn a
17537 control plane will call, which expects this increment
17538 to have occurred. Hence letting the binary API control
17539 plane fn do the increment for consistency between VAT
17540 and other control planes.
17543 vec_add1 (low_ports, this_low);
17544 vec_add1 (high_ports, this_hi);
17550 if (prefix_set == 0)
17552 errmsg ("<address>/<mask> not specified");
17558 errmsg ("VRF ID required, not specified");
17565 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17569 if (vec_len (low_ports) == 0)
17571 errmsg ("At least one port or port range required");
17575 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
17577 mp->is_add = is_add;
17582 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
17587 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
17590 mp->mask_length = length;
17591 mp->number_of_ranges = vec_len (low_ports);
17593 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
17594 vec_free (low_ports);
17596 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
17597 vec_free (high_ports);
17599 mp->vrf_id = ntohl (vrf_id);
17607 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
17609 unformat_input_t *input = vam->input;
17610 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
17611 u32 sw_if_index = ~0;
17613 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
17614 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
17618 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17620 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17622 else if (unformat (input, "sw_if_index %d", &sw_if_index))
17624 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
17626 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
17628 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
17630 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
17632 else if (unformat (input, "del"))
17638 if (sw_if_index == ~0)
17640 errmsg ("Interface required but not specified");
17646 errmsg ("VRF ID required but not specified");
17650 if (tcp_out_vrf_id == 0
17651 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
17654 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17658 /* Construct the API message */
17659 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
17661 mp->sw_if_index = ntohl (sw_if_index);
17662 mp->is_add = is_add;
17663 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
17664 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
17665 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
17666 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
17671 /* Wait for a reply... */
17677 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
17679 unformat_input_t *i = vam->input;
17680 vl_api_ipsec_gre_add_del_tunnel_t *mp;
17681 u32 local_sa_id = 0;
17682 u32 remote_sa_id = 0;
17683 ip4_address_t src_address;
17684 ip4_address_t dst_address;
17688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17690 if (unformat (i, "local_sa %d", &local_sa_id))
17692 else if (unformat (i, "remote_sa %d", &remote_sa_id))
17694 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
17696 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
17698 else if (unformat (i, "del"))
17702 clib_warning ("parse error '%U'", format_unformat_error, i);
17707 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
17709 mp->local_sa_id = ntohl (local_sa_id);
17710 mp->remote_sa_id = ntohl (remote_sa_id);
17711 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
17712 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
17713 mp->is_add = is_add;
17721 api_punt (vat_main_t * vam)
17723 unformat_input_t *i = vam->input;
17731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17733 if (unformat (i, "ip %d", &ipv))
17735 else if (unformat (i, "protocol %d", &protocol))
17737 else if (unformat (i, "port %d", &port))
17739 else if (unformat (i, "del"))
17743 clib_warning ("parse error '%U'", format_unformat_error, i);
17750 mp->is_add = (u8) is_add;
17751 mp->ipv = (u8) ipv;
17752 mp->l4_protocol = (u8) protocol;
17753 mp->l4_port = htons ((u16) port);
17760 static void vl_api_ipsec_gre_tunnel_details_t_handler
17761 (vl_api_ipsec_gre_tunnel_details_t * mp)
17763 vat_main_t *vam = &vat_main;
17765 print (vam->ofp, "%11d%15U%15U%14d%14d",
17766 ntohl (mp->sw_if_index),
17767 format_ip4_address, &mp->src_address,
17768 format_ip4_address, &mp->dst_address,
17769 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17772 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17773 (vl_api_ipsec_gre_tunnel_details_t * mp)
17775 vat_main_t *vam = &vat_main;
17776 vat_json_node_t *node = NULL;
17777 struct in_addr ip4;
17779 if (VAT_JSON_ARRAY != vam->json_tree.type)
17781 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17782 vat_json_init_array (&vam->json_tree);
17784 node = vat_json_array_add (&vam->json_tree);
17786 vat_json_init_object (node);
17787 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17788 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17789 vat_json_object_add_ip4 (node, "src_address", ip4);
17790 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17791 vat_json_object_add_ip4 (node, "dst_address", ip4);
17792 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17793 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17797 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17799 unformat_input_t *i = vam->input;
17800 vl_api_ipsec_gre_tunnel_dump_t *mp;
17801 vl_api_control_ping_t *mp_ping;
17803 u8 sw_if_index_set = 0;
17806 /* Parse args required to build the message */
17807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17809 if (unformat (i, "sw_if_index %d", &sw_if_index))
17810 sw_if_index_set = 1;
17815 if (sw_if_index_set == 0)
17820 if (!vam->json_output)
17822 print (vam->ofp, "%11s%15s%15s%14s%14s",
17823 "sw_if_index", "src_address", "dst_address",
17824 "local_sa_id", "remote_sa_id");
17827 /* Get list of gre-tunnel interfaces */
17828 M (IPSEC_GRE_TUNNEL_DUMP, mp);
17830 mp->sw_if_index = htonl (sw_if_index);
17834 /* Use a control ping for synchronization */
17835 M (CONTROL_PING, mp_ping);
17843 api_delete_subif (vat_main_t * vam)
17845 unformat_input_t *i = vam->input;
17846 vl_api_delete_subif_t *mp;
17847 u32 sw_if_index = ~0;
17850 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17852 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17854 if (unformat (i, "sw_if_index %d", &sw_if_index))
17860 if (sw_if_index == ~0)
17862 errmsg ("missing sw_if_index");
17866 /* Construct the API message */
17867 M (DELETE_SUBIF, mp);
17868 mp->sw_if_index = ntohl (sw_if_index);
17875 #define foreach_pbb_vtr_op \
17876 _("disable", L2_VTR_DISABLED) \
17877 _("pop", L2_VTR_POP_2) \
17878 _("push", L2_VTR_PUSH_2)
17881 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17883 unformat_input_t *i = vam->input;
17884 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17885 u32 sw_if_index = ~0, vtr_op = ~0;
17886 u16 outer_tag = ~0;
17887 u8 dmac[6], smac[6];
17888 u8 dmac_set = 0, smac_set = 0;
17894 /* Shut up coverity */
17895 memset (dmac, 0, sizeof (dmac));
17896 memset (smac, 0, sizeof (smac));
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, "vtr_op %d", &vtr_op))
17906 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17909 else if (unformat (i, "translate_pbb_stag"))
17911 if (unformat (i, "%d", &tmp))
17913 vtr_op = L2_VTR_TRANSLATE_2_1;
17919 ("translate_pbb_stag operation requires outer tag definition");
17923 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17925 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17927 else if (unformat (i, "sid %d", &sid))
17929 else if (unformat (i, "vlanid %d", &tmp))
17933 clib_warning ("parse error '%U'", format_unformat_error, i);
17938 if ((sw_if_index == ~0) || (vtr_op == ~0))
17940 errmsg ("missing sw_if_index or vtr operation");
17943 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17944 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17947 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17951 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17952 mp->sw_if_index = ntohl (sw_if_index);
17953 mp->vtr_op = ntohl (vtr_op);
17954 mp->outer_tag = ntohs (outer_tag);
17955 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17956 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17957 mp->b_vlanid = ntohs (vlanid);
17958 mp->i_sid = ntohl (sid);
17966 api_flow_classify_set_interface (vat_main_t * vam)
17968 unformat_input_t *i = vam->input;
17969 vl_api_flow_classify_set_interface_t *mp;
17971 int sw_if_index_set;
17972 u32 ip4_table_index = ~0;
17973 u32 ip6_table_index = ~0;
17977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17979 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17980 sw_if_index_set = 1;
17981 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17982 sw_if_index_set = 1;
17983 else if (unformat (i, "del"))
17985 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17987 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17991 clib_warning ("parse error '%U'", format_unformat_error, i);
17996 if (sw_if_index_set == 0)
17998 errmsg ("missing interface name or sw_if_index");
18002 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
18004 mp->sw_if_index = ntohl (sw_if_index);
18005 mp->ip4_table_index = ntohl (ip4_table_index);
18006 mp->ip6_table_index = ntohl (ip6_table_index);
18007 mp->is_add = is_add;
18015 api_flow_classify_dump (vat_main_t * vam)
18017 unformat_input_t *i = vam->input;
18018 vl_api_flow_classify_dump_t *mp;
18019 vl_api_control_ping_t *mp_ping;
18020 u8 type = FLOW_CLASSIFY_N_TABLES;
18023 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
18027 errmsg ("classify table type must be specified");
18031 if (!vam->json_output)
18033 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18036 M (FLOW_CLASSIFY_DUMP, mp);
18041 /* Use a control ping for synchronization */
18042 M (CONTROL_PING, mp_ping);
18045 /* Wait for a reply... */
18051 api_feature_enable_disable (vat_main_t * vam)
18053 unformat_input_t *i = vam->input;
18054 vl_api_feature_enable_disable_t *mp;
18056 u8 *feature_name = 0;
18057 u32 sw_if_index = ~0;
18061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18063 if (unformat (i, "arc_name %s", &arc_name))
18065 else if (unformat (i, "feature_name %s", &feature_name))
18068 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18070 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18072 else if (unformat (i, "disable"))
18080 errmsg ("missing arc name");
18083 if (vec_len (arc_name) > 63)
18085 errmsg ("arc name too long");
18088 if (feature_name == 0)
18090 errmsg ("missing feature name");
18093 if (vec_len (feature_name) > 63)
18095 errmsg ("feature name too long");
18098 if (sw_if_index == ~0)
18100 errmsg ("missing interface name or sw_if_index");
18104 /* Construct the API message */
18105 M (FEATURE_ENABLE_DISABLE, mp);
18106 mp->sw_if_index = ntohl (sw_if_index);
18107 mp->enable = enable;
18108 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
18109 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
18110 vec_free (arc_name);
18111 vec_free (feature_name);
18119 api_sw_interface_tag_add_del (vat_main_t * vam)
18121 unformat_input_t *i = vam->input;
18122 vl_api_sw_interface_tag_add_del_t *mp;
18123 u32 sw_if_index = ~0;
18128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18130 if (unformat (i, "tag %s", &tag))
18132 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18134 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18136 else if (unformat (i, "del"))
18142 if (sw_if_index == ~0)
18144 errmsg ("missing interface name or sw_if_index");
18148 if (enable && (tag == 0))
18150 errmsg ("no tag specified");
18154 /* Construct the API message */
18155 M (SW_INTERFACE_TAG_ADD_DEL, mp);
18156 mp->sw_if_index = ntohl (sw_if_index);
18157 mp->is_add = enable;
18159 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
18167 static void vl_api_l2_xconnect_details_t_handler
18168 (vl_api_l2_xconnect_details_t * mp)
18170 vat_main_t *vam = &vat_main;
18172 print (vam->ofp, "%15d%15d",
18173 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
18176 static void vl_api_l2_xconnect_details_t_handler_json
18177 (vl_api_l2_xconnect_details_t * mp)
18179 vat_main_t *vam = &vat_main;
18180 vat_json_node_t *node = NULL;
18182 if (VAT_JSON_ARRAY != vam->json_tree.type)
18184 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18185 vat_json_init_array (&vam->json_tree);
18187 node = vat_json_array_add (&vam->json_tree);
18189 vat_json_init_object (node);
18190 vat_json_object_add_uint (node, "rx_sw_if_index",
18191 ntohl (mp->rx_sw_if_index));
18192 vat_json_object_add_uint (node, "tx_sw_if_index",
18193 ntohl (mp->tx_sw_if_index));
18197 api_l2_xconnect_dump (vat_main_t * vam)
18199 vl_api_l2_xconnect_dump_t *mp;
18200 vl_api_control_ping_t *mp_ping;
18203 if (!vam->json_output)
18205 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
18208 M (L2_XCONNECT_DUMP, mp);
18212 /* Use a control ping for synchronization */
18213 M (CONTROL_PING, mp_ping);
18221 api_sw_interface_set_mtu (vat_main_t * vam)
18223 unformat_input_t *i = vam->input;
18224 vl_api_sw_interface_set_mtu_t *mp;
18225 u32 sw_if_index = ~0;
18229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18231 if (unformat (i, "mtu %d", &mtu))
18233 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18235 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18241 if (sw_if_index == ~0)
18243 errmsg ("missing interface name or sw_if_index");
18249 errmsg ("no mtu specified");
18253 /* Construct the API message */
18254 M (SW_INTERFACE_SET_MTU, mp);
18255 mp->sw_if_index = ntohl (sw_if_index);
18256 mp->mtu = ntohs ((u16) mtu);
18265 q_or_quit (vat_main_t * vam)
18267 #if VPP_API_TEST_BUILTIN == 0
18268 longjmp (vam->jump_buf, 1);
18270 return 0; /* not so much */
18274 q (vat_main_t * vam)
18276 return q_or_quit (vam);
18280 quit (vat_main_t * vam)
18282 return q_or_quit (vam);
18286 comment (vat_main_t * vam)
18292 cmd_cmp (void *a1, void *a2)
18297 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
18301 help (vat_main_t * vam)
18306 unformat_input_t *i = vam->input;
18309 if (unformat (i, "%s", &name))
18313 vec_add1 (name, 0);
18315 hs = hash_get_mem (vam->help_by_name, name);
18317 print (vam->ofp, "usage: %s %s", name, hs[0]);
18319 print (vam->ofp, "No such msg / command '%s'", name);
18324 print (vam->ofp, "Help is available for the following:");
18327 hash_foreach_pair (p, vam->function_by_name,
18329 vec_add1 (cmds, (u8 *)(p->key));
18333 vec_sort_with_function (cmds, cmd_cmp);
18335 for (j = 0; j < vec_len (cmds); j++)
18336 print (vam->ofp, "%s", cmds[j]);
18343 set (vat_main_t * vam)
18345 u8 *name = 0, *value = 0;
18346 unformat_input_t *i = vam->input;
18348 if (unformat (i, "%s", &name))
18350 /* The input buffer is a vector, not a string. */
18351 value = vec_dup (i->buffer);
18352 vec_delete (value, i->index, 0);
18353 /* Almost certainly has a trailing newline */
18354 if (value[vec_len (value) - 1] == '\n')
18355 value[vec_len (value) - 1] = 0;
18356 /* Make sure it's a proper string, one way or the other */
18357 vec_add1 (value, 0);
18358 (void) clib_macro_set_value (&vam->macro_main,
18359 (char *) name, (char *) value);
18362 errmsg ("usage: set <name> <value>");
18370 unset (vat_main_t * vam)
18374 if (unformat (vam->input, "%s", &name))
18375 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
18376 errmsg ("unset: %s wasn't set", name);
18389 macro_sort_cmp (void *a1, void *a2)
18391 macro_sort_t *s1 = a1;
18392 macro_sort_t *s2 = a2;
18394 return strcmp ((char *) (s1->name), (char *) (s2->name));
18398 dump_macro_table (vat_main_t * vam)
18400 macro_sort_t *sort_me = 0, *sm;
18405 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
18407 vec_add2 (sort_me, sm, 1);
18408 sm->name = (u8 *)(p->key);
18409 sm->value = (u8 *) (p->value[0]);
18413 vec_sort_with_function (sort_me, macro_sort_cmp);
18415 if (vec_len (sort_me))
18416 print (vam->ofp, "%-15s%s", "Name", "Value");
18418 print (vam->ofp, "The macro table is empty...");
18420 for (i = 0; i < vec_len (sort_me); i++)
18421 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
18426 dump_node_table (vat_main_t * vam)
18429 vlib_node_t *node, *next_node;
18431 if (vec_len (vam->graph_nodes) == 0)
18433 print (vam->ofp, "Node table empty, issue get_node_graph...");
18437 for (i = 0; i < vec_len (vam->graph_nodes); i++)
18439 node = vam->graph_nodes[i];
18440 print (vam->ofp, "[%d] %s", i, node->name);
18441 for (j = 0; j < vec_len (node->next_nodes); j++)
18443 if (node->next_nodes[j] != ~0)
18445 next_node = vam->graph_nodes[node->next_nodes[j]];
18446 print (vam->ofp, " [%d] %s", j, next_node->name);
18454 value_sort_cmp (void *a1, void *a2)
18456 name_sort_t *n1 = a1;
18457 name_sort_t *n2 = a2;
18459 if (n1->value < n2->value)
18461 if (n1->value > n2->value)
18468 dump_msg_api_table (vat_main_t * vam)
18470 api_main_t *am = &api_main;
18471 name_sort_t *nses = 0, *ns;
18476 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
18478 vec_add2 (nses, ns, 1);
18479 ns->name = (u8 *)(hp->key);
18480 ns->value = (u32) hp->value[0];
18484 vec_sort_with_function (nses, value_sort_cmp);
18486 for (i = 0; i < vec_len (nses); i++)
18487 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
18493 get_msg_id (vat_main_t * vam)
18498 if (unformat (vam->input, "%s", &name_and_crc))
18500 message_index = vl_api_get_msg_index (name_and_crc);
18501 if (message_index == ~0)
18503 print (vam->ofp, " '%s' not found", name_and_crc);
18506 print (vam->ofp, " '%s' has message index %d",
18507 name_and_crc, message_index);
18510 errmsg ("name_and_crc required...");
18515 search_node_table (vat_main_t * vam)
18517 unformat_input_t *line_input = vam->input;
18520 vlib_node_t *node, *next_node;
18523 if (vam->graph_node_index_by_name == 0)
18525 print (vam->ofp, "Node table empty, issue get_node_graph...");
18529 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
18531 if (unformat (line_input, "%s", &node_to_find))
18533 vec_add1 (node_to_find, 0);
18534 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
18537 print (vam->ofp, "%s not found...", node_to_find);
18540 node = vam->graph_nodes[p[0]];
18541 print (vam->ofp, "[%d] %s", p[0], node->name);
18542 for (j = 0; j < vec_len (node->next_nodes); j++)
18544 if (node->next_nodes[j] != ~0)
18546 next_node = vam->graph_nodes[node->next_nodes[j]];
18547 print (vam->ofp, " [%d] %s", j, next_node->name);
18554 clib_warning ("parse error '%U'", format_unformat_error,
18560 vec_free (node_to_find);
18569 script (vat_main_t * vam)
18571 #if (VPP_API_TEST_BUILTIN==0)
18573 char *save_current_file;
18574 unformat_input_t save_input;
18575 jmp_buf save_jump_buf;
18576 u32 save_line_number;
18578 FILE *new_fp, *save_ifp;
18580 if (unformat (vam->input, "%s", &s))
18582 new_fp = fopen ((char *) s, "r");
18585 errmsg ("Couldn't open script file %s", s);
18592 errmsg ("Missing script name");
18596 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
18597 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
18598 save_ifp = vam->ifp;
18599 save_line_number = vam->input_line_number;
18600 save_current_file = (char *) vam->current_file;
18602 vam->input_line_number = 0;
18604 vam->current_file = s;
18607 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
18608 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
18609 vam->ifp = save_ifp;
18610 vam->input_line_number = save_line_number;
18611 vam->current_file = (u8 *) save_current_file;
18616 clib_warning ("use the exec command...");
18622 echo (vat_main_t * vam)
18624 print (vam->ofp, "%v", vam->input->buffer);
18628 /* List of API message constructors, CLI names map to api_xxx */
18629 #define foreach_vpe_api_msg \
18630 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
18631 _(sw_interface_dump,"") \
18632 _(sw_interface_set_flags, \
18633 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
18634 _(sw_interface_add_del_address, \
18635 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
18636 _(sw_interface_set_table, \
18637 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
18638 _(sw_interface_set_mpls_enable, \
18639 "<intfc> | sw_if_index [disable | dis]") \
18640 _(sw_interface_set_vpath, \
18641 "<intfc> | sw_if_index <id> enable | disable") \
18642 _(sw_interface_set_vxlan_bypass, \
18643 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
18644 _(sw_interface_set_l2_xconnect, \
18645 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18646 "enable | disable") \
18647 _(sw_interface_set_l2_bridge, \
18648 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
18649 "[shg <split-horizon-group>] [bvi]\n" \
18650 "enable | disable") \
18651 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
18652 _(bridge_domain_add_del, \
18653 "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") \
18654 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
18656 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
18657 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
18658 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
18660 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
18662 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
18664 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
18666 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
18668 "<vpp-if-name> | sw_if_index <id>") \
18669 _(sw_interface_tap_dump, "") \
18670 _(ip_add_del_route, \
18671 "<addr>/<mask> via <addr> [table-id <n>]\n" \
18672 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18673 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18674 "[multipath] [count <n>]") \
18675 _(ip_mroute_add_del, \
18676 "<src> <grp>/<mask> [table-id <n>]\n" \
18677 "[<intfc> | sw_if_index <id>] [local] [del]") \
18678 _(mpls_route_add_del, \
18679 "<label> <eos> via <addr> [table-id <n>]\n" \
18680 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18681 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18682 "[multipath] [count <n>]") \
18683 _(mpls_ip_bind_unbind, \
18684 "<label> <addr/len>") \
18685 _(mpls_tunnel_add_del, \
18686 " via <addr> [table-id <n>]\n" \
18687 "sw_if_index <id>] [l2] [del]") \
18688 _(proxy_arp_add_del, \
18689 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
18690 _(proxy_arp_intfc_enable_disable, \
18691 "<intfc> | sw_if_index <id> enable | disable") \
18692 _(sw_interface_set_unnumbered, \
18693 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
18694 _(ip_neighbor_add_del, \
18695 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
18696 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
18697 _(reset_vrf, "vrf <id> [ipv6]") \
18698 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
18699 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
18700 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
18701 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
18702 "[outer_vlan_id_any][inner_vlan_id_any]") \
18703 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
18704 _(reset_fib, "vrf <n> [ipv6]") \
18705 _(dhcp_proxy_config, \
18706 "svr <v46-address> src <v46-address>\n" \
18707 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
18708 _(dhcp_proxy_set_vss, \
18709 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
18710 _(dhcp_proxy_dump, "ip6") \
18711 _(dhcp_client_config, \
18712 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
18713 _(set_ip_flow_hash, \
18714 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
18715 _(sw_interface_ip6_enable_disable, \
18716 "<intfc> | sw_if_index <id> enable | disable") \
18717 _(sw_interface_ip6_set_link_local_address, \
18718 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
18719 _(ip6nd_proxy_add_del, \
18720 "<intfc> | sw_if_index <id> <ip6-address>") \
18721 _(ip6nd_proxy_dump, "") \
18722 _(sw_interface_ip6nd_ra_prefix, \
18723 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
18724 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
18725 "[nolink] [isno]") \
18726 _(sw_interface_ip6nd_ra_config, \
18727 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
18728 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
18729 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
18730 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
18731 _(l2_patch_add_del, \
18732 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18733 "enable | disable") \
18734 _(sr_localsid_add_del, \
18735 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
18736 "fib-table <num> (end.psp) sw_if_index <num>") \
18737 _(classify_add_del_table, \
18738 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
18739 " [del] [del-chain] mask <mask-value>\n" \
18740 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
18741 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
18742 _(classify_add_del_session, \
18743 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
18744 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
18745 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
18746 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
18747 _(classify_set_interface_ip_table, \
18748 "<intfc> | sw_if_index <nn> table <nn>") \
18749 _(classify_set_interface_l2_tables, \
18750 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18751 " [other-table <nn>]") \
18752 _(get_node_index, "node <node-name") \
18753 _(add_node_next, "node <node-name> next <next-node-name>") \
18754 _(l2tpv3_create_tunnel, \
18755 "client_address <ip6-addr> our_address <ip6-addr>\n" \
18756 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
18757 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
18758 _(l2tpv3_set_tunnel_cookies, \
18759 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
18760 "[new_remote_cookie <nn>]\n") \
18761 _(l2tpv3_interface_enable_disable, \
18762 "<intfc> | sw_if_index <nn> enable | disable") \
18763 _(l2tpv3_set_lookup_key, \
18764 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18765 _(sw_if_l2tpv3_tunnel_dump, "") \
18766 _(vxlan_add_del_tunnel, \
18767 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18768 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18769 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18770 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18771 _(gre_add_del_tunnel, \
18772 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18773 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18774 _(l2_fib_clear_table, "") \
18775 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18776 _(l2_interface_vlan_tag_rewrite, \
18777 "<intfc> | sw_if_index <nn> \n" \
18778 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18779 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18780 _(create_vhost_user_if, \
18781 "socket <filename> [server] [renumber <dev_instance>] " \
18782 "[mac <mac_address>] " \
18783 "[mode <interrupt | polling>]") \
18784 _(modify_vhost_user_if, \
18785 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18786 "[server] [renumber <dev_instance>] " \
18787 "[mode <interrupt | polling>]") \
18788 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18789 _(sw_interface_vhost_user_dump, "") \
18790 _(show_version, "") \
18791 _(vxlan_gpe_add_del_tunnel, \
18792 "local <addr> remote <addr> vni <nn>\n" \
18793 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18794 "[next-ethernet] [next-nsh]\n") \
18795 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18796 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18797 _(interface_name_renumber, \
18798 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18799 _(input_acl_set_interface, \
18800 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18801 " [l2-table <nn>] [del]") \
18802 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18803 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18804 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18805 _(ip_dump, "ipv4 | ipv6") \
18806 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18807 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18809 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18810 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18811 " integ_alg <alg> integ_key <hex>") \
18812 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18813 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18814 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18815 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18816 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18817 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18818 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18819 "(auth_data 0x<data> | auth_data <data>)") \
18820 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18821 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18822 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18823 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18824 "(local|remote)") \
18825 _(ikev2_set_local_key, "file <absolute_file_path>") \
18826 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
18827 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18828 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18829 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
18830 _(ikev2_initiate_sa_init, "<profile_name>") \
18831 _(ikev2_initiate_del_ike_sa, "<ispi>") \
18832 _(ikev2_initiate_del_child_sa, "<ispi>") \
18833 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
18834 _(delete_loopback,"sw_if_index <nn>") \
18835 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18836 _(map_add_domain, \
18837 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18838 "ip6-src <ip6addr> " \
18839 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18840 _(map_del_domain, "index <n>") \
18841 _(map_add_del_rule, \
18842 "index <n> psid <n> dst <ip6addr> [del]") \
18843 _(map_domain_dump, "") \
18844 _(map_rule_dump, "index <map-domain>") \
18845 _(want_interface_events, "enable|disable") \
18846 _(want_stats,"enable|disable") \
18847 _(get_first_msg_id, "client <name>") \
18848 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18849 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18850 "fib-id <nn> [ip4][ip6][default]") \
18851 _(get_node_graph, " ") \
18852 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18853 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18854 _(ioam_disable, "") \
18855 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18856 " sw_if_index <sw_if_index> p <priority> " \
18857 "w <weight>] [del]") \
18858 _(one_add_del_locator, "locator-set <locator_name> " \
18859 "iface <intf> | sw_if_index <sw_if_index> " \
18860 "p <priority> w <weight> [del]") \
18861 _(one_add_del_local_eid,"vni <vni> eid " \
18862 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18863 "locator-set <locator_name> [del]" \
18864 "[key-id sha1|sha256 secret-key <secret-key>]")\
18865 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
18866 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
18867 _(one_enable_disable, "enable|disable") \
18868 _(one_map_register_enable_disable, "enable|disable") \
18869 _(one_rloc_probe_enable_disable, "enable|disable") \
18870 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18872 "rloc <locator> p <prio> " \
18873 "w <weight> [rloc <loc> ... ] " \
18874 "action <action> [del-all]") \
18875 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18877 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18878 _(one_use_petr, "ip-address> | disable") \
18879 _(one_map_request_mode, "src-dst|dst-only") \
18880 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18881 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18882 _(one_locator_set_dump, "[local | remote]") \
18883 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
18884 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18885 "[local] | [remote]") \
18886 _(one_stats_enable_disable, "enable|disalbe") \
18887 _(show_one_stats_enable_disable, "") \
18888 _(one_eid_table_vni_dump, "") \
18889 _(one_eid_table_map_dump, "l2|l3") \
18890 _(one_map_resolver_dump, "") \
18891 _(one_map_server_dump, "") \
18892 _(one_adjacencies_get, "vni <vni>") \
18893 _(show_one_rloc_probe_state, "") \
18894 _(show_one_map_register_state, "") \
18895 _(show_one_status, "") \
18896 _(one_stats_dump, "") \
18897 _(one_stats_flush, "") \
18898 _(one_get_map_request_itr_rlocs, "") \
18899 _(show_one_pitr, "") \
18900 _(show_one_use_petr, "") \
18901 _(show_one_map_request_mode, "") \
18902 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
18903 " sw_if_index <sw_if_index> p <priority> " \
18904 "w <weight>] [del]") \
18905 _(lisp_add_del_locator, "locator-set <locator_name> " \
18906 "iface <intf> | sw_if_index <sw_if_index> " \
18907 "p <priority> w <weight> [del]") \
18908 _(lisp_add_del_local_eid,"vni <vni> eid " \
18909 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18910 "locator-set <locator_name> [del]" \
18911 "[key-id sha1|sha256 secret-key <secret-key>]") \
18912 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18913 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18914 _(lisp_enable_disable, "enable|disable") \
18915 _(lisp_map_register_enable_disable, "enable|disable") \
18916 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18917 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18919 "rloc <locator> p <prio> " \
18920 "w <weight> [rloc <loc> ... ] " \
18921 "action <action> [del-all]") \
18922 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18924 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18925 _(lisp_use_petr, "<ip-address> | disable") \
18926 _(lisp_map_request_mode, "src-dst|dst-only") \
18927 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18928 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18929 _(lisp_locator_set_dump, "[local | remote]") \
18930 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18931 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18932 "[local] | [remote]") \
18933 _(lisp_eid_table_vni_dump, "") \
18934 _(lisp_eid_table_map_dump, "l2|l3") \
18935 _(lisp_map_resolver_dump, "") \
18936 _(lisp_map_server_dump, "") \
18937 _(lisp_adjacencies_get, "vni <vni>") \
18938 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18939 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18940 _(gpe_set_encap_mode, "lisp|vxlan") \
18941 _(gpe_get_encap_mode, "") \
18942 _(lisp_gpe_add_del_iface, "up|down") \
18943 _(lisp_gpe_enable_disable, "enable|disable") \
18944 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18945 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18946 _(show_lisp_rloc_probe_state, "") \
18947 _(show_lisp_map_register_state, "") \
18948 _(show_lisp_status, "") \
18949 _(lisp_get_map_request_itr_rlocs, "") \
18950 _(show_lisp_pitr, "") \
18951 _(show_lisp_use_petr, "") \
18952 _(show_lisp_map_request_mode, "") \
18953 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18954 _(af_packet_delete, "name <host interface name>") \
18955 _(policer_add_del, "name <policer name> <params> [del]") \
18956 _(policer_dump, "[name <policer name>]") \
18957 _(policer_classify_set_interface, \
18958 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18959 " [l2-table <nn>] [del]") \
18960 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18961 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18962 "[master|slave]") \
18963 _(netmap_delete, "name <interface name>") \
18964 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18965 _(mpls_fib_dump, "") \
18966 _(classify_table_ids, "") \
18967 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18968 _(classify_table_info, "table_id <nn>") \
18969 _(classify_session_dump, "table_id <nn>") \
18970 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18971 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18972 "[template_interval <nn>] [udp_checksum]") \
18973 _(ipfix_exporter_dump, "") \
18974 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18975 _(ipfix_classify_stream_dump, "") \
18976 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18977 _(ipfix_classify_table_dump, "") \
18978 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18979 _(sw_interface_span_dump, "") \
18980 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18981 _(pg_create_interface, "if_id <nn>") \
18982 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18983 _(pg_enable_disable, "[stream <id>] disable") \
18984 _(ip_source_and_port_range_check_add_del, \
18985 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18986 _(ip_source_and_port_range_check_interface_add_del, \
18987 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18988 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18989 _(ipsec_gre_add_del_tunnel, \
18990 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18991 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18992 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18993 _(l2_interface_pbb_tag_rewrite, \
18994 "<intfc> | sw_if_index <nn> \n" \
18995 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18996 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18997 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18998 _(flow_classify_set_interface, \
18999 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
19000 _(flow_classify_dump, "type [ip4|ip6]") \
19001 _(ip_fib_dump, "") \
19002 _(ip_mfib_dump, "") \
19003 _(ip6_fib_dump, "") \
19004 _(ip6_mfib_dump, "") \
19005 _(feature_enable_disable, "arc_name <arc_name> " \
19006 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
19007 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
19009 _(l2_xconnect_dump, "") \
19010 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
19011 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
19012 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
19014 /* List of command functions, CLI names map directly to functions */
19015 #define foreach_cli_function \
19016 _(comment, "usage: comment <ignore-rest-of-line>") \
19017 _(dump_interface_table, "usage: dump_interface_table") \
19018 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
19019 _(dump_ipv4_table, "usage: dump_ipv4_table") \
19020 _(dump_ipv6_table, "usage: dump_ipv6_table") \
19021 _(dump_stats_table, "usage: dump_stats_table") \
19022 _(dump_macro_table, "usage: dump_macro_table ") \
19023 _(dump_node_table, "usage: dump_node_table") \
19024 _(dump_msg_api_table, "usage: dump_msg_api_table") \
19025 _(get_msg_id, "usage: get_msg_id name_and_crc") \
19026 _(echo, "usage: echo <message>") \
19027 _(exec, "usage: exec <vpe-debug-CLI-command>") \
19028 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
19029 _(help, "usage: help") \
19030 _(q, "usage: quit") \
19031 _(quit, "usage: quit") \
19032 _(search_node_table, "usage: search_node_table <name>...") \
19033 _(set, "usage: set <variable-name> <value>") \
19034 _(script, "usage: script <file-name>") \
19035 _(unset, "usage: unset <variable-name>")
19038 static void vl_api_##n##_t_handler_uni \
19039 (vl_api_##n##_t * mp) \
19041 vat_main_t * vam = &vat_main; \
19042 if (vam->json_output) { \
19043 vl_api_##n##_t_handler_json(mp); \
19045 vl_api_##n##_t_handler(mp); \
19048 foreach_vpe_api_reply_msg;
19049 #if VPP_API_TEST_BUILTIN == 0
19050 foreach_standalone_reply_msg;
19055 vat_api_hookup (vat_main_t * vam)
19058 vl_msg_api_set_handlers(VL_API_##N, #n, \
19059 vl_api_##n##_t_handler_uni, \
19061 vl_api_##n##_t_endian, \
19062 vl_api_##n##_t_print, \
19063 sizeof(vl_api_##n##_t), 1);
19064 foreach_vpe_api_reply_msg;
19065 #if VPP_API_TEST_BUILTIN == 0
19066 foreach_standalone_reply_msg;
19070 #if (VPP_API_TEST_BUILTIN==0)
19071 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
19073 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
19075 vam->function_by_name = hash_create_string (0, sizeof (uword));
19077 vam->help_by_name = hash_create_string (0, sizeof (uword));
19080 /* API messages we can send */
19081 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
19082 foreach_vpe_api_msg;
19086 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
19087 foreach_vpe_api_msg;
19090 /* CLI functions */
19091 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
19092 foreach_cli_function;
19096 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
19097 foreach_cli_function;
19101 #if VPP_API_TEST_BUILTIN
19102 static clib_error_t *
19103 vat_api_hookup_shim (vlib_main_t * vm)
19105 vat_api_hookup (&vat_main);
19109 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
19113 * fd.io coding-style-patch-verification: ON
19116 * eval: (c-set-style "gnu")