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 _(gpe_add_del_fwd_entry_reply) \
4242 _(gpe_enable_disable_reply) \
4243 _(gpe_set_encap_mode_reply) \
4244 _(gpe_add_del_iface_reply) \
4245 _(vxlan_gpe_add_del_tunnel_reply) \
4246 _(af_packet_delete_reply) \
4247 _(policer_classify_set_interface_reply) \
4248 _(netmap_create_reply) \
4249 _(netmap_delete_reply) \
4250 _(set_ipfix_exporter_reply) \
4251 _(set_ipfix_classify_stream_reply) \
4252 _(ipfix_classify_table_add_del_reply) \
4253 _(flow_classify_set_interface_reply) \
4254 _(sw_interface_span_enable_disable_reply) \
4255 _(pg_capture_reply) \
4256 _(pg_enable_disable_reply) \
4257 _(ip_source_and_port_range_check_add_del_reply) \
4258 _(ip_source_and_port_range_check_interface_add_del_reply)\
4259 _(delete_subif_reply) \
4260 _(l2_interface_pbb_tag_rewrite_reply) \
4262 _(feature_enable_disable_reply) \
4263 _(sw_interface_tag_add_del_reply) \
4264 _(sw_interface_set_mtu_reply)
4267 static void vl_api_##n##_t_handler \
4268 (vl_api_##n##_t * mp) \
4270 vat_main_t * vam = &vat_main; \
4271 i32 retval = ntohl(mp->retval); \
4272 if (vam->async_mode) { \
4273 vam->async_errors += (retval < 0); \
4275 vam->retval = retval; \
4276 vam->result_ready = 1; \
4279 foreach_standard_reply_retval_handler;
4283 static void vl_api_##n##_t_handler_json \
4284 (vl_api_##n##_t * mp) \
4286 vat_main_t * vam = &vat_main; \
4287 vat_json_node_t node; \
4288 vat_json_init_object(&node); \
4289 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
4290 vat_json_print(vam->ofp, &node); \
4291 vam->retval = ntohl(mp->retval); \
4292 vam->result_ready = 1; \
4294 foreach_standard_reply_retval_handler;
4298 * Table of message reply handlers, must include boilerplate handlers
4302 #define foreach_vpe_api_reply_msg \
4303 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4304 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
4305 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4306 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4307 _(CONTROL_PING_REPLY, control_ping_reply) \
4308 _(CLI_REPLY, cli_reply) \
4309 _(CLI_INBAND_REPLY, cli_inband_reply) \
4310 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4311 sw_interface_add_del_address_reply) \
4312 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4313 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4314 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4315 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4316 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4317 sw_interface_set_l2_xconnect_reply) \
4318 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4319 sw_interface_set_l2_bridge_reply) \
4320 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4321 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4322 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
4323 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
4324 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4325 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
4326 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
4327 _(L2_FLAGS_REPLY, l2_flags_reply) \
4328 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4329 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4330 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4331 _(TAP_DELETE_REPLY, tap_delete_reply) \
4332 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4333 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4334 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4335 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4336 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4337 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4338 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4339 proxy_arp_intfc_enable_disable_reply) \
4340 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4341 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4342 sw_interface_set_unnumbered_reply) \
4343 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4344 _(RESET_VRF_REPLY, reset_vrf_reply) \
4345 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4346 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4347 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4348 _(RESET_FIB_REPLY, reset_fib_reply) \
4349 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4350 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4351 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4352 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4353 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4354 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4355 sw_interface_ip6_enable_disable_reply) \
4356 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4357 sw_interface_ip6_set_link_local_address_reply) \
4358 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
4359 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
4360 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4361 sw_interface_ip6nd_ra_prefix_reply) \
4362 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4363 sw_interface_ip6nd_ra_config_reply) \
4364 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4365 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4366 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
4367 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
4368 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
4369 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
4370 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
4371 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4372 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4373 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4374 classify_set_interface_ip_table_reply) \
4375 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4376 classify_set_interface_l2_tables_reply) \
4377 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4378 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4379 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4380 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4381 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4382 l2tpv3_interface_enable_disable_reply) \
4383 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4384 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4385 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4386 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4387 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4388 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4389 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4390 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4391 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4392 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4393 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4394 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4395 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4396 _(SHOW_VERSION_REPLY, show_version_reply) \
4397 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4398 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4399 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4400 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4401 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4402 _(IP4_ARP_EVENT, ip4_arp_event) \
4403 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4404 _(IP6_ND_EVENT, ip6_nd_event) \
4405 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4406 _(IP_ADDRESS_DETAILS, ip_address_details) \
4407 _(IP_DETAILS, ip_details) \
4408 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4409 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4410 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4411 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4412 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4413 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4414 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4415 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4416 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4417 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4418 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4419 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4420 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4421 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4422 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4423 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4424 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4425 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4426 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4427 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4428 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4429 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4430 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4431 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4432 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4433 _(MAP_RULE_DETAILS, map_rule_details) \
4434 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4435 _(WANT_STATS_REPLY, want_stats_reply) \
4436 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4437 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4438 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4439 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4440 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4441 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4442 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4443 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4444 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4445 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4446 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4447 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4448 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4449 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4450 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4451 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4452 one_map_register_enable_disable_reply) \
4453 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4454 one_rloc_probe_enable_disable_reply) \
4455 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4456 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
4457 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4458 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4459 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4460 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4461 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4462 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4463 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4464 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4465 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4466 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4467 _(ONE_STATS_DETAILS, one_stats_details) \
4468 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
4469 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
4470 show_one_stats_enable_disable_reply) \
4471 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4472 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4473 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4474 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4475 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4476 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4477 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4478 gpe_fwd_entry_path_details) \
4479 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4480 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4481 one_add_del_map_request_itr_rlocs_reply) \
4482 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4483 one_get_map_request_itr_rlocs_reply) \
4484 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4485 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
4486 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4487 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4488 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4489 show_one_map_register_state_reply) \
4490 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4491 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4492 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4493 _(POLICER_DETAILS, policer_details) \
4494 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4495 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4496 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4497 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4498 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4499 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4500 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4501 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4502 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4503 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4504 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4505 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4506 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4507 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4508 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4509 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4510 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4511 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4512 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4513 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4514 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4515 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4516 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4517 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4518 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4519 ip_source_and_port_range_check_add_del_reply) \
4520 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4521 ip_source_and_port_range_check_interface_add_del_reply) \
4522 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4523 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4524 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4525 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4526 _(PUNT_REPLY, punt_reply) \
4527 _(IP_FIB_DETAILS, ip_fib_details) \
4528 _(IP6_FIB_DETAILS, ip6_fib_details) \
4529 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4530 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4531 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4532 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4533 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4534 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4536 #define foreach_standalone_reply_msg \
4537 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
4538 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4539 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4540 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4541 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4542 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
4551 #define STR_VTR_OP_CASE(op) \
4552 case L2_VTR_ ## op: \
4556 str_vtr_op (u32 vtr_op)
4560 STR_VTR_OP_CASE (DISABLED);
4561 STR_VTR_OP_CASE (PUSH_1);
4562 STR_VTR_OP_CASE (PUSH_2);
4563 STR_VTR_OP_CASE (POP_1);
4564 STR_VTR_OP_CASE (POP_2);
4565 STR_VTR_OP_CASE (TRANSLATE_1_1);
4566 STR_VTR_OP_CASE (TRANSLATE_1_2);
4567 STR_VTR_OP_CASE (TRANSLATE_2_1);
4568 STR_VTR_OP_CASE (TRANSLATE_2_2);
4575 dump_sub_interface_table (vat_main_t * vam)
4577 const sw_interface_subif_t *sub = NULL;
4579 if (vam->json_output)
4582 ("JSON output supported only for VPE API calls and dump_stats_table");
4587 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4588 "Interface", "sw_if_index",
4589 "sub id", "dot1ad", "tags", "outer id",
4590 "inner id", "exact", "default", "outer any", "inner any");
4592 vec_foreach (sub, vam->sw_if_subif_table)
4595 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4596 sub->interface_name,
4598 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4599 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4600 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4601 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4602 if (sub->vtr_op != L2_VTR_DISABLED)
4605 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4606 "tag1: %d tag2: %d ]",
4607 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4608 sub->vtr_tag1, sub->vtr_tag2);
4616 name_sort_cmp (void *a1, void *a2)
4618 name_sort_t *n1 = a1;
4619 name_sort_t *n2 = a2;
4621 return strcmp ((char *) n1->name, (char *) n2->name);
4625 dump_interface_table (vat_main_t * vam)
4628 name_sort_t *nses = 0, *ns;
4630 if (vam->json_output)
4633 ("JSON output supported only for VPE API calls and dump_stats_table");
4638 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4640 vec_add2 (nses, ns, 1);
4641 ns->name = (u8 *)(p->key);
4642 ns->value = (u32) p->value[0];
4646 vec_sort_with_function (nses, name_sort_cmp);
4648 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4649 vec_foreach (ns, nses)
4651 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4658 dump_ip_table (vat_main_t * vam, int is_ipv6)
4660 const ip_details_t *det = NULL;
4661 const ip_address_details_t *address = NULL;
4664 print (vam->ofp, "%-12s", "sw_if_index");
4666 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4673 print (vam->ofp, "%-12d", i);
4674 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4679 vec_foreach (address, det->addr)
4683 is_ipv6 ? format_ip6_address : format_ip4_address,
4684 address->ip, address->prefix_length);
4692 dump_ipv4_table (vat_main_t * vam)
4694 if (vam->json_output)
4697 ("JSON output supported only for VPE API calls and dump_stats_table");
4701 return dump_ip_table (vam, 0);
4705 dump_ipv6_table (vat_main_t * vam)
4707 if (vam->json_output)
4710 ("JSON output supported only for VPE API calls and dump_stats_table");
4714 return dump_ip_table (vam, 1);
4718 counter_type_to_str (u8 counter_type, u8 is_combined)
4722 switch (counter_type)
4724 case VNET_INTERFACE_COUNTER_DROP:
4726 case VNET_INTERFACE_COUNTER_PUNT:
4728 case VNET_INTERFACE_COUNTER_IP4:
4730 case VNET_INTERFACE_COUNTER_IP6:
4732 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4734 case VNET_INTERFACE_COUNTER_RX_MISS:
4736 case VNET_INTERFACE_COUNTER_RX_ERROR:
4738 case VNET_INTERFACE_COUNTER_TX_ERROR:
4741 return "INVALID-COUNTER-TYPE";
4746 switch (counter_type)
4748 case VNET_INTERFACE_COUNTER_RX:
4750 case VNET_INTERFACE_COUNTER_TX:
4753 return "INVALID-COUNTER-TYPE";
4759 dump_stats_table (vat_main_t * vam)
4761 vat_json_node_t node;
4762 vat_json_node_t *msg_array;
4763 vat_json_node_t *msg;
4764 vat_json_node_t *counter_array;
4765 vat_json_node_t *counter;
4766 interface_counter_t c;
4768 ip4_fib_counter_t *c4;
4769 ip6_fib_counter_t *c6;
4770 ip4_nbr_counter_t *n4;
4771 ip6_nbr_counter_t *n6;
4774 if (!vam->json_output)
4776 clib_warning ("dump_stats_table supported only in JSON format");
4780 vat_json_init_object (&node);
4782 /* interface counters */
4783 msg_array = vat_json_object_add (&node, "interface_counters");
4784 vat_json_init_array (msg_array);
4785 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4787 msg = vat_json_array_add (msg_array);
4788 vat_json_init_object (msg);
4789 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4790 (u8 *) counter_type_to_str (i, 0));
4791 vat_json_object_add_int (msg, "is_combined", 0);
4792 counter_array = vat_json_object_add (msg, "data");
4793 vat_json_init_array (counter_array);
4794 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4796 packets = vam->simple_interface_counters[i][j];
4797 vat_json_array_add_uint (counter_array, packets);
4800 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4802 msg = vat_json_array_add (msg_array);
4803 vat_json_init_object (msg);
4804 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4805 (u8 *) counter_type_to_str (i, 1));
4806 vat_json_object_add_int (msg, "is_combined", 1);
4807 counter_array = vat_json_object_add (msg, "data");
4808 vat_json_init_array (counter_array);
4809 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4811 c = vam->combined_interface_counters[i][j];
4812 counter = vat_json_array_add (counter_array);
4813 vat_json_init_object (counter);
4814 vat_json_object_add_uint (counter, "packets", c.packets);
4815 vat_json_object_add_uint (counter, "bytes", c.bytes);
4819 /* ip4 fib counters */
4820 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4821 vat_json_init_array (msg_array);
4822 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4824 msg = vat_json_array_add (msg_array);
4825 vat_json_init_object (msg);
4826 vat_json_object_add_uint (msg, "vrf_id",
4827 vam->ip4_fib_counters_vrf_id_by_index[i]);
4828 counter_array = vat_json_object_add (msg, "c");
4829 vat_json_init_array (counter_array);
4830 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4832 counter = vat_json_array_add (counter_array);
4833 vat_json_init_object (counter);
4834 c4 = &vam->ip4_fib_counters[i][j];
4835 vat_json_object_add_ip4 (counter, "address", c4->address);
4836 vat_json_object_add_uint (counter, "address_length",
4837 c4->address_length);
4838 vat_json_object_add_uint (counter, "packets", c4->packets);
4839 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4843 /* ip6 fib counters */
4844 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4845 vat_json_init_array (msg_array);
4846 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4848 msg = vat_json_array_add (msg_array);
4849 vat_json_init_object (msg);
4850 vat_json_object_add_uint (msg, "vrf_id",
4851 vam->ip6_fib_counters_vrf_id_by_index[i]);
4852 counter_array = vat_json_object_add (msg, "c");
4853 vat_json_init_array (counter_array);
4854 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4856 counter = vat_json_array_add (counter_array);
4857 vat_json_init_object (counter);
4858 c6 = &vam->ip6_fib_counters[i][j];
4859 vat_json_object_add_ip6 (counter, "address", c6->address);
4860 vat_json_object_add_uint (counter, "address_length",
4861 c6->address_length);
4862 vat_json_object_add_uint (counter, "packets", c6->packets);
4863 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4867 /* ip4 nbr counters */
4868 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4869 vat_json_init_array (msg_array);
4870 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4872 msg = vat_json_array_add (msg_array);
4873 vat_json_init_object (msg);
4874 vat_json_object_add_uint (msg, "sw_if_index", i);
4875 counter_array = vat_json_object_add (msg, "c");
4876 vat_json_init_array (counter_array);
4877 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4879 counter = vat_json_array_add (counter_array);
4880 vat_json_init_object (counter);
4881 n4 = &vam->ip4_nbr_counters[i][j];
4882 vat_json_object_add_ip4 (counter, "address", n4->address);
4883 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4884 vat_json_object_add_uint (counter, "packets", n4->packets);
4885 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4889 /* ip6 nbr counters */
4890 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4891 vat_json_init_array (msg_array);
4892 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4894 msg = vat_json_array_add (msg_array);
4895 vat_json_init_object (msg);
4896 vat_json_object_add_uint (msg, "sw_if_index", i);
4897 counter_array = vat_json_object_add (msg, "c");
4898 vat_json_init_array (counter_array);
4899 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4901 counter = vat_json_array_add (counter_array);
4902 vat_json_init_object (counter);
4903 n6 = &vam->ip6_nbr_counters[i][j];
4904 vat_json_object_add_ip6 (counter, "address", n6->address);
4905 vat_json_object_add_uint (counter, "packets", n6->packets);
4906 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4910 vat_json_print (vam->ofp, &node);
4911 vat_json_free (&node);
4917 exec (vat_main_t * vam)
4919 api_main_t *am = &api_main;
4920 vl_api_cli_request_t *mp;
4924 unformat_input_t *i = vam->input;
4926 if (vec_len (i->buffer) == 0)
4929 if (vam->exec_mode == 0 && unformat (i, "mode"))
4934 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4941 M (CLI_REQUEST, mp);
4944 * Copy cmd into shared memory.
4945 * In order for the CLI command to work, it
4946 * must be a vector ending in \n, not a C-string ending
4949 pthread_mutex_lock (&am->vlib_rp->mutex);
4950 oldheap = svm_push_data_heap (am->vlib_rp);
4952 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4953 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4955 svm_pop_heap (oldheap);
4956 pthread_mutex_unlock (&am->vlib_rp->mutex);
4958 mp->cmd_in_shmem = (u64) cmd;
4960 timeout = vat_time_now (vam) + 10.0;
4962 while (vat_time_now (vam) < timeout)
4964 if (vam->result_ready == 1)
4967 if (vam->shmem_result != NULL)
4968 print (vam->ofp, "%s", vam->shmem_result);
4969 pthread_mutex_lock (&am->vlib_rp->mutex);
4970 oldheap = svm_push_data_heap (am->vlib_rp);
4972 free_me = (u8 *) vam->shmem_result;
4975 svm_pop_heap (oldheap);
4976 pthread_mutex_unlock (&am->vlib_rp->mutex);
4984 * Future replacement of exec() that passes CLI buffers directly in
4985 * the API messages instead of an additional shared memory area.
4988 exec_inband (vat_main_t * vam)
4990 vl_api_cli_inband_t *mp;
4991 unformat_input_t *i = vam->input;
4994 if (vec_len (i->buffer) == 0)
4997 if (vam->exec_mode == 0 && unformat (i, "mode"))
5002 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5009 * In order for the CLI command to work, it
5010 * must be a vector ending in \n, not a C-string ending
5013 u32 len = vec_len (vam->input->buffer);
5014 M2 (CLI_INBAND, mp, len);
5015 clib_memcpy (mp->cmd, vam->input->buffer, len);
5016 mp->length = htonl (len);
5019 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
5024 api_create_loopback (vat_main_t * vam)
5026 unformat_input_t *i = vam->input;
5027 vl_api_create_loopback_t *mp;
5028 vl_api_create_loopback_instance_t *mp_lbi;
5031 u8 is_specified = 0;
5032 u32 user_instance = 0;
5035 memset (mac_address, 0, sizeof (mac_address));
5037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5039 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5041 if (unformat (i, "instance %d", &user_instance))
5049 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5050 mp_lbi->is_specified = is_specified;
5052 mp_lbi->user_instance = htonl (user_instance);
5054 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5059 /* Construct the API message */
5060 M (CREATE_LOOPBACK, mp);
5062 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5071 api_delete_loopback (vat_main_t * vam)
5073 unformat_input_t *i = vam->input;
5074 vl_api_delete_loopback_t *mp;
5075 u32 sw_if_index = ~0;
5078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5080 if (unformat (i, "sw_if_index %d", &sw_if_index))
5086 if (sw_if_index == ~0)
5088 errmsg ("missing sw_if_index");
5092 /* Construct the API message */
5093 M (DELETE_LOOPBACK, mp);
5094 mp->sw_if_index = ntohl (sw_if_index);
5102 api_want_stats (vat_main_t * vam)
5104 unformat_input_t *i = vam->input;
5105 vl_api_want_stats_t *mp;
5109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5111 if (unformat (i, "enable"))
5113 else if (unformat (i, "disable"))
5121 errmsg ("missing enable|disable");
5126 mp->enable_disable = enable;
5134 api_want_interface_events (vat_main_t * vam)
5136 unformat_input_t *i = vam->input;
5137 vl_api_want_interface_events_t *mp;
5141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5143 if (unformat (i, "enable"))
5145 else if (unformat (i, "disable"))
5153 errmsg ("missing enable|disable");
5157 M (WANT_INTERFACE_EVENTS, mp);
5158 mp->enable_disable = enable;
5160 vam->interface_event_display = enable;
5168 /* Note: non-static, called once to set up the initial intfc table */
5170 api_sw_interface_dump (vat_main_t * vam)
5172 vl_api_sw_interface_dump_t *mp;
5173 vl_api_control_ping_t *mp_ping;
5175 name_sort_t *nses = 0, *ns;
5176 sw_interface_subif_t *sub = NULL;
5179 /* Toss the old name table */
5181 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5183 vec_add2 (nses, ns, 1);
5184 ns->name = (u8 *)(p->key);
5185 ns->value = (u32) p->value[0];
5189 hash_free (vam->sw_if_index_by_interface_name);
5191 vec_foreach (ns, nses) vec_free (ns->name);
5195 vec_foreach (sub, vam->sw_if_subif_table)
5197 vec_free (sub->interface_name);
5199 vec_free (vam->sw_if_subif_table);
5201 /* recreate the interface name hash table */
5202 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5204 /* Get list of ethernets */
5205 M (SW_INTERFACE_DUMP, mp);
5206 mp->name_filter_valid = 1;
5207 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
5210 /* and local / loopback interfaces */
5211 M (SW_INTERFACE_DUMP, mp);
5212 mp->name_filter_valid = 1;
5213 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
5216 /* and packet-generator interfaces */
5217 M (SW_INTERFACE_DUMP, mp);
5218 mp->name_filter_valid = 1;
5219 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
5222 /* and vxlan-gpe tunnel interfaces */
5223 M (SW_INTERFACE_DUMP, mp);
5224 mp->name_filter_valid = 1;
5225 strncpy ((char *) mp->name_filter, "vxlan_gpe",
5226 sizeof (mp->name_filter) - 1);
5229 /* and vxlan tunnel interfaces */
5230 M (SW_INTERFACE_DUMP, mp);
5231 mp->name_filter_valid = 1;
5232 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
5235 /* and host (af_packet) interfaces */
5236 M (SW_INTERFACE_DUMP, mp);
5237 mp->name_filter_valid = 1;
5238 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
5241 /* and l2tpv3 tunnel interfaces */
5242 M (SW_INTERFACE_DUMP, mp);
5243 mp->name_filter_valid = 1;
5244 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
5245 sizeof (mp->name_filter) - 1);
5248 /* and GRE tunnel interfaces */
5249 M (SW_INTERFACE_DUMP, mp);
5250 mp->name_filter_valid = 1;
5251 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
5254 /* and LISP-GPE interfaces */
5255 M (SW_INTERFACE_DUMP, mp);
5256 mp->name_filter_valid = 1;
5257 strncpy ((char *) mp->name_filter, "lisp_gpe",
5258 sizeof (mp->name_filter) - 1);
5261 /* and IPSEC tunnel interfaces */
5262 M (SW_INTERFACE_DUMP, mp);
5263 mp->name_filter_valid = 1;
5264 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
5267 /* Use a control ping for synchronization */
5268 M (CONTROL_PING, mp_ping);
5276 api_sw_interface_set_flags (vat_main_t * vam)
5278 unformat_input_t *i = vam->input;
5279 vl_api_sw_interface_set_flags_t *mp;
5281 u8 sw_if_index_set = 0;
5282 u8 admin_up = 0, link_up = 0;
5285 /* Parse args required to build the message */
5286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5288 if (unformat (i, "admin-up"))
5290 else if (unformat (i, "admin-down"))
5292 else if (unformat (i, "link-up"))
5294 else if (unformat (i, "link-down"))
5297 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5298 sw_if_index_set = 1;
5299 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5300 sw_if_index_set = 1;
5305 if (sw_if_index_set == 0)
5307 errmsg ("missing interface name or sw_if_index");
5311 /* Construct the API message */
5312 M (SW_INTERFACE_SET_FLAGS, mp);
5313 mp->sw_if_index = ntohl (sw_if_index);
5314 mp->admin_up_down = admin_up;
5315 mp->link_up_down = link_up;
5320 /* Wait for a reply, return the good/bad news... */
5326 api_sw_interface_clear_stats (vat_main_t * vam)
5328 unformat_input_t *i = vam->input;
5329 vl_api_sw_interface_clear_stats_t *mp;
5331 u8 sw_if_index_set = 0;
5334 /* Parse args required to build the message */
5335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5337 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5338 sw_if_index_set = 1;
5339 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5340 sw_if_index_set = 1;
5345 /* Construct the API message */
5346 M (SW_INTERFACE_CLEAR_STATS, mp);
5348 if (sw_if_index_set == 1)
5349 mp->sw_if_index = ntohl (sw_if_index);
5351 mp->sw_if_index = ~0;
5356 /* Wait for a reply, return the good/bad news... */
5362 api_sw_interface_add_del_address (vat_main_t * vam)
5364 unformat_input_t *i = vam->input;
5365 vl_api_sw_interface_add_del_address_t *mp;
5367 u8 sw_if_index_set = 0;
5368 u8 is_add = 1, del_all = 0;
5369 u32 address_length = 0;
5370 u8 v4_address_set = 0;
5371 u8 v6_address_set = 0;
5372 ip4_address_t v4address;
5373 ip6_address_t v6address;
5376 /* Parse args required to build the message */
5377 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5379 if (unformat (i, "del-all"))
5381 else if (unformat (i, "del"))
5384 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5385 sw_if_index_set = 1;
5386 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5387 sw_if_index_set = 1;
5388 else if (unformat (i, "%U/%d",
5389 unformat_ip4_address, &v4address, &address_length))
5391 else if (unformat (i, "%U/%d",
5392 unformat_ip6_address, &v6address, &address_length))
5398 if (sw_if_index_set == 0)
5400 errmsg ("missing interface name or sw_if_index");
5403 if (v4_address_set && v6_address_set)
5405 errmsg ("both v4 and v6 addresses set");
5408 if (!v4_address_set && !v6_address_set && !del_all)
5410 errmsg ("no addresses set");
5414 /* Construct the API message */
5415 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5417 mp->sw_if_index = ntohl (sw_if_index);
5418 mp->is_add = is_add;
5419 mp->del_all = del_all;
5423 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5427 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5429 mp->address_length = address_length;
5434 /* Wait for a reply, return good/bad news */
5440 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5442 unformat_input_t *i = vam->input;
5443 vl_api_sw_interface_set_mpls_enable_t *mp;
5445 u8 sw_if_index_set = 0;
5449 /* Parse args required to build the message */
5450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5452 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5453 sw_if_index_set = 1;
5454 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5455 sw_if_index_set = 1;
5456 else if (unformat (i, "disable"))
5458 else if (unformat (i, "dis"))
5464 if (sw_if_index_set == 0)
5466 errmsg ("missing interface name or sw_if_index");
5470 /* Construct the API message */
5471 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5473 mp->sw_if_index = ntohl (sw_if_index);
5474 mp->enable = enable;
5479 /* Wait for a reply... */
5485 api_sw_interface_set_table (vat_main_t * vam)
5487 unformat_input_t *i = vam->input;
5488 vl_api_sw_interface_set_table_t *mp;
5489 u32 sw_if_index, vrf_id = 0;
5490 u8 sw_if_index_set = 0;
5494 /* Parse args required to build the message */
5495 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5497 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5498 sw_if_index_set = 1;
5499 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5500 sw_if_index_set = 1;
5501 else if (unformat (i, "vrf %d", &vrf_id))
5503 else if (unformat (i, "ipv6"))
5509 if (sw_if_index_set == 0)
5511 errmsg ("missing interface name or sw_if_index");
5515 /* Construct the API message */
5516 M (SW_INTERFACE_SET_TABLE, mp);
5518 mp->sw_if_index = ntohl (sw_if_index);
5519 mp->is_ipv6 = is_ipv6;
5520 mp->vrf_id = ntohl (vrf_id);
5525 /* Wait for a reply... */
5530 static void vl_api_sw_interface_get_table_reply_t_handler
5531 (vl_api_sw_interface_get_table_reply_t * mp)
5533 vat_main_t *vam = &vat_main;
5535 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5537 vam->retval = ntohl (mp->retval);
5538 vam->result_ready = 1;
5542 static void vl_api_sw_interface_get_table_reply_t_handler_json
5543 (vl_api_sw_interface_get_table_reply_t * mp)
5545 vat_main_t *vam = &vat_main;
5546 vat_json_node_t node;
5548 vat_json_init_object (&node);
5549 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5550 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5552 vat_json_print (vam->ofp, &node);
5553 vat_json_free (&node);
5555 vam->retval = ntohl (mp->retval);
5556 vam->result_ready = 1;
5560 api_sw_interface_get_table (vat_main_t * vam)
5562 unformat_input_t *i = vam->input;
5563 vl_api_sw_interface_get_table_t *mp;
5565 u8 sw_if_index_set = 0;
5569 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5571 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5572 sw_if_index_set = 1;
5573 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5574 sw_if_index_set = 1;
5575 else if (unformat (i, "ipv6"))
5581 if (sw_if_index_set == 0)
5583 errmsg ("missing interface name or sw_if_index");
5587 M (SW_INTERFACE_GET_TABLE, mp);
5588 mp->sw_if_index = htonl (sw_if_index);
5589 mp->is_ipv6 = is_ipv6;
5597 api_sw_interface_set_vpath (vat_main_t * vam)
5599 unformat_input_t *i = vam->input;
5600 vl_api_sw_interface_set_vpath_t *mp;
5601 u32 sw_if_index = 0;
5602 u8 sw_if_index_set = 0;
5606 /* Parse args required to build the message */
5607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5609 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5610 sw_if_index_set = 1;
5611 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5612 sw_if_index_set = 1;
5613 else if (unformat (i, "enable"))
5615 else if (unformat (i, "disable"))
5621 if (sw_if_index_set == 0)
5623 errmsg ("missing interface name or sw_if_index");
5627 /* Construct the API message */
5628 M (SW_INTERFACE_SET_VPATH, mp);
5630 mp->sw_if_index = ntohl (sw_if_index);
5631 mp->enable = is_enable;
5636 /* Wait for a reply... */
5642 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5644 unformat_input_t *i = vam->input;
5645 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5646 u32 sw_if_index = 0;
5647 u8 sw_if_index_set = 0;
5652 /* Parse args required to build the message */
5653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5655 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5656 sw_if_index_set = 1;
5657 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5658 sw_if_index_set = 1;
5659 else if (unformat (i, "enable"))
5661 else if (unformat (i, "disable"))
5663 else if (unformat (i, "ip4"))
5665 else if (unformat (i, "ip6"))
5671 if (sw_if_index_set == 0)
5673 errmsg ("missing interface name or sw_if_index");
5677 /* Construct the API message */
5678 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5680 mp->sw_if_index = ntohl (sw_if_index);
5681 mp->enable = is_enable;
5682 mp->is_ipv6 = is_ipv6;
5687 /* Wait for a reply... */
5693 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5695 unformat_input_t *i = vam->input;
5696 vl_api_sw_interface_set_l2_xconnect_t *mp;
5698 u8 rx_sw_if_index_set = 0;
5700 u8 tx_sw_if_index_set = 0;
5704 /* Parse args required to build the message */
5705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5707 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5708 rx_sw_if_index_set = 1;
5709 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5710 tx_sw_if_index_set = 1;
5711 else if (unformat (i, "rx"))
5713 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5715 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5717 rx_sw_if_index_set = 1;
5722 else if (unformat (i, "tx"))
5724 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5726 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5728 tx_sw_if_index_set = 1;
5733 else if (unformat (i, "enable"))
5735 else if (unformat (i, "disable"))
5741 if (rx_sw_if_index_set == 0)
5743 errmsg ("missing rx interface name or rx_sw_if_index");
5747 if (enable && (tx_sw_if_index_set == 0))
5749 errmsg ("missing tx interface name or tx_sw_if_index");
5753 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5755 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5756 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5757 mp->enable = enable;
5765 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5767 unformat_input_t *i = vam->input;
5768 vl_api_sw_interface_set_l2_bridge_t *mp;
5770 u8 rx_sw_if_index_set = 0;
5778 /* Parse args required to build the message */
5779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5781 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5782 rx_sw_if_index_set = 1;
5783 else if (unformat (i, "bd_id %d", &bd_id))
5787 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5788 rx_sw_if_index_set = 1;
5789 else if (unformat (i, "shg %d", &shg))
5791 else if (unformat (i, "bvi"))
5793 else if (unformat (i, "enable"))
5795 else if (unformat (i, "disable"))
5801 if (rx_sw_if_index_set == 0)
5803 errmsg ("missing rx interface name or sw_if_index");
5807 if (enable && (bd_id_set == 0))
5809 errmsg ("missing bridge domain");
5813 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5815 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5816 mp->bd_id = ntohl (bd_id);
5819 mp->enable = enable;
5827 api_bridge_domain_dump (vat_main_t * vam)
5829 unformat_input_t *i = vam->input;
5830 vl_api_bridge_domain_dump_t *mp;
5831 vl_api_control_ping_t *mp_ping;
5835 /* Parse args required to build the message */
5836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5838 if (unformat (i, "bd_id %d", &bd_id))
5844 M (BRIDGE_DOMAIN_DUMP, mp);
5845 mp->bd_id = ntohl (bd_id);
5848 /* Use a control ping for synchronization */
5849 M (CONTROL_PING, mp_ping);
5857 api_bridge_domain_add_del (vat_main_t * vam)
5859 unformat_input_t *i = vam->input;
5860 vl_api_bridge_domain_add_del_t *mp;
5863 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5867 /* Parse args required to build the message */
5868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5870 if (unformat (i, "bd_id %d", &bd_id))
5872 else if (unformat (i, "flood %d", &flood))
5874 else if (unformat (i, "uu-flood %d", &uu_flood))
5876 else if (unformat (i, "forward %d", &forward))
5878 else if (unformat (i, "learn %d", &learn))
5880 else if (unformat (i, "arp-term %d", &arp_term))
5882 else if (unformat (i, "mac-age %d", &mac_age))
5884 else if (unformat (i, "del"))
5887 flood = uu_flood = forward = learn = 0;
5895 errmsg ("missing bridge domain");
5901 errmsg ("mac age must be less than 256 ");
5905 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5907 mp->bd_id = ntohl (bd_id);
5909 mp->uu_flood = uu_flood;
5910 mp->forward = forward;
5912 mp->arp_term = arp_term;
5913 mp->is_add = is_add;
5914 mp->mac_age = (u8) mac_age;
5922 api_l2fib_flush_bd (vat_main_t * vam)
5924 unformat_input_t *i = vam->input;
5925 vl_api_l2fib_flush_bd_t *mp;
5929 /* Parse args required to build the message */
5930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5932 if (unformat (i, "bd_id %d", &bd_id));
5939 errmsg ("missing bridge domain");
5943 M (L2FIB_FLUSH_BD, mp);
5945 mp->bd_id = htonl (bd_id);
5953 api_l2fib_flush_int (vat_main_t * vam)
5955 unformat_input_t *i = vam->input;
5956 vl_api_l2fib_flush_int_t *mp;
5957 u32 sw_if_index = ~0;
5960 /* Parse args required to build the message */
5961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5963 if (unformat (i, "sw_if_index %d", &sw_if_index));
5965 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
5970 if (sw_if_index == ~0)
5972 errmsg ("missing interface name or sw_if_index");
5976 M (L2FIB_FLUSH_INT, mp);
5978 mp->sw_if_index = ntohl (sw_if_index);
5986 api_l2fib_add_del (vat_main_t * vam)
5988 unformat_input_t *i = vam->input;
5989 vl_api_l2fib_add_del_t *mp;
5995 u32 sw_if_index = ~0;
5996 u8 sw_if_index_set = 0;
6005 /* Parse args required to build the message */
6006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6008 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
6010 else if (unformat (i, "bd_id %d", &bd_id))
6012 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6013 sw_if_index_set = 1;
6014 else if (unformat (i, "sw_if"))
6016 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6019 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6020 sw_if_index_set = 1;
6025 else if (unformat (i, "static"))
6027 else if (unformat (i, "filter"))
6032 else if (unformat (i, "bvi"))
6037 else if (unformat (i, "del"))
6039 else if (unformat (i, "count %d", &count))
6047 errmsg ("missing mac address");
6053 errmsg ("missing bridge domain");
6057 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6059 errmsg ("missing interface name or sw_if_index");
6065 /* Turn on async mode */
6066 vam->async_mode = 1;
6067 vam->async_errors = 0;
6068 before = vat_time_now (vam);
6071 for (j = 0; j < count; j++)
6073 M (L2FIB_ADD_DEL, mp);
6076 mp->bd_id = ntohl (bd_id);
6077 mp->is_add = is_add;
6081 mp->sw_if_index = ntohl (sw_if_index);
6082 mp->static_mac = static_mac;
6083 mp->filter_mac = filter_mac;
6084 mp->bvi_mac = bvi_mac;
6086 increment_mac_address (&mac);
6093 vl_api_control_ping_t *mp_ping;
6096 /* Shut off async mode */
6097 vam->async_mode = 0;
6099 M (CONTROL_PING, mp_ping);
6102 timeout = vat_time_now (vam) + 1.0;
6103 while (vat_time_now (vam) < timeout)
6104 if (vam->result_ready == 1)
6109 if (vam->retval == -99)
6112 if (vam->async_errors > 0)
6114 errmsg ("%d asynchronous errors", vam->async_errors);
6117 vam->async_errors = 0;
6118 after = vat_time_now (vam);
6120 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6121 count, after - before, count / (after - before));
6127 /* Wait for a reply... */
6131 /* Return the good/bad news */
6132 return (vam->retval);
6136 api_bridge_domain_set_mac_age (vat_main_t * vam)
6138 unformat_input_t *i = vam->input;
6139 vl_api_bridge_domain_set_mac_age_t *mp;
6144 /* Parse args required to build the message */
6145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6147 if (unformat (i, "bd_id %d", &bd_id));
6148 else if (unformat (i, "mac-age %d", &mac_age));
6155 errmsg ("missing bridge domain");
6161 errmsg ("mac age must be less than 256 ");
6165 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6167 mp->bd_id = htonl (bd_id);
6168 mp->mac_age = (u8) mac_age;
6176 api_l2_flags (vat_main_t * vam)
6178 unformat_input_t *i = vam->input;
6179 vl_api_l2_flags_t *mp;
6181 u32 feature_bitmap = 0;
6182 u8 sw_if_index_set = 0;
6185 /* Parse args required to build the message */
6186 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6188 if (unformat (i, "sw_if_index %d", &sw_if_index))
6189 sw_if_index_set = 1;
6190 else if (unformat (i, "sw_if"))
6192 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6195 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6196 sw_if_index_set = 1;
6201 else if (unformat (i, "learn"))
6202 feature_bitmap |= L2INPUT_FEAT_LEARN;
6203 else if (unformat (i, "forward"))
6204 feature_bitmap |= L2INPUT_FEAT_FWD;
6205 else if (unformat (i, "flood"))
6206 feature_bitmap |= L2INPUT_FEAT_FLOOD;
6207 else if (unformat (i, "uu-flood"))
6208 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
6213 if (sw_if_index_set == 0)
6215 errmsg ("missing interface name or sw_if_index");
6221 mp->sw_if_index = ntohl (sw_if_index);
6222 mp->feature_bitmap = ntohl (feature_bitmap);
6230 api_bridge_flags (vat_main_t * vam)
6232 unformat_input_t *i = vam->input;
6233 vl_api_bridge_flags_t *mp;
6240 /* Parse args required to build the message */
6241 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6243 if (unformat (i, "bd_id %d", &bd_id))
6245 else if (unformat (i, "learn"))
6247 else if (unformat (i, "forward"))
6249 else if (unformat (i, "flood"))
6251 else if (unformat (i, "uu-flood"))
6252 flags |= L2_UU_FLOOD;
6253 else if (unformat (i, "arp-term"))
6254 flags |= L2_ARP_TERM;
6255 else if (unformat (i, "off"))
6257 else if (unformat (i, "disable"))
6265 errmsg ("missing bridge domain");
6269 M (BRIDGE_FLAGS, mp);
6271 mp->bd_id = ntohl (bd_id);
6272 mp->feature_bitmap = ntohl (flags);
6273 mp->is_set = is_set;
6281 api_bd_ip_mac_add_del (vat_main_t * vam)
6283 unformat_input_t *i = vam->input;
6284 vl_api_bd_ip_mac_add_del_t *mp;
6291 ip4_address_t v4addr;
6292 ip6_address_t v6addr;
6297 /* Parse args required to build the message */
6298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6300 if (unformat (i, "bd_id %d", &bd_id))
6304 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6308 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6313 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6317 else if (unformat (i, "del"))
6325 errmsg ("missing bridge domain");
6328 else if (ip_set == 0)
6330 errmsg ("missing IP address");
6333 else if (mac_set == 0)
6335 errmsg ("missing MAC address");
6339 M (BD_IP_MAC_ADD_DEL, mp);
6341 mp->bd_id = ntohl (bd_id);
6342 mp->is_ipv6 = is_ipv6;
6343 mp->is_add = is_add;
6345 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6347 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6348 clib_memcpy (mp->mac_address, macaddr, 6);
6355 api_tap_connect (vat_main_t * vam)
6357 unformat_input_t *i = vam->input;
6358 vl_api_tap_connect_t *mp;
6364 ip4_address_t ip4_address;
6366 int ip4_address_set = 0;
6367 ip6_address_t ip6_address;
6369 int ip6_address_set = 0;
6372 memset (mac_address, 0, sizeof (mac_address));
6374 /* Parse args required to build the message */
6375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6377 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6381 else if (unformat (i, "random-mac"))
6383 else if (unformat (i, "tapname %s", &tap_name))
6385 else if (unformat (i, "tag %s", &tag))
6387 else if (unformat (i, "address %U/%d",
6388 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6389 ip4_address_set = 1;
6390 else if (unformat (i, "address %U/%d",
6391 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6392 ip6_address_set = 1;
6399 errmsg ("missing tap name");
6402 if (vec_len (tap_name) > 63)
6404 errmsg ("tap name too long");
6407 vec_add1 (tap_name, 0);
6409 if (vec_len (tag) > 63)
6411 errmsg ("tag too long");
6415 /* Construct the API message */
6416 M (TAP_CONNECT, mp);
6418 mp->use_random_mac = random_mac;
6419 clib_memcpy (mp->mac_address, mac_address, 6);
6420 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6422 clib_memcpy (mp->tag, tag, vec_len (tag));
6424 if (ip4_address_set)
6426 mp->ip4_address_set = 1;
6427 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6428 mp->ip4_mask_width = ip4_mask_width;
6430 if (ip6_address_set)
6432 mp->ip6_address_set = 1;
6433 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6434 mp->ip6_mask_width = ip6_mask_width;
6437 vec_free (tap_name);
6443 /* Wait for a reply... */
6449 api_tap_modify (vat_main_t * vam)
6451 unformat_input_t *i = vam->input;
6452 vl_api_tap_modify_t *mp;
6457 u32 sw_if_index = ~0;
6458 u8 sw_if_index_set = 0;
6461 memset (mac_address, 0, sizeof (mac_address));
6463 /* Parse args required to build the message */
6464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6466 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6467 sw_if_index_set = 1;
6468 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6469 sw_if_index_set = 1;
6470 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6474 else if (unformat (i, "random-mac"))
6476 else if (unformat (i, "tapname %s", &tap_name))
6482 if (sw_if_index_set == 0)
6484 errmsg ("missing vpp interface name");
6489 errmsg ("missing tap name");
6492 if (vec_len (tap_name) > 63)
6494 errmsg ("tap name too long");
6496 vec_add1 (tap_name, 0);
6498 /* Construct the API message */
6501 mp->use_random_mac = random_mac;
6502 mp->sw_if_index = ntohl (sw_if_index);
6503 clib_memcpy (mp->mac_address, mac_address, 6);
6504 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6505 vec_free (tap_name);
6510 /* Wait for a reply... */
6516 api_tap_delete (vat_main_t * vam)
6518 unformat_input_t *i = vam->input;
6519 vl_api_tap_delete_t *mp;
6520 u32 sw_if_index = ~0;
6521 u8 sw_if_index_set = 0;
6524 /* Parse args required to build the message */
6525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6527 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6528 sw_if_index_set = 1;
6529 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6530 sw_if_index_set = 1;
6535 if (sw_if_index_set == 0)
6537 errmsg ("missing vpp interface name");
6541 /* Construct the API message */
6544 mp->sw_if_index = ntohl (sw_if_index);
6549 /* Wait for a reply... */
6555 api_ip_add_del_route (vat_main_t * vam)
6557 unformat_input_t *i = vam->input;
6558 vl_api_ip_add_del_route_t *mp;
6559 u32 sw_if_index = ~0, vrf_id = 0;
6561 u8 is_local = 0, is_drop = 0;
6562 u8 is_unreach = 0, is_prohibit = 0;
6563 u8 create_vrf_if_needed = 0;
6565 u32 next_hop_weight = 1;
6567 u8 is_multipath = 0;
6569 u8 address_length_set = 0;
6570 u32 next_hop_table_id = 0;
6571 u32 resolve_attempts = 0;
6572 u32 dst_address_length = 0;
6573 u8 next_hop_set = 0;
6574 ip4_address_t v4_dst_address, v4_next_hop_address;
6575 ip6_address_t v6_dst_address, v6_next_hop_address;
6579 u32 random_add_del = 0;
6580 u32 *random_vector = 0;
6582 u32 random_seed = 0xdeaddabe;
6583 u32 classify_table_index = ~0;
6585 u8 resolve_host = 0, resolve_attached = 0;
6586 mpls_label_t *next_hop_out_label_stack = NULL;
6587 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6588 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6590 /* Parse args required to build the message */
6591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6593 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6595 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6597 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6602 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6607 else if (unformat (i, "/%d", &dst_address_length))
6609 address_length_set = 1;
6612 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6613 &v4_next_hop_address))
6617 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6618 &v6_next_hop_address))
6622 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6624 else if (unformat (i, "weight %d", &next_hop_weight))
6626 else if (unformat (i, "drop"))
6630 else if (unformat (i, "null-send-unreach"))
6634 else if (unformat (i, "null-send-prohibit"))
6638 else if (unformat (i, "local"))
6642 else if (unformat (i, "classify %d", &classify_table_index))
6646 else if (unformat (i, "del"))
6648 else if (unformat (i, "add"))
6650 else if (unformat (i, "not-last"))
6652 else if (unformat (i, "resolve-via-host"))
6654 else if (unformat (i, "resolve-via-attached"))
6655 resolve_attached = 1;
6656 else if (unformat (i, "multipath"))
6658 else if (unformat (i, "vrf %d", &vrf_id))
6660 else if (unformat (i, "create-vrf"))
6661 create_vrf_if_needed = 1;
6662 else if (unformat (i, "count %d", &count))
6664 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6666 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6668 else if (unformat (i, "out-label %d", &next_hop_out_label))
6669 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6670 else if (unformat (i, "via-label %d", &next_hop_via_label))
6672 else if (unformat (i, "random"))
6674 else if (unformat (i, "seed %d", &random_seed))
6678 clib_warning ("parse error '%U'", format_unformat_error, i);
6683 if (!next_hop_set && !is_drop && !is_local &&
6684 !is_classify && !is_unreach && !is_prohibit &&
6685 MPLS_LABEL_INVALID == next_hop_via_label)
6688 ("next hop / local / drop / unreach / prohibit / classify not set");
6692 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6694 errmsg ("next hop and next-hop via label set");
6697 if (address_set == 0)
6699 errmsg ("missing addresses");
6703 if (address_length_set == 0)
6705 errmsg ("missing address length");
6709 /* Generate a pile of unique, random routes */
6712 u32 this_random_address;
6713 random_hash = hash_create (count, sizeof (uword));
6715 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6716 for (j = 0; j <= count; j++)
6720 this_random_address = random_u32 (&random_seed);
6721 this_random_address =
6722 clib_host_to_net_u32 (this_random_address);
6724 while (hash_get (random_hash, this_random_address));
6725 vec_add1 (random_vector, this_random_address);
6726 hash_set (random_hash, this_random_address, 1);
6728 hash_free (random_hash);
6729 v4_dst_address.as_u32 = random_vector[0];
6734 /* Turn on async mode */
6735 vam->async_mode = 1;
6736 vam->async_errors = 0;
6737 before = vat_time_now (vam);
6740 for (j = 0; j < count; j++)
6742 /* Construct the API message */
6743 M2 (IP_ADD_DEL_ROUTE, mp,
6744 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6746 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6747 mp->table_id = ntohl (vrf_id);
6748 mp->create_vrf_if_needed = create_vrf_if_needed;
6750 mp->is_add = is_add;
6751 mp->is_drop = is_drop;
6752 mp->is_unreach = is_unreach;
6753 mp->is_prohibit = is_prohibit;
6754 mp->is_ipv6 = is_ipv6;
6755 mp->is_local = is_local;
6756 mp->is_classify = is_classify;
6757 mp->is_multipath = is_multipath;
6758 mp->is_resolve_host = resolve_host;
6759 mp->is_resolve_attached = resolve_attached;
6760 mp->not_last = not_last;
6761 mp->next_hop_weight = next_hop_weight;
6762 mp->dst_address_length = dst_address_length;
6763 mp->next_hop_table_id = ntohl (next_hop_table_id);
6764 mp->classify_table_index = ntohl (classify_table_index);
6765 mp->next_hop_via_label = ntohl (next_hop_via_label);
6766 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6767 if (0 != mp->next_hop_n_out_labels)
6769 memcpy (mp->next_hop_out_label_stack,
6770 next_hop_out_label_stack,
6771 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6772 vec_free (next_hop_out_label_stack);
6777 clib_memcpy (mp->dst_address, &v6_dst_address,
6778 sizeof (v6_dst_address));
6780 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6781 sizeof (v6_next_hop_address));
6782 increment_v6_address (&v6_dst_address);
6786 clib_memcpy (mp->dst_address, &v4_dst_address,
6787 sizeof (v4_dst_address));
6789 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6790 sizeof (v4_next_hop_address));
6792 v4_dst_address.as_u32 = random_vector[j + 1];
6794 increment_v4_address (&v4_dst_address);
6798 /* If we receive SIGTERM, stop now... */
6803 /* When testing multiple add/del ops, use a control-ping to sync */
6806 vl_api_control_ping_t *mp_ping;
6810 /* Shut off async mode */
6811 vam->async_mode = 0;
6813 M (CONTROL_PING, mp_ping);
6816 timeout = vat_time_now (vam) + 1.0;
6817 while (vat_time_now (vam) < timeout)
6818 if (vam->result_ready == 1)
6823 if (vam->retval == -99)
6826 if (vam->async_errors > 0)
6828 errmsg ("%d asynchronous errors", vam->async_errors);
6831 vam->async_errors = 0;
6832 after = vat_time_now (vam);
6834 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6838 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6839 count, after - before, count / (after - before));
6845 /* Wait for a reply... */
6850 /* Return the good/bad news */
6851 return (vam->retval);
6855 api_ip_mroute_add_del (vat_main_t * vam)
6857 unformat_input_t *i = vam->input;
6858 vl_api_ip_mroute_add_del_t *mp;
6859 u32 sw_if_index = ~0, vrf_id = 0;
6862 u8 create_vrf_if_needed = 0;
6865 u32 grp_address_length = 0;
6866 ip4_address_t v4_grp_address, v4_src_address;
6867 ip6_address_t v6_grp_address, v6_src_address;
6868 mfib_itf_flags_t iflags = 0;
6869 mfib_entry_flags_t eflags = 0;
6872 /* Parse args required to build the message */
6873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6875 if (unformat (i, "sw_if_index %d", &sw_if_index))
6877 else if (unformat (i, "%U %U",
6878 unformat_ip4_address, &v4_src_address,
6879 unformat_ip4_address, &v4_grp_address))
6881 grp_address_length = 64;
6885 else if (unformat (i, "%U %U",
6886 unformat_ip6_address, &v6_src_address,
6887 unformat_ip6_address, &v6_grp_address))
6889 grp_address_length = 256;
6893 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6895 memset (&v4_src_address, 0, sizeof (v4_src_address));
6896 grp_address_length = 32;
6900 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6902 memset (&v6_src_address, 0, sizeof (v6_src_address));
6903 grp_address_length = 128;
6907 else if (unformat (i, "/%d", &grp_address_length))
6909 else if (unformat (i, "local"))
6913 else if (unformat (i, "del"))
6915 else if (unformat (i, "add"))
6917 else if (unformat (i, "vrf %d", &vrf_id))
6919 else if (unformat (i, "create-vrf"))
6920 create_vrf_if_needed = 1;
6921 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6923 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6927 clib_warning ("parse error '%U'", format_unformat_error, i);
6932 if (address_set == 0)
6934 errmsg ("missing addresses\n");
6938 /* Construct the API message */
6939 M (IP_MROUTE_ADD_DEL, mp);
6941 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6942 mp->table_id = ntohl (vrf_id);
6943 mp->create_vrf_if_needed = create_vrf_if_needed;
6945 mp->is_add = is_add;
6946 mp->is_ipv6 = is_ipv6;
6947 mp->is_local = is_local;
6948 mp->itf_flags = ntohl (iflags);
6949 mp->entry_flags = ntohl (eflags);
6950 mp->grp_address_length = grp_address_length;
6951 mp->grp_address_length = ntohs (mp->grp_address_length);
6955 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6956 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6960 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6961 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6967 /* Wait for a reply... */
6973 api_mpls_route_add_del (vat_main_t * vam)
6975 unformat_input_t *i = vam->input;
6976 vl_api_mpls_route_add_del_t *mp;
6977 u32 sw_if_index = ~0, table_id = 0;
6978 u8 create_table_if_needed = 0;
6980 u32 next_hop_weight = 1;
6981 u8 is_multipath = 0;
6982 u32 next_hop_table_id = 0;
6983 u8 next_hop_set = 0;
6984 ip4_address_t v4_next_hop_address = {
6987 ip6_address_t v6_next_hop_address = { {0} };
6991 u32 classify_table_index = ~0;
6993 u8 resolve_host = 0, resolve_attached = 0;
6994 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6995 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6996 mpls_label_t *next_hop_out_label_stack = NULL;
6997 mpls_label_t local_label = MPLS_LABEL_INVALID;
6999 u8 next_hop_proto_is_ip4 = 1;
7001 /* Parse args required to build the message */
7002 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7004 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7006 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7008 else if (unformat (i, "%d", &local_label))
7010 else if (unformat (i, "eos"))
7012 else if (unformat (i, "non-eos"))
7014 else if (unformat (i, "via %U", unformat_ip4_address,
7015 &v4_next_hop_address))
7018 next_hop_proto_is_ip4 = 1;
7020 else if (unformat (i, "via %U", unformat_ip6_address,
7021 &v6_next_hop_address))
7024 next_hop_proto_is_ip4 = 0;
7026 else if (unformat (i, "weight %d", &next_hop_weight))
7028 else if (unformat (i, "create-table"))
7029 create_table_if_needed = 1;
7030 else if (unformat (i, "classify %d", &classify_table_index))
7034 else if (unformat (i, "del"))
7036 else if (unformat (i, "add"))
7038 else if (unformat (i, "resolve-via-host"))
7040 else if (unformat (i, "resolve-via-attached"))
7041 resolve_attached = 1;
7042 else if (unformat (i, "multipath"))
7044 else if (unformat (i, "count %d", &count))
7046 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
7049 next_hop_proto_is_ip4 = 1;
7051 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
7054 next_hop_proto_is_ip4 = 0;
7056 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7058 else if (unformat (i, "via-label %d", &next_hop_via_label))
7060 else if (unformat (i, "out-label %d", &next_hop_out_label))
7061 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7064 clib_warning ("parse error '%U'", format_unformat_error, i);
7069 if (!next_hop_set && !is_classify)
7071 errmsg ("next hop / classify not set");
7075 if (MPLS_LABEL_INVALID == local_label)
7077 errmsg ("missing label");
7083 /* Turn on async mode */
7084 vam->async_mode = 1;
7085 vam->async_errors = 0;
7086 before = vat_time_now (vam);
7089 for (j = 0; j < count; j++)
7091 /* Construct the API message */
7092 M2 (MPLS_ROUTE_ADD_DEL, mp,
7093 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7095 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
7096 mp->mr_table_id = ntohl (table_id);
7097 mp->mr_create_table_if_needed = create_table_if_needed;
7099 mp->mr_is_add = is_add;
7100 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7101 mp->mr_is_classify = is_classify;
7102 mp->mr_is_multipath = is_multipath;
7103 mp->mr_is_resolve_host = resolve_host;
7104 mp->mr_is_resolve_attached = resolve_attached;
7105 mp->mr_next_hop_weight = next_hop_weight;
7106 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
7107 mp->mr_classify_table_index = ntohl (classify_table_index);
7108 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
7109 mp->mr_label = ntohl (local_label);
7110 mp->mr_eos = is_eos;
7112 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7113 if (0 != mp->mr_next_hop_n_out_labels)
7115 memcpy (mp->mr_next_hop_out_label_stack,
7116 next_hop_out_label_stack,
7117 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7118 vec_free (next_hop_out_label_stack);
7123 if (next_hop_proto_is_ip4)
7125 clib_memcpy (mp->mr_next_hop,
7126 &v4_next_hop_address,
7127 sizeof (v4_next_hop_address));
7131 clib_memcpy (mp->mr_next_hop,
7132 &v6_next_hop_address,
7133 sizeof (v6_next_hop_address));
7140 /* If we receive SIGTERM, stop now... */
7145 /* When testing multiple add/del ops, use a control-ping to sync */
7148 vl_api_control_ping_t *mp_ping;
7152 /* Shut off async mode */
7153 vam->async_mode = 0;
7155 M (CONTROL_PING, mp_ping);
7158 timeout = vat_time_now (vam) + 1.0;
7159 while (vat_time_now (vam) < timeout)
7160 if (vam->result_ready == 1)
7165 if (vam->retval == -99)
7168 if (vam->async_errors > 0)
7170 errmsg ("%d asynchronous errors", vam->async_errors);
7173 vam->async_errors = 0;
7174 after = vat_time_now (vam);
7176 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7180 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7181 count, after - before, count / (after - before));
7187 /* Wait for a reply... */
7192 /* Return the good/bad news */
7193 return (vam->retval);
7197 api_mpls_ip_bind_unbind (vat_main_t * vam)
7199 unformat_input_t *i = vam->input;
7200 vl_api_mpls_ip_bind_unbind_t *mp;
7201 u32 ip_table_id = 0;
7202 u8 create_table_if_needed = 0;
7205 ip4_address_t v4_address;
7206 ip6_address_t v6_address;
7209 mpls_label_t local_label = MPLS_LABEL_INVALID;
7212 /* Parse args required to build the message */
7213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7215 if (unformat (i, "%U/%d", unformat_ip4_address,
7216 &v4_address, &address_length))
7221 else if (unformat (i, "%U/%d", unformat_ip6_address,
7222 &v6_address, &address_length))
7227 else if (unformat (i, "%d", &local_label))
7229 else if (unformat (i, "create-table"))
7230 create_table_if_needed = 1;
7231 else if (unformat (i, "table-id %d", &ip_table_id))
7233 else if (unformat (i, "unbind"))
7235 else if (unformat (i, "bind"))
7239 clib_warning ("parse error '%U'", format_unformat_error, i);
7246 errmsg ("IP addres not set");
7250 if (MPLS_LABEL_INVALID == local_label)
7252 errmsg ("missing label");
7256 /* Construct the API message */
7257 M (MPLS_IP_BIND_UNBIND, mp);
7259 mp->mb_create_table_if_needed = create_table_if_needed;
7260 mp->mb_is_bind = is_bind;
7261 mp->mb_is_ip4 = is_ip4;
7262 mp->mb_ip_table_id = ntohl (ip_table_id);
7263 mp->mb_mpls_table_id = 0;
7264 mp->mb_label = ntohl (local_label);
7265 mp->mb_address_length = address_length;
7268 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7270 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7275 /* Wait for a reply... */
7281 api_proxy_arp_add_del (vat_main_t * vam)
7283 unformat_input_t *i = vam->input;
7284 vl_api_proxy_arp_add_del_t *mp;
7287 ip4_address_t lo, hi;
7291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7293 if (unformat (i, "vrf %d", &vrf_id))
7295 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7296 unformat_ip4_address, &hi))
7298 else if (unformat (i, "del"))
7302 clib_warning ("parse error '%U'", format_unformat_error, i);
7309 errmsg ("address range not set");
7313 M (PROXY_ARP_ADD_DEL, mp);
7315 mp->vrf_id = ntohl (vrf_id);
7316 mp->is_add = is_add;
7317 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7318 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7326 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7328 unformat_input_t *i = vam->input;
7329 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7332 u8 sw_if_index_set = 0;
7335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7337 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7338 sw_if_index_set = 1;
7339 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7340 sw_if_index_set = 1;
7341 else if (unformat (i, "enable"))
7343 else if (unformat (i, "disable"))
7347 clib_warning ("parse error '%U'", format_unformat_error, i);
7352 if (sw_if_index_set == 0)
7354 errmsg ("missing interface name or sw_if_index");
7358 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7360 mp->sw_if_index = ntohl (sw_if_index);
7361 mp->enable_disable = enable;
7369 api_mpls_tunnel_add_del (vat_main_t * vam)
7371 unformat_input_t *i = vam->input;
7372 vl_api_mpls_tunnel_add_del_t *mp;
7376 u32 sw_if_index = ~0;
7377 u32 next_hop_sw_if_index = ~0;
7378 u32 next_hop_proto_is_ip4 = 1;
7380 u32 next_hop_table_id = 0;
7381 ip4_address_t v4_next_hop_address = {
7384 ip6_address_t v6_next_hop_address = { {0} };
7385 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7390 if (unformat (i, "add"))
7392 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7394 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7396 else if (unformat (i, "via %U",
7397 unformat_ip4_address, &v4_next_hop_address))
7399 next_hop_proto_is_ip4 = 1;
7401 else if (unformat (i, "via %U",
7402 unformat_ip6_address, &v6_next_hop_address))
7404 next_hop_proto_is_ip4 = 0;
7406 else if (unformat (i, "l2-only"))
7408 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7410 else if (unformat (i, "out-label %d", &next_hop_out_label))
7411 vec_add1 (labels, ntohl (next_hop_out_label));
7414 clib_warning ("parse error '%U'", format_unformat_error, i);
7419 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7421 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7422 mp->mt_sw_if_index = ntohl (sw_if_index);
7423 mp->mt_is_add = is_add;
7424 mp->mt_l2_only = l2_only;
7425 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7426 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7428 mp->mt_next_hop_n_out_labels = vec_len (labels);
7430 if (0 != mp->mt_next_hop_n_out_labels)
7432 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7433 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7437 if (next_hop_proto_is_ip4)
7439 clib_memcpy (mp->mt_next_hop,
7440 &v4_next_hop_address, sizeof (v4_next_hop_address));
7444 clib_memcpy (mp->mt_next_hop,
7445 &v6_next_hop_address, sizeof (v6_next_hop_address));
7454 api_sw_interface_set_unnumbered (vat_main_t * vam)
7456 unformat_input_t *i = vam->input;
7457 vl_api_sw_interface_set_unnumbered_t *mp;
7459 u32 unnum_sw_index = ~0;
7461 u8 sw_if_index_set = 0;
7464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7466 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7467 sw_if_index_set = 1;
7468 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7469 sw_if_index_set = 1;
7470 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7472 else if (unformat (i, "del"))
7476 clib_warning ("parse error '%U'", format_unformat_error, i);
7481 if (sw_if_index_set == 0)
7483 errmsg ("missing interface name or sw_if_index");
7487 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7489 mp->sw_if_index = ntohl (sw_if_index);
7490 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7491 mp->is_add = is_add;
7499 api_ip_neighbor_add_del (vat_main_t * vam)
7501 unformat_input_t *i = vam->input;
7502 vl_api_ip_neighbor_add_del_t *mp;
7504 u8 sw_if_index_set = 0;
7507 u8 is_no_fib_entry = 0;
7510 u8 v4_address_set = 0;
7511 u8 v6_address_set = 0;
7512 ip4_address_t v4address;
7513 ip6_address_t v6address;
7516 memset (mac_address, 0, sizeof (mac_address));
7518 /* Parse args required to build the message */
7519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7521 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7525 else if (unformat (i, "del"))
7528 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7529 sw_if_index_set = 1;
7530 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7531 sw_if_index_set = 1;
7532 else if (unformat (i, "is_static"))
7534 else if (unformat (i, "no-fib-entry"))
7535 is_no_fib_entry = 1;
7536 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7538 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7542 clib_warning ("parse error '%U'", format_unformat_error, i);
7547 if (sw_if_index_set == 0)
7549 errmsg ("missing interface name or sw_if_index");
7552 if (v4_address_set && v6_address_set)
7554 errmsg ("both v4 and v6 addresses set");
7557 if (!v4_address_set && !v6_address_set)
7559 errmsg ("no address set");
7563 /* Construct the API message */
7564 M (IP_NEIGHBOR_ADD_DEL, mp);
7566 mp->sw_if_index = ntohl (sw_if_index);
7567 mp->is_add = is_add;
7568 mp->is_static = is_static;
7569 mp->is_no_adj_fib = is_no_fib_entry;
7571 clib_memcpy (mp->mac_address, mac_address, 6);
7575 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7579 /* mp->is_ipv6 = 0; via memset in M macro above */
7580 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7586 /* Wait for a reply, return good/bad news */
7592 api_reset_vrf (vat_main_t * vam)
7594 unformat_input_t *i = vam->input;
7595 vl_api_reset_vrf_t *mp;
7601 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7603 if (unformat (i, "vrf %d", &vrf_id))
7605 else if (unformat (i, "ipv6"))
7609 clib_warning ("parse error '%U'", format_unformat_error, i);
7614 if (vrf_id_set == 0)
7616 errmsg ("missing vrf id");
7622 mp->vrf_id = ntohl (vrf_id);
7623 mp->is_ipv6 = is_ipv6;
7631 api_create_vlan_subif (vat_main_t * vam)
7633 unformat_input_t *i = vam->input;
7634 vl_api_create_vlan_subif_t *mp;
7636 u8 sw_if_index_set = 0;
7641 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7643 if (unformat (i, "sw_if_index %d", &sw_if_index))
7644 sw_if_index_set = 1;
7646 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7647 sw_if_index_set = 1;
7648 else if (unformat (i, "vlan %d", &vlan_id))
7652 clib_warning ("parse error '%U'", format_unformat_error, i);
7657 if (sw_if_index_set == 0)
7659 errmsg ("missing interface name or sw_if_index");
7663 if (vlan_id_set == 0)
7665 errmsg ("missing vlan_id");
7668 M (CREATE_VLAN_SUBIF, mp);
7670 mp->sw_if_index = ntohl (sw_if_index);
7671 mp->vlan_id = ntohl (vlan_id);
7678 #define foreach_create_subif_bit \
7685 _(outer_vlan_id_any) \
7686 _(inner_vlan_id_any)
7689 api_create_subif (vat_main_t * vam)
7691 unformat_input_t *i = vam->input;
7692 vl_api_create_subif_t *mp;
7694 u8 sw_if_index_set = 0;
7701 u32 exact_match = 0;
7702 u32 default_sub = 0;
7703 u32 outer_vlan_id_any = 0;
7704 u32 inner_vlan_id_any = 0;
7706 u16 outer_vlan_id = 0;
7707 u16 inner_vlan_id = 0;
7710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7712 if (unformat (i, "sw_if_index %d", &sw_if_index))
7713 sw_if_index_set = 1;
7715 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7716 sw_if_index_set = 1;
7717 else if (unformat (i, "sub_id %d", &sub_id))
7719 else if (unformat (i, "outer_vlan_id %d", &tmp))
7720 outer_vlan_id = tmp;
7721 else if (unformat (i, "inner_vlan_id %d", &tmp))
7722 inner_vlan_id = tmp;
7724 #define _(a) else if (unformat (i, #a)) a = 1 ;
7725 foreach_create_subif_bit
7729 clib_warning ("parse error '%U'", format_unformat_error, i);
7734 if (sw_if_index_set == 0)
7736 errmsg ("missing interface name or sw_if_index");
7740 if (sub_id_set == 0)
7742 errmsg ("missing sub_id");
7745 M (CREATE_SUBIF, mp);
7747 mp->sw_if_index = ntohl (sw_if_index);
7748 mp->sub_id = ntohl (sub_id);
7750 #define _(a) mp->a = a;
7751 foreach_create_subif_bit;
7754 mp->outer_vlan_id = ntohs (outer_vlan_id);
7755 mp->inner_vlan_id = ntohs (inner_vlan_id);
7763 api_oam_add_del (vat_main_t * vam)
7765 unformat_input_t *i = vam->input;
7766 vl_api_oam_add_del_t *mp;
7769 ip4_address_t src, dst;
7774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7776 if (unformat (i, "vrf %d", &vrf_id))
7778 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7780 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7782 else if (unformat (i, "del"))
7786 clib_warning ("parse error '%U'", format_unformat_error, i);
7793 errmsg ("missing src addr");
7799 errmsg ("missing dst addr");
7803 M (OAM_ADD_DEL, mp);
7805 mp->vrf_id = ntohl (vrf_id);
7806 mp->is_add = is_add;
7807 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7808 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7816 api_reset_fib (vat_main_t * vam)
7818 unformat_input_t *i = vam->input;
7819 vl_api_reset_fib_t *mp;
7825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7827 if (unformat (i, "vrf %d", &vrf_id))
7829 else if (unformat (i, "ipv6"))
7833 clib_warning ("parse error '%U'", format_unformat_error, i);
7838 if (vrf_id_set == 0)
7840 errmsg ("missing vrf id");
7846 mp->vrf_id = ntohl (vrf_id);
7847 mp->is_ipv6 = is_ipv6;
7855 api_dhcp_proxy_config (vat_main_t * vam)
7857 unformat_input_t *i = vam->input;
7858 vl_api_dhcp_proxy_config_t *mp;
7860 u32 server_vrf_id = 0;
7862 u8 v4_address_set = 0;
7863 u8 v6_address_set = 0;
7864 ip4_address_t v4address;
7865 ip6_address_t v6address;
7866 u8 v4_src_address_set = 0;
7867 u8 v6_src_address_set = 0;
7868 ip4_address_t v4srcaddress;
7869 ip6_address_t v6srcaddress;
7872 /* Parse args required to build the message */
7873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7875 if (unformat (i, "del"))
7877 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7879 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7881 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7883 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7885 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7886 v4_src_address_set = 1;
7887 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7888 v6_src_address_set = 1;
7893 if (v4_address_set && v6_address_set)
7895 errmsg ("both v4 and v6 server addresses set");
7898 if (!v4_address_set && !v6_address_set)
7900 errmsg ("no server addresses set");
7904 if (v4_src_address_set && v6_src_address_set)
7906 errmsg ("both v4 and v6 src addresses set");
7909 if (!v4_src_address_set && !v6_src_address_set)
7911 errmsg ("no src addresses set");
7915 if (!(v4_src_address_set && v4_address_set) &&
7916 !(v6_src_address_set && v6_address_set))
7918 errmsg ("no matching server and src addresses set");
7922 /* Construct the API message */
7923 M (DHCP_PROXY_CONFIG, mp);
7925 mp->is_add = is_add;
7926 mp->rx_vrf_id = ntohl (rx_vrf_id);
7927 mp->server_vrf_id = ntohl (server_vrf_id);
7931 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7932 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7936 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7937 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7943 /* Wait for a reply, return good/bad news */
7948 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
7949 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
7952 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
7954 vat_main_t *vam = &vat_main;
7955 u32 i, count = mp->count;
7956 vl_api_dhcp_server_t *s;
7960 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7961 ntohl (mp->rx_vrf_id),
7962 format_ip6_address, mp->dhcp_src_address,
7963 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7966 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7967 ntohl (mp->rx_vrf_id),
7968 format_ip4_address, mp->dhcp_src_address,
7969 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7971 for (i = 0; i < count; i++)
7973 s = &mp->servers[i];
7977 " Server Table-ID %d, Server Address %U",
7978 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
7981 " Server Table-ID %d, Server Address %U",
7982 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
7986 static void vl_api_dhcp_proxy_details_t_handler_json
7987 (vl_api_dhcp_proxy_details_t * mp)
7989 vat_main_t *vam = &vat_main;
7990 vat_json_node_t *node = NULL;
7991 u32 i, count = mp->count;
7993 struct in6_addr ip6;
7994 vl_api_dhcp_server_t *s;
7996 if (VAT_JSON_ARRAY != vam->json_tree.type)
7998 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7999 vat_json_init_array (&vam->json_tree);
8001 node = vat_json_array_add (&vam->json_tree);
8003 vat_json_init_object (node);
8004 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
8005 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
8006 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
8010 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
8011 vat_json_object_add_ip6 (node, "src_address", ip6);
8015 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
8016 vat_json_object_add_ip4 (node, "src_address", ip4);
8019 for (i = 0; i < count; i++)
8021 s = &mp->servers[i];
8023 vat_json_object_add_uint (node, "server-table-id",
8024 ntohl (s->server_vrf_id));
8028 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
8029 vat_json_object_add_ip4 (node, "src_address", ip4);
8033 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
8034 vat_json_object_add_ip6 (node, "server_address", ip6);
8040 api_dhcp_proxy_dump (vat_main_t * vam)
8042 unformat_input_t *i = vam->input;
8043 vl_api_control_ping_t *mp_ping;
8044 vl_api_dhcp_proxy_dump_t *mp;
8048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8050 if (unformat (i, "ipv6"))
8054 clib_warning ("parse error '%U'", format_unformat_error, i);
8059 M (DHCP_PROXY_DUMP, mp);
8061 mp->is_ip6 = is_ipv6;
8064 /* Use a control ping for synchronization */
8065 M (CONTROL_PING, mp_ping);
8073 api_dhcp_proxy_set_vss (vat_main_t * vam)
8075 unformat_input_t *i = vam->input;
8076 vl_api_dhcp_proxy_set_vss_t *mp;
8087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8089 if (unformat (i, "tbl_id %d", &tbl_id))
8091 if (unformat (i, "fib_id %d", &fib_id))
8093 if (unformat (i, "oui %d", &oui))
8095 else if (unformat (i, "ipv6"))
8097 else if (unformat (i, "del"))
8101 clib_warning ("parse error '%U'", format_unformat_error, i);
8106 if (tbl_id_set == 0)
8108 errmsg ("missing tbl id");
8112 if (fib_id_set == 0)
8114 errmsg ("missing fib id");
8119 errmsg ("missing oui");
8123 M (DHCP_PROXY_SET_VSS, mp);
8124 mp->tbl_id = ntohl (tbl_id);
8125 mp->fib_id = ntohl (fib_id);
8126 mp->oui = ntohl (oui);
8127 mp->is_ipv6 = is_ipv6;
8128 mp->is_add = is_add;
8136 api_dhcp_client_config (vat_main_t * vam)
8138 unformat_input_t *i = vam->input;
8139 vl_api_dhcp_client_config_t *mp;
8141 u8 sw_if_index_set = 0;
8144 u8 disable_event = 0;
8147 /* Parse args required to build the message */
8148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8150 if (unformat (i, "del"))
8153 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8154 sw_if_index_set = 1;
8155 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8156 sw_if_index_set = 1;
8157 else if (unformat (i, "hostname %s", &hostname))
8159 else if (unformat (i, "disable_event"))
8165 if (sw_if_index_set == 0)
8167 errmsg ("missing interface name or sw_if_index");
8171 if (vec_len (hostname) > 63)
8173 errmsg ("hostname too long");
8175 vec_add1 (hostname, 0);
8177 /* Construct the API message */
8178 M (DHCP_CLIENT_CONFIG, mp);
8180 mp->sw_if_index = htonl (sw_if_index);
8181 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
8182 vec_free (hostname);
8183 mp->is_add = is_add;
8184 mp->want_dhcp_event = disable_event ? 0 : 1;
8185 mp->pid = htonl (getpid ());
8190 /* Wait for a reply, return good/bad news */
8196 api_set_ip_flow_hash (vat_main_t * vam)
8198 unformat_input_t *i = vam->input;
8199 vl_api_set_ip_flow_hash_t *mp;
8211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8213 if (unformat (i, "vrf %d", &vrf_id))
8215 else if (unformat (i, "ipv6"))
8217 else if (unformat (i, "src"))
8219 else if (unformat (i, "dst"))
8221 else if (unformat (i, "sport"))
8223 else if (unformat (i, "dport"))
8225 else if (unformat (i, "proto"))
8227 else if (unformat (i, "reverse"))
8232 clib_warning ("parse error '%U'", format_unformat_error, i);
8237 if (vrf_id_set == 0)
8239 errmsg ("missing vrf id");
8243 M (SET_IP_FLOW_HASH, mp);
8249 mp->reverse = reverse;
8250 mp->vrf_id = ntohl (vrf_id);
8251 mp->is_ipv6 = is_ipv6;
8259 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
8261 unformat_input_t *i = vam->input;
8262 vl_api_sw_interface_ip6_enable_disable_t *mp;
8264 u8 sw_if_index_set = 0;
8268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8270 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8271 sw_if_index_set = 1;
8272 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8273 sw_if_index_set = 1;
8274 else if (unformat (i, "enable"))
8276 else if (unformat (i, "disable"))
8280 clib_warning ("parse error '%U'", format_unformat_error, i);
8285 if (sw_if_index_set == 0)
8287 errmsg ("missing interface name or sw_if_index");
8291 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8293 mp->sw_if_index = ntohl (sw_if_index);
8294 mp->enable = enable;
8302 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8304 unformat_input_t *i = vam->input;
8305 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8307 u8 sw_if_index_set = 0;
8308 u8 v6_address_set = 0;
8309 ip6_address_t v6address;
8312 /* Parse args required to build the message */
8313 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8315 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8316 sw_if_index_set = 1;
8317 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8318 sw_if_index_set = 1;
8319 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8325 if (sw_if_index_set == 0)
8327 errmsg ("missing interface name or sw_if_index");
8330 if (!v6_address_set)
8332 errmsg ("no address set");
8336 /* Construct the API message */
8337 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8339 mp->sw_if_index = ntohl (sw_if_index);
8340 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8345 /* Wait for a reply, return good/bad news */
8351 api_ip6nd_proxy_add_del (vat_main_t * vam)
8353 unformat_input_t *i = vam->input;
8354 vl_api_ip6nd_proxy_add_del_t *mp;
8355 u32 sw_if_index = ~0;
8356 u8 v6_address_set = 0;
8357 ip6_address_t v6address;
8361 /* Parse args required to build the message */
8362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8364 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8366 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8368 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8370 if (unformat (i, "del"))
8374 clib_warning ("parse error '%U'", format_unformat_error, i);
8379 if (sw_if_index == ~0)
8381 errmsg ("missing interface name or sw_if_index");
8384 if (!v6_address_set)
8386 errmsg ("no address set");
8390 /* Construct the API message */
8391 M (IP6ND_PROXY_ADD_DEL, mp);
8393 mp->is_del = is_del;
8394 mp->sw_if_index = ntohl (sw_if_index);
8395 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8400 /* Wait for a reply, return good/bad news */
8406 api_ip6nd_proxy_dump (vat_main_t * vam)
8408 vl_api_ip6nd_proxy_dump_t *mp;
8409 vl_api_control_ping_t *mp_ping;
8412 M (IP6ND_PROXY_DUMP, mp);
8416 /* Use a control ping for synchronization */
8417 M (CONTROL_PING, mp_ping);
8424 static void vl_api_ip6nd_proxy_details_t_handler
8425 (vl_api_ip6nd_proxy_details_t * mp)
8427 vat_main_t *vam = &vat_main;
8429 print (vam->ofp, "host %U sw_if_index %d",
8430 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
8433 static void vl_api_ip6nd_proxy_details_t_handler_json
8434 (vl_api_ip6nd_proxy_details_t * mp)
8436 vat_main_t *vam = &vat_main;
8437 struct in6_addr ip6;
8438 vat_json_node_t *node = NULL;
8440 if (VAT_JSON_ARRAY != vam->json_tree.type)
8442 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8443 vat_json_init_array (&vam->json_tree);
8445 node = vat_json_array_add (&vam->json_tree);
8447 vat_json_init_object (node);
8448 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8450 clib_memcpy (&ip6, mp->address, sizeof (ip6));
8451 vat_json_object_add_ip6 (node, "host", ip6);
8455 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8457 unformat_input_t *i = vam->input;
8458 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8460 u8 sw_if_index_set = 0;
8461 u32 address_length = 0;
8462 u8 v6_address_set = 0;
8463 ip6_address_t v6address;
8465 u8 no_advertise = 0;
8467 u8 no_autoconfig = 0;
8470 u32 val_lifetime = 0;
8471 u32 pref_lifetime = 0;
8474 /* Parse args required to build the message */
8475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8477 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8478 sw_if_index_set = 1;
8479 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8480 sw_if_index_set = 1;
8481 else if (unformat (i, "%U/%d",
8482 unformat_ip6_address, &v6address, &address_length))
8484 else if (unformat (i, "val_life %d", &val_lifetime))
8486 else if (unformat (i, "pref_life %d", &pref_lifetime))
8488 else if (unformat (i, "def"))
8490 else if (unformat (i, "noadv"))
8492 else if (unformat (i, "offl"))
8494 else if (unformat (i, "noauto"))
8496 else if (unformat (i, "nolink"))
8498 else if (unformat (i, "isno"))
8502 clib_warning ("parse error '%U'", format_unformat_error, i);
8507 if (sw_if_index_set == 0)
8509 errmsg ("missing interface name or sw_if_index");
8512 if (!v6_address_set)
8514 errmsg ("no address set");
8518 /* Construct the API message */
8519 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8521 mp->sw_if_index = ntohl (sw_if_index);
8522 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8523 mp->address_length = address_length;
8524 mp->use_default = use_default;
8525 mp->no_advertise = no_advertise;
8526 mp->off_link = off_link;
8527 mp->no_autoconfig = no_autoconfig;
8528 mp->no_onlink = no_onlink;
8530 mp->val_lifetime = ntohl (val_lifetime);
8531 mp->pref_lifetime = ntohl (pref_lifetime);
8536 /* Wait for a reply, return good/bad news */
8542 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8544 unformat_input_t *i = vam->input;
8545 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8547 u8 sw_if_index_set = 0;
8552 u8 send_unicast = 0;
8555 u8 default_router = 0;
8556 u32 max_interval = 0;
8557 u32 min_interval = 0;
8559 u32 initial_count = 0;
8560 u32 initial_interval = 0;
8564 /* Parse args required to build the message */
8565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8567 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8568 sw_if_index_set = 1;
8569 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8570 sw_if_index_set = 1;
8571 else if (unformat (i, "maxint %d", &max_interval))
8573 else if (unformat (i, "minint %d", &min_interval))
8575 else if (unformat (i, "life %d", &lifetime))
8577 else if (unformat (i, "count %d", &initial_count))
8579 else if (unformat (i, "interval %d", &initial_interval))
8581 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8583 else if (unformat (i, "managed"))
8585 else if (unformat (i, "other"))
8587 else if (unformat (i, "ll"))
8589 else if (unformat (i, "send"))
8591 else if (unformat (i, "cease"))
8593 else if (unformat (i, "isno"))
8595 else if (unformat (i, "def"))
8599 clib_warning ("parse error '%U'", format_unformat_error, i);
8604 if (sw_if_index_set == 0)
8606 errmsg ("missing interface name or sw_if_index");
8610 /* Construct the API message */
8611 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8613 mp->sw_if_index = ntohl (sw_if_index);
8614 mp->max_interval = ntohl (max_interval);
8615 mp->min_interval = ntohl (min_interval);
8616 mp->lifetime = ntohl (lifetime);
8617 mp->initial_count = ntohl (initial_count);
8618 mp->initial_interval = ntohl (initial_interval);
8619 mp->suppress = suppress;
8620 mp->managed = managed;
8622 mp->ll_option = ll_option;
8623 mp->send_unicast = send_unicast;
8626 mp->default_router = default_router;
8631 /* Wait for a reply, return good/bad news */
8637 api_set_arp_neighbor_limit (vat_main_t * vam)
8639 unformat_input_t *i = vam->input;
8640 vl_api_set_arp_neighbor_limit_t *mp;
8646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8648 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8650 else if (unformat (i, "ipv6"))
8654 clib_warning ("parse error '%U'", format_unformat_error, i);
8661 errmsg ("missing limit value");
8665 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8667 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8668 mp->is_ipv6 = is_ipv6;
8676 api_l2_patch_add_del (vat_main_t * vam)
8678 unformat_input_t *i = vam->input;
8679 vl_api_l2_patch_add_del_t *mp;
8681 u8 rx_sw_if_index_set = 0;
8683 u8 tx_sw_if_index_set = 0;
8687 /* Parse args required to build the message */
8688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8690 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8691 rx_sw_if_index_set = 1;
8692 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8693 tx_sw_if_index_set = 1;
8694 else if (unformat (i, "rx"))
8696 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8698 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8700 rx_sw_if_index_set = 1;
8705 else if (unformat (i, "tx"))
8707 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8709 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8711 tx_sw_if_index_set = 1;
8716 else if (unformat (i, "del"))
8722 if (rx_sw_if_index_set == 0)
8724 errmsg ("missing rx interface name or rx_sw_if_index");
8728 if (tx_sw_if_index_set == 0)
8730 errmsg ("missing tx interface name or tx_sw_if_index");
8734 M (L2_PATCH_ADD_DEL, mp);
8736 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8737 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8738 mp->is_add = is_add;
8746 u8 localsid_addr[16];
8755 api_sr_localsid_add_del (vat_main_t * vam)
8757 unformat_input_t *i = vam->input;
8758 vl_api_sr_localsid_add_del_t *mp;
8761 ip6_address_t localsid;
8765 u32 fib_table = ~(u32) 0;
8766 ip6_address_t next_hop;
8768 bool nexthop_set = 0;
8772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8774 if (unformat (i, "del"))
8776 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
8777 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
8779 else if (unformat (i, "behavior %u", &behavior));
8780 else if (unformat (i, "sw_if_index %u", &sw_if_index));
8781 else if (unformat (i, "fib-table %u", &fib_table));
8782 else if (unformat (i, "end.psp %u", &behavior));
8787 M (SR_LOCALSID_ADD_DEL, mp);
8789 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
8791 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
8792 mp->behavior = behavior;
8793 mp->sw_if_index = ntohl (sw_if_index);
8794 mp->fib_table = ntohl (fib_table);
8795 mp->end_psp = end_psp;
8796 mp->is_del = is_del;
8804 api_ioam_enable (vat_main_t * vam)
8806 unformat_input_t *input = vam->input;
8807 vl_api_ioam_enable_t *mp;
8809 int has_trace_option = 0;
8810 int has_pot_option = 0;
8811 int has_seqno_option = 0;
8812 int has_analyse_option = 0;
8815 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8817 if (unformat (input, "trace"))
8818 has_trace_option = 1;
8819 else if (unformat (input, "pot"))
8821 else if (unformat (input, "seqno"))
8822 has_seqno_option = 1;
8823 else if (unformat (input, "analyse"))
8824 has_analyse_option = 1;
8828 M (IOAM_ENABLE, mp);
8829 mp->id = htons (id);
8830 mp->seqno = has_seqno_option;
8831 mp->analyse = has_analyse_option;
8832 mp->pot_enable = has_pot_option;
8833 mp->trace_enable = has_trace_option;
8842 api_ioam_disable (vat_main_t * vam)
8844 vl_api_ioam_disable_t *mp;
8847 M (IOAM_DISABLE, mp);
8853 #define foreach_tcp_proto_field \
8857 #define foreach_udp_proto_field \
8861 #define foreach_ip4_proto_field \
8873 u16 src_port, dst_port;
8876 #if VPP_API_TEST_BUILTIN == 0
8878 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8880 u8 **maskp = va_arg (*args, u8 **);
8882 u8 found_something = 0;
8885 #define _(a) u8 a=0;
8886 foreach_tcp_proto_field;
8889 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8892 #define _(a) else if (unformat (input, #a)) a=1;
8893 foreach_tcp_proto_field
8899 #define _(a) found_something += a;
8900 foreach_tcp_proto_field;
8903 if (found_something == 0)
8906 vec_validate (mask, sizeof (*tcp) - 1);
8908 tcp = (tcp_header_t *) mask;
8910 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8911 foreach_tcp_proto_field;
8919 unformat_udp_mask (unformat_input_t * input, va_list * args)
8921 u8 **maskp = va_arg (*args, u8 **);
8923 u8 found_something = 0;
8926 #define _(a) u8 a=0;
8927 foreach_udp_proto_field;
8930 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8933 #define _(a) else if (unformat (input, #a)) a=1;
8934 foreach_udp_proto_field
8940 #define _(a) found_something += a;
8941 foreach_udp_proto_field;
8944 if (found_something == 0)
8947 vec_validate (mask, sizeof (*udp) - 1);
8949 udp = (udp_header_t *) mask;
8951 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8952 foreach_udp_proto_field;
8960 unformat_l4_mask (unformat_input_t * input, va_list * args)
8962 u8 **maskp = va_arg (*args, u8 **);
8963 u16 src_port = 0, dst_port = 0;
8964 tcpudp_header_t *tcpudp;
8966 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8968 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8970 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8972 else if (unformat (input, "src_port"))
8974 else if (unformat (input, "dst_port"))
8980 if (!src_port && !dst_port)
8984 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8986 tcpudp = (tcpudp_header_t *) mask;
8987 tcpudp->src_port = src_port;
8988 tcpudp->dst_port = dst_port;
8996 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8998 u8 **maskp = va_arg (*args, u8 **);
9000 u8 found_something = 0;
9003 #define _(a) u8 a=0;
9004 foreach_ip4_proto_field;
9010 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9012 if (unformat (input, "version"))
9014 else if (unformat (input, "hdr_length"))
9016 else if (unformat (input, "src"))
9018 else if (unformat (input, "dst"))
9020 else if (unformat (input, "proto"))
9023 #define _(a) else if (unformat (input, #a)) a=1;
9024 foreach_ip4_proto_field
9030 #define _(a) found_something += a;
9031 foreach_ip4_proto_field;
9034 if (found_something == 0)
9037 vec_validate (mask, sizeof (*ip) - 1);
9039 ip = (ip4_header_t *) mask;
9041 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9042 foreach_ip4_proto_field;
9045 ip->ip_version_and_header_length = 0;
9048 ip->ip_version_and_header_length |= 0xF0;
9051 ip->ip_version_and_header_length |= 0x0F;
9057 #define foreach_ip6_proto_field \
9065 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9067 u8 **maskp = va_arg (*args, u8 **);
9069 u8 found_something = 0;
9071 u32 ip_version_traffic_class_and_flow_label;
9073 #define _(a) u8 a=0;
9074 foreach_ip6_proto_field;
9077 u8 traffic_class = 0;
9080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9082 if (unformat (input, "version"))
9084 else if (unformat (input, "traffic-class"))
9086 else if (unformat (input, "flow-label"))
9088 else if (unformat (input, "src"))
9090 else if (unformat (input, "dst"))
9092 else if (unformat (input, "proto"))
9095 #define _(a) else if (unformat (input, #a)) a=1;
9096 foreach_ip6_proto_field
9102 #define _(a) found_something += a;
9103 foreach_ip6_proto_field;
9106 if (found_something == 0)
9109 vec_validate (mask, sizeof (*ip) - 1);
9111 ip = (ip6_header_t *) mask;
9113 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
9114 foreach_ip6_proto_field;
9117 ip_version_traffic_class_and_flow_label = 0;
9120 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9123 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9126 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9128 ip->ip_version_traffic_class_and_flow_label =
9129 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9136 unformat_l3_mask (unformat_input_t * input, va_list * args)
9138 u8 **maskp = va_arg (*args, u8 **);
9140 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9142 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9144 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9153 unformat_l2_mask (unformat_input_t * input, va_list * args)
9155 u8 **maskp = va_arg (*args, u8 **);
9170 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9172 if (unformat (input, "src"))
9174 else if (unformat (input, "dst"))
9176 else if (unformat (input, "proto"))
9178 else if (unformat (input, "tag1"))
9180 else if (unformat (input, "tag2"))
9182 else if (unformat (input, "ignore-tag1"))
9184 else if (unformat (input, "ignore-tag2"))
9186 else if (unformat (input, "cos1"))
9188 else if (unformat (input, "cos2"))
9190 else if (unformat (input, "dot1q"))
9192 else if (unformat (input, "dot1ad"))
9197 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9198 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9201 if (tag1 || ignore_tag1 || cos1 || dot1q)
9203 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9206 vec_validate (mask, len - 1);
9209 memset (mask, 0xff, 6);
9212 memset (mask + 6, 0xff, 6);
9216 /* inner vlan tag */
9225 mask[21] = mask[20] = 0xff;
9246 mask[16] = mask[17] = 0xff;
9256 mask[12] = mask[13] = 0xff;
9263 unformat_classify_mask (unformat_input_t * input, va_list * args)
9265 u8 **maskp = va_arg (*args, u8 **);
9266 u32 *skipp = va_arg (*args, u32 *);
9267 u32 *matchp = va_arg (*args, u32 *);
9275 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9277 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9279 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9281 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9283 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9297 if (mask || l2 || l3 || l4)
9301 /* "With a free Ethernet header in every package" */
9303 vec_validate (l2, 13);
9307 vec_append (mask, l3);
9312 vec_append (mask, l4);
9317 /* Scan forward looking for the first significant mask octet */
9318 for (i = 0; i < vec_len (mask); i++)
9322 /* compute (skip, match) params */
9323 *skipp = i / sizeof (u32x4);
9324 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9326 /* Pad mask to an even multiple of the vector size */
9327 while (vec_len (mask) % sizeof (u32x4))
9330 match = vec_len (mask) / sizeof (u32x4);
9332 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9334 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9335 if (*tmp || *(tmp + 1))
9340 clib_warning ("BUG: match 0");
9342 _vec_len (mask) = match * sizeof (u32x4);
9352 #endif /* VPP_API_TEST_BUILTIN */
9354 #define foreach_l2_next \
9356 _(ethernet, ETHERNET_INPUT) \
9361 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9363 u32 *miss_next_indexp = va_arg (*args, u32 *);
9368 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9372 if (unformat (input, "%d", &tmp))
9381 *miss_next_indexp = next_index;
9385 #define foreach_ip_next \
9391 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9393 u32 *miss_next_indexp = va_arg (*args, u32 *);
9398 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9402 if (unformat (input, "%d", &tmp))
9411 *miss_next_indexp = next_index;
9415 #define foreach_acl_next \
9419 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9421 u32 *miss_next_indexp = va_arg (*args, u32 *);
9426 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9430 if (unformat (input, "permit"))
9435 else if (unformat (input, "%d", &tmp))
9444 *miss_next_indexp = next_index;
9449 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9451 u32 *r = va_arg (*args, u32 *);
9453 if (unformat (input, "conform-color"))
9454 *r = POLICE_CONFORM;
9455 else if (unformat (input, "exceed-color"))
9464 api_classify_add_del_table (vat_main_t * vam)
9466 unformat_input_t *i = vam->input;
9467 vl_api_classify_add_del_table_t *mp;
9474 u32 table_index = ~0;
9475 u32 next_table_index = ~0;
9476 u32 miss_next_index = ~0;
9477 u32 memory_size = 32 << 20;
9479 u32 current_data_flag = 0;
9480 int current_data_offset = 0;
9483 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9485 if (unformat (i, "del"))
9487 else if (unformat (i, "del-chain"))
9492 else if (unformat (i, "buckets %d", &nbuckets))
9494 else if (unformat (i, "memory_size %d", &memory_size))
9496 else if (unformat (i, "skip %d", &skip))
9498 else if (unformat (i, "match %d", &match))
9500 else if (unformat (i, "table %d", &table_index))
9502 else if (unformat (i, "mask %U", unformat_classify_mask,
9503 &mask, &skip, &match))
9505 else if (unformat (i, "next-table %d", &next_table_index))
9507 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
9510 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9513 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
9516 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9518 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9524 if (is_add && mask == 0)
9526 errmsg ("Mask required");
9530 if (is_add && skip == ~0)
9532 errmsg ("skip count required");
9536 if (is_add && match == ~0)
9538 errmsg ("match count required");
9542 if (!is_add && table_index == ~0)
9544 errmsg ("table index required for delete");
9548 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9550 mp->is_add = is_add;
9551 mp->del_chain = del_chain;
9552 mp->table_index = ntohl (table_index);
9553 mp->nbuckets = ntohl (nbuckets);
9554 mp->memory_size = ntohl (memory_size);
9555 mp->skip_n_vectors = ntohl (skip);
9556 mp->match_n_vectors = ntohl (match);
9557 mp->next_table_index = ntohl (next_table_index);
9558 mp->miss_next_index = ntohl (miss_next_index);
9559 mp->current_data_flag = ntohl (current_data_flag);
9560 mp->current_data_offset = ntohl (current_data_offset);
9561 clib_memcpy (mp->mask, mask, vec_len (mask));
9570 #if VPP_API_TEST_BUILTIN == 0
9572 unformat_l4_match (unformat_input_t * input, va_list * args)
9574 u8 **matchp = va_arg (*args, u8 **);
9576 u8 *proto_header = 0;
9582 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9584 if (unformat (input, "src_port %d", &src_port))
9586 else if (unformat (input, "dst_port %d", &dst_port))
9592 h.src_port = clib_host_to_net_u16 (src_port);
9593 h.dst_port = clib_host_to_net_u16 (dst_port);
9594 vec_validate (proto_header, sizeof (h) - 1);
9595 memcpy (proto_header, &h, sizeof (h));
9597 *matchp = proto_header;
9603 unformat_ip4_match (unformat_input_t * input, va_list * args)
9605 u8 **matchp = va_arg (*args, u8 **);
9612 int src = 0, dst = 0;
9613 ip4_address_t src_val, dst_val;
9620 int fragment_id = 0;
9621 u32 fragment_id_val;
9627 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9629 if (unformat (input, "version %d", &version_val))
9631 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9633 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9635 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9637 else if (unformat (input, "proto %d", &proto_val))
9639 else if (unformat (input, "tos %d", &tos_val))
9641 else if (unformat (input, "length %d", &length_val))
9643 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9645 else if (unformat (input, "ttl %d", &ttl_val))
9647 else if (unformat (input, "checksum %d", &checksum_val))
9653 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9654 + ttl + checksum == 0)
9658 * Aligned because we use the real comparison functions
9660 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9662 ip = (ip4_header_t *) match;
9664 /* These are realistically matched in practice */
9666 ip->src_address.as_u32 = src_val.as_u32;
9669 ip->dst_address.as_u32 = dst_val.as_u32;
9672 ip->protocol = proto_val;
9675 /* These are not, but they're included for completeness */
9677 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9680 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9686 ip->length = clib_host_to_net_u16 (length_val);
9692 ip->checksum = clib_host_to_net_u16 (checksum_val);
9699 unformat_ip6_match (unformat_input_t * input, va_list * args)
9701 u8 **matchp = va_arg (*args, u8 **);
9706 u8 traffic_class = 0;
9707 u32 traffic_class_val = 0;
9710 int src = 0, dst = 0;
9711 ip6_address_t src_val, dst_val;
9714 int payload_length = 0;
9715 u32 payload_length_val;
9718 u32 ip_version_traffic_class_and_flow_label;
9720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9722 if (unformat (input, "version %d", &version_val))
9724 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9726 else if (unformat (input, "flow_label %d", &flow_label_val))
9728 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9730 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9732 else if (unformat (input, "proto %d", &proto_val))
9734 else if (unformat (input, "payload_length %d", &payload_length_val))
9736 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9742 if (version + traffic_class + flow_label + src + dst + proto +
9743 payload_length + hop_limit == 0)
9747 * Aligned because we use the real comparison functions
9749 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9751 ip = (ip6_header_t *) match;
9754 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9757 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9760 ip->protocol = proto_val;
9762 ip_version_traffic_class_and_flow_label = 0;
9765 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9768 ip_version_traffic_class_and_flow_label |=
9769 (traffic_class_val & 0xFF) << 20;
9772 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9774 ip->ip_version_traffic_class_and_flow_label =
9775 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9778 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9781 ip->hop_limit = hop_limit_val;
9788 unformat_l3_match (unformat_input_t * input, va_list * args)
9790 u8 **matchp = va_arg (*args, u8 **);
9792 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9794 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9796 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9805 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9807 u8 *tagp = va_arg (*args, u8 *);
9810 if (unformat (input, "%d", &tag))
9812 tagp[0] = (tag >> 8) & 0x0F;
9813 tagp[1] = tag & 0xFF;
9821 unformat_l2_match (unformat_input_t * input, va_list * args)
9823 u8 **matchp = va_arg (*args, u8 **);
9843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9845 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9848 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9850 else if (unformat (input, "proto %U",
9851 unformat_ethernet_type_host_byte_order, &proto_val))
9853 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9855 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9857 else if (unformat (input, "ignore-tag1"))
9859 else if (unformat (input, "ignore-tag2"))
9861 else if (unformat (input, "cos1 %d", &cos1_val))
9863 else if (unformat (input, "cos2 %d", &cos2_val))
9868 if ((src + dst + proto + tag1 + tag2 +
9869 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9872 if (tag1 || ignore_tag1 || cos1)
9874 if (tag2 || ignore_tag2 || cos2)
9877 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9880 clib_memcpy (match, dst_val, 6);
9883 clib_memcpy (match + 6, src_val, 6);
9887 /* inner vlan tag */
9888 match[19] = tag2_val[1];
9889 match[18] = tag2_val[0];
9891 match[18] |= (cos2_val & 0x7) << 5;
9894 match[21] = proto_val & 0xff;
9895 match[20] = proto_val >> 8;
9899 match[15] = tag1_val[1];
9900 match[14] = tag1_val[0];
9903 match[14] |= (cos1_val & 0x7) << 5;
9909 match[15] = tag1_val[1];
9910 match[14] = tag1_val[0];
9913 match[17] = proto_val & 0xff;
9914 match[16] = proto_val >> 8;
9917 match[14] |= (cos1_val & 0x7) << 5;
9923 match[18] |= (cos2_val & 0x7) << 5;
9925 match[14] |= (cos1_val & 0x7) << 5;
9928 match[13] = proto_val & 0xff;
9929 match[12] = proto_val >> 8;
9938 api_unformat_classify_match (unformat_input_t * input, va_list * args)
9940 u8 **matchp = va_arg (*args, u8 **);
9941 u32 skip_n_vectors = va_arg (*args, u32);
9942 u32 match_n_vectors = va_arg (*args, u32);
9949 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9951 if (unformat (input, "hex %U", unformat_hex_string, &match))
9953 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9955 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9957 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9971 if (match || l2 || l3 || l4)
9975 /* "Win a free Ethernet header in every packet" */
9977 vec_validate_aligned (l2, 13, sizeof (u32x4));
9981 vec_append_aligned (match, l3, sizeof (u32x4));
9986 vec_append_aligned (match, l4, sizeof (u32x4));
9991 /* Make sure the vector is big enough even if key is all 0's */
9992 vec_validate_aligned
9993 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9996 /* Set size, include skipped vectors */
9997 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10008 api_classify_add_del_session (vat_main_t * vam)
10010 unformat_input_t *i = vam->input;
10011 vl_api_classify_add_del_session_t *mp;
10013 u32 table_index = ~0;
10014 u32 hit_next_index = ~0;
10015 u32 opaque_index = ~0;
10018 u32 skip_n_vectors = 0;
10019 u32 match_n_vectors = 0;
10025 * Warning: you have to supply skip_n and match_n
10026 * because the API client cant simply look at the classify
10030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10032 if (unformat (i, "del"))
10034 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10037 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10040 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10043 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10045 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10047 else if (unformat (i, "opaque-index %d", &opaque_index))
10049 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10051 else if (unformat (i, "match_n %d", &match_n_vectors))
10053 else if (unformat (i, "match %U", api_unformat_classify_match,
10054 &match, skip_n_vectors, match_n_vectors))
10056 else if (unformat (i, "advance %d", &advance))
10058 else if (unformat (i, "table-index %d", &table_index))
10060 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10062 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10064 else if (unformat (i, "action %d", &action))
10066 else if (unformat (i, "metadata %d", &metadata))
10072 if (table_index == ~0)
10074 errmsg ("Table index required");
10078 if (is_add && match == 0)
10080 errmsg ("Match value required");
10084 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10086 mp->is_add = is_add;
10087 mp->table_index = ntohl (table_index);
10088 mp->hit_next_index = ntohl (hit_next_index);
10089 mp->opaque_index = ntohl (opaque_index);
10090 mp->advance = ntohl (advance);
10091 mp->action = action;
10092 mp->metadata = ntohl (metadata);
10093 clib_memcpy (mp->match, match, vec_len (match));
10102 api_classify_set_interface_ip_table (vat_main_t * vam)
10104 unformat_input_t *i = vam->input;
10105 vl_api_classify_set_interface_ip_table_t *mp;
10107 int sw_if_index_set;
10108 u32 table_index = ~0;
10112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10114 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10115 sw_if_index_set = 1;
10116 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10117 sw_if_index_set = 1;
10118 else if (unformat (i, "table %d", &table_index))
10122 clib_warning ("parse error '%U'", format_unformat_error, i);
10127 if (sw_if_index_set == 0)
10129 errmsg ("missing interface name or sw_if_index");
10134 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10136 mp->sw_if_index = ntohl (sw_if_index);
10137 mp->table_index = ntohl (table_index);
10138 mp->is_ipv6 = is_ipv6;
10146 api_classify_set_interface_l2_tables (vat_main_t * vam)
10148 unformat_input_t *i = vam->input;
10149 vl_api_classify_set_interface_l2_tables_t *mp;
10151 int sw_if_index_set;
10152 u32 ip4_table_index = ~0;
10153 u32 ip6_table_index = ~0;
10154 u32 other_table_index = ~0;
10158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10160 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10161 sw_if_index_set = 1;
10162 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10163 sw_if_index_set = 1;
10164 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10166 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10168 else if (unformat (i, "other-table %d", &other_table_index))
10170 else if (unformat (i, "is-input %d", &is_input))
10174 clib_warning ("parse error '%U'", format_unformat_error, i);
10179 if (sw_if_index_set == 0)
10181 errmsg ("missing interface name or sw_if_index");
10186 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10188 mp->sw_if_index = ntohl (sw_if_index);
10189 mp->ip4_table_index = ntohl (ip4_table_index);
10190 mp->ip6_table_index = ntohl (ip6_table_index);
10191 mp->other_table_index = ntohl (other_table_index);
10192 mp->is_input = (u8) is_input;
10200 api_set_ipfix_exporter (vat_main_t * vam)
10202 unformat_input_t *i = vam->input;
10203 vl_api_set_ipfix_exporter_t *mp;
10204 ip4_address_t collector_address;
10205 u8 collector_address_set = 0;
10206 u32 collector_port = ~0;
10207 ip4_address_t src_address;
10208 u8 src_address_set = 0;
10211 u32 template_interval = ~0;
10212 u8 udp_checksum = 0;
10215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10217 if (unformat (i, "collector_address %U", unformat_ip4_address,
10218 &collector_address))
10219 collector_address_set = 1;
10220 else if (unformat (i, "collector_port %d", &collector_port))
10222 else if (unformat (i, "src_address %U", unformat_ip4_address,
10224 src_address_set = 1;
10225 else if (unformat (i, "vrf_id %d", &vrf_id))
10227 else if (unformat (i, "path_mtu %d", &path_mtu))
10229 else if (unformat (i, "template_interval %d", &template_interval))
10231 else if (unformat (i, "udp_checksum"))
10237 if (collector_address_set == 0)
10239 errmsg ("collector_address required");
10243 if (src_address_set == 0)
10245 errmsg ("src_address required");
10249 M (SET_IPFIX_EXPORTER, mp);
10251 memcpy (mp->collector_address, collector_address.data,
10252 sizeof (collector_address.data));
10253 mp->collector_port = htons ((u16) collector_port);
10254 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10255 mp->vrf_id = htonl (vrf_id);
10256 mp->path_mtu = htonl (path_mtu);
10257 mp->template_interval = htonl (template_interval);
10258 mp->udp_checksum = udp_checksum;
10266 api_set_ipfix_classify_stream (vat_main_t * vam)
10268 unformat_input_t *i = vam->input;
10269 vl_api_set_ipfix_classify_stream_t *mp;
10271 u32 src_port = UDP_DST_PORT_ipfix;
10274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10276 if (unformat (i, "domain %d", &domain_id))
10278 else if (unformat (i, "src_port %d", &src_port))
10282 errmsg ("unknown input `%U'", format_unformat_error, i);
10287 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10289 mp->domain_id = htonl (domain_id);
10290 mp->src_port = htons ((u16) src_port);
10298 api_ipfix_classify_table_add_del (vat_main_t * vam)
10300 unformat_input_t *i = vam->input;
10301 vl_api_ipfix_classify_table_add_del_t *mp;
10303 u32 classify_table_index = ~0;
10305 u8 transport_protocol = 255;
10308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10310 if (unformat (i, "add"))
10312 else if (unformat (i, "del"))
10314 else if (unformat (i, "table %d", &classify_table_index))
10316 else if (unformat (i, "ip4"))
10318 else if (unformat (i, "ip6"))
10320 else if (unformat (i, "tcp"))
10321 transport_protocol = 6;
10322 else if (unformat (i, "udp"))
10323 transport_protocol = 17;
10326 errmsg ("unknown input `%U'", format_unformat_error, i);
10333 errmsg ("expecting: add|del");
10336 if (classify_table_index == ~0)
10338 errmsg ("classifier table not specified");
10341 if (ip_version == 0)
10343 errmsg ("IP version not specified");
10347 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10349 mp->is_add = is_add;
10350 mp->table_id = htonl (classify_table_index);
10351 mp->ip_version = ip_version;
10352 mp->transport_protocol = transport_protocol;
10360 api_get_node_index (vat_main_t * vam)
10362 unformat_input_t *i = vam->input;
10363 vl_api_get_node_index_t *mp;
10367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10369 if (unformat (i, "node %s", &name))
10376 errmsg ("node name required");
10379 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10381 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10385 M (GET_NODE_INDEX, mp);
10386 clib_memcpy (mp->node_name, name, vec_len (name));
10395 api_get_next_index (vat_main_t * vam)
10397 unformat_input_t *i = vam->input;
10398 vl_api_get_next_index_t *mp;
10399 u8 *node_name = 0, *next_node_name = 0;
10402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10404 if (unformat (i, "node-name %s", &node_name))
10406 else if (unformat (i, "next-node-name %s", &next_node_name))
10410 if (node_name == 0)
10412 errmsg ("node name required");
10415 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10417 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10421 if (next_node_name == 0)
10423 errmsg ("next node name required");
10426 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10428 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10432 M (GET_NEXT_INDEX, mp);
10433 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10434 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10435 vec_free (node_name);
10436 vec_free (next_node_name);
10444 api_add_node_next (vat_main_t * vam)
10446 unformat_input_t *i = vam->input;
10447 vl_api_add_node_next_t *mp;
10452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10454 if (unformat (i, "node %s", &name))
10456 else if (unformat (i, "next %s", &next))
10463 errmsg ("node name required");
10466 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10468 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10473 errmsg ("next node required");
10476 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10478 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10482 M (ADD_NODE_NEXT, mp);
10483 clib_memcpy (mp->node_name, name, vec_len (name));
10484 clib_memcpy (mp->next_name, next, vec_len (next));
10494 api_l2tpv3_create_tunnel (vat_main_t * vam)
10496 unformat_input_t *i = vam->input;
10497 ip6_address_t client_address, our_address;
10498 int client_address_set = 0;
10499 int our_address_set = 0;
10500 u32 local_session_id = 0;
10501 u32 remote_session_id = 0;
10502 u64 local_cookie = 0;
10503 u64 remote_cookie = 0;
10504 u8 l2_sublayer_present = 0;
10505 vl_api_l2tpv3_create_tunnel_t *mp;
10508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10510 if (unformat (i, "client_address %U", unformat_ip6_address,
10512 client_address_set = 1;
10513 else if (unformat (i, "our_address %U", unformat_ip6_address,
10515 our_address_set = 1;
10516 else if (unformat (i, "local_session_id %d", &local_session_id))
10518 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10520 else if (unformat (i, "local_cookie %lld", &local_cookie))
10522 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10524 else if (unformat (i, "l2-sublayer-present"))
10525 l2_sublayer_present = 1;
10530 if (client_address_set == 0)
10532 errmsg ("client_address required");
10536 if (our_address_set == 0)
10538 errmsg ("our_address required");
10542 M (L2TPV3_CREATE_TUNNEL, mp);
10544 clib_memcpy (mp->client_address, client_address.as_u8,
10545 sizeof (mp->client_address));
10547 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10549 mp->local_session_id = ntohl (local_session_id);
10550 mp->remote_session_id = ntohl (remote_session_id);
10551 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10552 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10553 mp->l2_sublayer_present = l2_sublayer_present;
10562 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10564 unformat_input_t *i = vam->input;
10566 u8 sw_if_index_set = 0;
10567 u64 new_local_cookie = 0;
10568 u64 new_remote_cookie = 0;
10569 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10572 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10574 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10575 sw_if_index_set = 1;
10576 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10577 sw_if_index_set = 1;
10578 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10580 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10586 if (sw_if_index_set == 0)
10588 errmsg ("missing interface name or sw_if_index");
10592 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10594 mp->sw_if_index = ntohl (sw_if_index);
10595 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10596 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10604 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10606 unformat_input_t *i = vam->input;
10607 vl_api_l2tpv3_interface_enable_disable_t *mp;
10609 u8 sw_if_index_set = 0;
10610 u8 enable_disable = 1;
10613 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10615 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10616 sw_if_index_set = 1;
10617 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10618 sw_if_index_set = 1;
10619 else if (unformat (i, "enable"))
10620 enable_disable = 1;
10621 else if (unformat (i, "disable"))
10622 enable_disable = 0;
10627 if (sw_if_index_set == 0)
10629 errmsg ("missing interface name or sw_if_index");
10633 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10635 mp->sw_if_index = ntohl (sw_if_index);
10636 mp->enable_disable = enable_disable;
10644 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10646 unformat_input_t *i = vam->input;
10647 vl_api_l2tpv3_set_lookup_key_t *mp;
10651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10653 if (unformat (i, "lookup_v6_src"))
10654 key = L2T_LOOKUP_SRC_ADDRESS;
10655 else if (unformat (i, "lookup_v6_dst"))
10656 key = L2T_LOOKUP_DST_ADDRESS;
10657 else if (unformat (i, "lookup_session_id"))
10658 key = L2T_LOOKUP_SESSION_ID;
10663 if (key == (u8) ~ 0)
10665 errmsg ("l2tp session lookup key unset");
10669 M (L2TPV3_SET_LOOKUP_KEY, mp);
10678 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10679 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10681 vat_main_t *vam = &vat_main;
10683 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10684 format_ip6_address, mp->our_address,
10685 format_ip6_address, mp->client_address,
10686 clib_net_to_host_u32 (mp->sw_if_index));
10689 " local cookies %016llx %016llx remote cookie %016llx",
10690 clib_net_to_host_u64 (mp->local_cookie[0]),
10691 clib_net_to_host_u64 (mp->local_cookie[1]),
10692 clib_net_to_host_u64 (mp->remote_cookie));
10694 print (vam->ofp, " local session-id %d remote session-id %d",
10695 clib_net_to_host_u32 (mp->local_session_id),
10696 clib_net_to_host_u32 (mp->remote_session_id));
10698 print (vam->ofp, " l2 specific sublayer %s\n",
10699 mp->l2_sublayer_present ? "preset" : "absent");
10703 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10704 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10706 vat_main_t *vam = &vat_main;
10707 vat_json_node_t *node = NULL;
10708 struct in6_addr addr;
10710 if (VAT_JSON_ARRAY != vam->json_tree.type)
10712 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10713 vat_json_init_array (&vam->json_tree);
10715 node = vat_json_array_add (&vam->json_tree);
10717 vat_json_init_object (node);
10719 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10720 vat_json_object_add_ip6 (node, "our_address", addr);
10721 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10722 vat_json_object_add_ip6 (node, "client_address", addr);
10724 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10725 vat_json_init_array (lc);
10726 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10727 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10728 vat_json_object_add_uint (node, "remote_cookie",
10729 clib_net_to_host_u64 (mp->remote_cookie));
10731 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10732 vat_json_object_add_uint (node, "local_session_id",
10733 clib_net_to_host_u32 (mp->local_session_id));
10734 vat_json_object_add_uint (node, "remote_session_id",
10735 clib_net_to_host_u32 (mp->remote_session_id));
10736 vat_json_object_add_string_copy (node, "l2_sublayer",
10737 mp->l2_sublayer_present ? (u8 *) "present"
10738 : (u8 *) "absent");
10742 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10744 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10745 vl_api_control_ping_t *mp_ping;
10748 /* Get list of l2tpv3-tunnel interfaces */
10749 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10752 /* Use a control ping for synchronization */
10753 M (CONTROL_PING, mp_ping);
10761 static void vl_api_sw_interface_tap_details_t_handler
10762 (vl_api_sw_interface_tap_details_t * mp)
10764 vat_main_t *vam = &vat_main;
10766 print (vam->ofp, "%-16s %d",
10767 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10770 static void vl_api_sw_interface_tap_details_t_handler_json
10771 (vl_api_sw_interface_tap_details_t * mp)
10773 vat_main_t *vam = &vat_main;
10774 vat_json_node_t *node = NULL;
10776 if (VAT_JSON_ARRAY != vam->json_tree.type)
10778 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10779 vat_json_init_array (&vam->json_tree);
10781 node = vat_json_array_add (&vam->json_tree);
10783 vat_json_init_object (node);
10784 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10785 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10789 api_sw_interface_tap_dump (vat_main_t * vam)
10791 vl_api_sw_interface_tap_dump_t *mp;
10792 vl_api_control_ping_t *mp_ping;
10795 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10796 /* Get list of tap interfaces */
10797 M (SW_INTERFACE_TAP_DUMP, mp);
10800 /* Use a control ping for synchronization */
10801 M (CONTROL_PING, mp_ping);
10808 static uword unformat_vxlan_decap_next
10809 (unformat_input_t * input, va_list * args)
10811 u32 *result = va_arg (*args, u32 *);
10814 if (unformat (input, "l2"))
10815 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10816 else if (unformat (input, "%d", &tmp))
10824 api_vxlan_add_del_tunnel (vat_main_t * vam)
10826 unformat_input_t *line_input = vam->input;
10827 vl_api_vxlan_add_del_tunnel_t *mp;
10828 ip46_address_t src, dst;
10830 u8 ipv4_set = 0, ipv6_set = 0;
10834 u32 mcast_sw_if_index = ~0;
10835 u32 encap_vrf_id = 0;
10836 u32 decap_next_index = ~0;
10840 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10841 memset (&src, 0, sizeof src);
10842 memset (&dst, 0, sizeof dst);
10844 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10846 if (unformat (line_input, "del"))
10849 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10855 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10861 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10867 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10872 else if (unformat (line_input, "group %U %U",
10873 unformat_ip4_address, &dst.ip4,
10874 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10876 grp_set = dst_set = 1;
10879 else if (unformat (line_input, "group %U",
10880 unformat_ip4_address, &dst.ip4))
10882 grp_set = dst_set = 1;
10885 else if (unformat (line_input, "group %U %U",
10886 unformat_ip6_address, &dst.ip6,
10887 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10889 grp_set = dst_set = 1;
10892 else if (unformat (line_input, "group %U",
10893 unformat_ip6_address, &dst.ip6))
10895 grp_set = dst_set = 1;
10899 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10901 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10903 else if (unformat (line_input, "decap-next %U",
10904 unformat_vxlan_decap_next, &decap_next_index))
10906 else if (unformat (line_input, "vni %d", &vni))
10910 errmsg ("parse error '%U'", format_unformat_error, line_input);
10917 errmsg ("tunnel src address not specified");
10922 errmsg ("tunnel dst address not specified");
10926 if (grp_set && !ip46_address_is_multicast (&dst))
10928 errmsg ("tunnel group address not multicast");
10931 if (grp_set && mcast_sw_if_index == ~0)
10933 errmsg ("tunnel nonexistent multicast device");
10936 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10938 errmsg ("tunnel dst address must be unicast");
10943 if (ipv4_set && ipv6_set)
10945 errmsg ("both IPv4 and IPv6 addresses specified");
10949 if ((vni == 0) || (vni >> 24))
10951 errmsg ("vni not specified or out of range");
10955 M (VXLAN_ADD_DEL_TUNNEL, mp);
10959 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10960 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10964 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10965 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10967 mp->encap_vrf_id = ntohl (encap_vrf_id);
10968 mp->decap_next_index = ntohl (decap_next_index);
10969 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10970 mp->vni = ntohl (vni);
10971 mp->is_add = is_add;
10972 mp->is_ipv6 = ipv6_set;
10979 static void vl_api_vxlan_tunnel_details_t_handler
10980 (vl_api_vxlan_tunnel_details_t * mp)
10982 vat_main_t *vam = &vat_main;
10983 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
10984 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
10986 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10987 ntohl (mp->sw_if_index),
10988 format_ip46_address, &src, IP46_TYPE_ANY,
10989 format_ip46_address, &dst, IP46_TYPE_ANY,
10990 ntohl (mp->encap_vrf_id),
10991 ntohl (mp->decap_next_index), ntohl (mp->vni),
10992 ntohl (mp->mcast_sw_if_index));
10995 static void vl_api_vxlan_tunnel_details_t_handler_json
10996 (vl_api_vxlan_tunnel_details_t * mp)
10998 vat_main_t *vam = &vat_main;
10999 vat_json_node_t *node = NULL;
11001 if (VAT_JSON_ARRAY != vam->json_tree.type)
11003 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11004 vat_json_init_array (&vam->json_tree);
11006 node = vat_json_array_add (&vam->json_tree);
11008 vat_json_init_object (node);
11009 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11012 struct in6_addr ip6;
11014 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11015 vat_json_object_add_ip6 (node, "src_address", ip6);
11016 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11017 vat_json_object_add_ip6 (node, "dst_address", ip6);
11021 struct in_addr ip4;
11023 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11024 vat_json_object_add_ip4 (node, "src_address", ip4);
11025 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11026 vat_json_object_add_ip4 (node, "dst_address", ip4);
11028 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11029 vat_json_object_add_uint (node, "decap_next_index",
11030 ntohl (mp->decap_next_index));
11031 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11032 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11033 vat_json_object_add_uint (node, "mcast_sw_if_index",
11034 ntohl (mp->mcast_sw_if_index));
11038 api_vxlan_tunnel_dump (vat_main_t * vam)
11040 unformat_input_t *i = vam->input;
11041 vl_api_vxlan_tunnel_dump_t *mp;
11042 vl_api_control_ping_t *mp_ping;
11044 u8 sw_if_index_set = 0;
11047 /* Parse args required to build the message */
11048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11050 if (unformat (i, "sw_if_index %d", &sw_if_index))
11051 sw_if_index_set = 1;
11056 if (sw_if_index_set == 0)
11061 if (!vam->json_output)
11063 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
11064 "sw_if_index", "src_address", "dst_address",
11065 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11068 /* Get list of vxlan-tunnel interfaces */
11069 M (VXLAN_TUNNEL_DUMP, mp);
11071 mp->sw_if_index = htonl (sw_if_index);
11075 /* Use a control ping for synchronization */
11076 M (CONTROL_PING, mp_ping);
11084 api_gre_add_del_tunnel (vat_main_t * vam)
11086 unformat_input_t *line_input = vam->input;
11087 vl_api_gre_add_del_tunnel_t *mp;
11088 ip4_address_t src4, dst4;
11089 ip6_address_t src6, dst6;
11096 u32 outer_fib_id = 0;
11099 memset (&src4, 0, sizeof src4);
11100 memset (&dst4, 0, sizeof dst4);
11101 memset (&src6, 0, sizeof src6);
11102 memset (&dst6, 0, sizeof dst6);
11104 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11106 if (unformat (line_input, "del"))
11108 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
11113 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
11118 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
11123 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
11128 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
11130 else if (unformat (line_input, "teb"))
11134 errmsg ("parse error '%U'", format_unformat_error, line_input);
11141 errmsg ("tunnel src address not specified");
11146 errmsg ("tunnel dst address not specified");
11149 if (ipv4_set && ipv6_set)
11151 errmsg ("both IPv4 and IPv6 addresses specified");
11156 M (GRE_ADD_DEL_TUNNEL, mp);
11160 clib_memcpy (&mp->src_address, &src4, 4);
11161 clib_memcpy (&mp->dst_address, &dst4, 4);
11165 clib_memcpy (&mp->src_address, &src6, 16);
11166 clib_memcpy (&mp->dst_address, &dst6, 16);
11168 mp->outer_fib_id = ntohl (outer_fib_id);
11169 mp->is_add = is_add;
11171 mp->is_ipv6 = ipv6_set;
11178 static void vl_api_gre_tunnel_details_t_handler
11179 (vl_api_gre_tunnel_details_t * mp)
11181 vat_main_t *vam = &vat_main;
11182 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
11183 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
11185 print (vam->ofp, "%11d%24U%24U%6d%14d",
11186 ntohl (mp->sw_if_index),
11187 format_ip46_address, &src, IP46_TYPE_ANY,
11188 format_ip46_address, &dst, IP46_TYPE_ANY,
11189 mp->teb, ntohl (mp->outer_fib_id));
11192 static void vl_api_gre_tunnel_details_t_handler_json
11193 (vl_api_gre_tunnel_details_t * mp)
11195 vat_main_t *vam = &vat_main;
11196 vat_json_node_t *node = NULL;
11197 struct in_addr ip4;
11198 struct in6_addr ip6;
11200 if (VAT_JSON_ARRAY != vam->json_tree.type)
11202 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11203 vat_json_init_array (&vam->json_tree);
11205 node = vat_json_array_add (&vam->json_tree);
11207 vat_json_init_object (node);
11208 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11211 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11212 vat_json_object_add_ip4 (node, "src_address", ip4);
11213 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11214 vat_json_object_add_ip4 (node, "dst_address", ip4);
11218 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
11219 vat_json_object_add_ip6 (node, "src_address", ip6);
11220 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
11221 vat_json_object_add_ip6 (node, "dst_address", ip6);
11223 vat_json_object_add_uint (node, "teb", mp->teb);
11224 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11225 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
11229 api_gre_tunnel_dump (vat_main_t * vam)
11231 unformat_input_t *i = vam->input;
11232 vl_api_gre_tunnel_dump_t *mp;
11233 vl_api_control_ping_t *mp_ping;
11235 u8 sw_if_index_set = 0;
11238 /* Parse args required to build the message */
11239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11241 if (unformat (i, "sw_if_index %d", &sw_if_index))
11242 sw_if_index_set = 1;
11247 if (sw_if_index_set == 0)
11252 if (!vam->json_output)
11254 print (vam->ofp, "%11s%24s%24s%6s%14s",
11255 "sw_if_index", "src_address", "dst_address", "teb",
11259 /* Get list of gre-tunnel interfaces */
11260 M (GRE_TUNNEL_DUMP, mp);
11262 mp->sw_if_index = htonl (sw_if_index);
11266 /* Use a control ping for synchronization */
11267 M (CONTROL_PING, mp_ping);
11275 api_l2_fib_clear_table (vat_main_t * vam)
11277 // unformat_input_t * i = vam->input;
11278 vl_api_l2_fib_clear_table_t *mp;
11281 M (L2_FIB_CLEAR_TABLE, mp);
11289 api_l2_interface_efp_filter (vat_main_t * vam)
11291 unformat_input_t *i = vam->input;
11292 vl_api_l2_interface_efp_filter_t *mp;
11295 u8 sw_if_index_set = 0;
11298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11300 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11301 sw_if_index_set = 1;
11302 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11303 sw_if_index_set = 1;
11304 else if (unformat (i, "enable"))
11306 else if (unformat (i, "disable"))
11310 clib_warning ("parse error '%U'", format_unformat_error, i);
11315 if (sw_if_index_set == 0)
11317 errmsg ("missing sw_if_index");
11321 M (L2_INTERFACE_EFP_FILTER, mp);
11323 mp->sw_if_index = ntohl (sw_if_index);
11324 mp->enable_disable = enable;
11331 #define foreach_vtr_op \
11332 _("disable", L2_VTR_DISABLED) \
11333 _("push-1", L2_VTR_PUSH_1) \
11334 _("push-2", L2_VTR_PUSH_2) \
11335 _("pop-1", L2_VTR_POP_1) \
11336 _("pop-2", L2_VTR_POP_2) \
11337 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11338 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11339 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11340 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11343 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11345 unformat_input_t *i = vam->input;
11346 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11348 u8 sw_if_index_set = 0;
11351 u32 push_dot1q = 1;
11356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11358 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11359 sw_if_index_set = 1;
11360 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11361 sw_if_index_set = 1;
11362 else if (unformat (i, "vtr_op %d", &vtr_op))
11364 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11367 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11369 else if (unformat (i, "tag1 %d", &tag1))
11371 else if (unformat (i, "tag2 %d", &tag2))
11375 clib_warning ("parse error '%U'", format_unformat_error, i);
11380 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11382 errmsg ("missing vtr operation or sw_if_index");
11386 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11387 mp->sw_if_index = ntohl (sw_if_index);
11388 mp->vtr_op = ntohl (vtr_op);
11389 mp->push_dot1q = ntohl (push_dot1q);
11390 mp->tag1 = ntohl (tag1);
11391 mp->tag2 = ntohl (tag2);
11399 api_create_vhost_user_if (vat_main_t * vam)
11401 unformat_input_t *i = vam->input;
11402 vl_api_create_vhost_user_if_t *mp;
11405 u8 file_name_set = 0;
11406 u32 custom_dev_instance = ~0;
11408 u8 use_custom_mac = 0;
11411 u8 operation_mode = VHOST_USER_POLLING_MODE;
11413 /* Shut up coverity */
11414 memset (hwaddr, 0, sizeof (hwaddr));
11416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11418 if (unformat (i, "socket %s", &file_name))
11422 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11424 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11425 use_custom_mac = 1;
11426 else if (unformat (i, "server"))
11428 else if (unformat (i, "tag %s", &tag))
11430 else if (unformat (i, "mode %U",
11431 api_unformat_vhost_user_operation_mode,
11438 if (file_name_set == 0)
11440 errmsg ("missing socket file name");
11444 if (vec_len (file_name) > 255)
11446 errmsg ("socket file name too long");
11449 vec_add1 (file_name, 0);
11451 M (CREATE_VHOST_USER_IF, mp);
11453 mp->operation_mode = operation_mode;
11454 mp->is_server = is_server;
11455 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11456 vec_free (file_name);
11457 if (custom_dev_instance != ~0)
11460 mp->custom_dev_instance = ntohl (custom_dev_instance);
11462 mp->use_custom_mac = use_custom_mac;
11463 clib_memcpy (mp->mac_address, hwaddr, 6);
11465 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11474 api_modify_vhost_user_if (vat_main_t * vam)
11476 unformat_input_t *i = vam->input;
11477 vl_api_modify_vhost_user_if_t *mp;
11480 u8 file_name_set = 0;
11481 u32 custom_dev_instance = ~0;
11482 u8 sw_if_index_set = 0;
11483 u32 sw_if_index = (u32) ~ 0;
11485 u8 operation_mode = VHOST_USER_POLLING_MODE;
11487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11489 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11490 sw_if_index_set = 1;
11491 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11492 sw_if_index_set = 1;
11493 else if (unformat (i, "socket %s", &file_name))
11497 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11499 else if (unformat (i, "server"))
11501 else if (unformat (i, "mode %U",
11502 api_unformat_vhost_user_operation_mode,
11509 if (sw_if_index_set == 0)
11511 errmsg ("missing sw_if_index or interface name");
11515 if (file_name_set == 0)
11517 errmsg ("missing socket file name");
11521 if (vec_len (file_name) > 255)
11523 errmsg ("socket file name too long");
11526 vec_add1 (file_name, 0);
11528 M (MODIFY_VHOST_USER_IF, mp);
11530 mp->operation_mode = operation_mode;
11531 mp->sw_if_index = ntohl (sw_if_index);
11532 mp->is_server = is_server;
11533 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11534 vec_free (file_name);
11535 if (custom_dev_instance != ~0)
11538 mp->custom_dev_instance = ntohl (custom_dev_instance);
11547 api_delete_vhost_user_if (vat_main_t * vam)
11549 unformat_input_t *i = vam->input;
11550 vl_api_delete_vhost_user_if_t *mp;
11551 u32 sw_if_index = ~0;
11552 u8 sw_if_index_set = 0;
11555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11557 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11558 sw_if_index_set = 1;
11559 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11560 sw_if_index_set = 1;
11565 if (sw_if_index_set == 0)
11567 errmsg ("missing sw_if_index or interface name");
11572 M (DELETE_VHOST_USER_IF, mp);
11574 mp->sw_if_index = ntohl (sw_if_index);
11581 static void vl_api_sw_interface_vhost_user_details_t_handler
11582 (vl_api_sw_interface_vhost_user_details_t * mp)
11584 vat_main_t *vam = &vat_main;
11586 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %U %s",
11587 (char *) mp->interface_name,
11588 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11589 clib_net_to_host_u64 (mp->features), mp->is_server,
11590 ntohl (mp->num_regions), api_format_vhost_user_operation_mode,
11591 mp->operation_mode, (char *) mp->sock_filename);
11592 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11595 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11596 (vl_api_sw_interface_vhost_user_details_t * mp)
11598 vat_main_t *vam = &vat_main;
11599 vat_json_node_t *node = NULL;
11601 if (VAT_JSON_ARRAY != vam->json_tree.type)
11603 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11604 vat_json_init_array (&vam->json_tree);
11606 node = vat_json_array_add (&vam->json_tree);
11608 vat_json_init_object (node);
11609 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11610 vat_json_object_add_string_copy (node, "interface_name",
11611 mp->interface_name);
11612 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11613 ntohl (mp->virtio_net_hdr_sz));
11614 vat_json_object_add_uint (node, "features",
11615 clib_net_to_host_u64 (mp->features));
11616 vat_json_object_add_uint (node, "is_server", mp->is_server);
11617 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11618 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11619 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11620 vat_json_object_add_uint (node, "mode", mp->operation_mode);
11624 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11626 vl_api_sw_interface_vhost_user_dump_t *mp;
11627 vl_api_control_ping_t *mp_ping;
11630 "Interface name idx hdr_sz features server regions mode"
11633 /* Get list of vhost-user interfaces */
11634 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11637 /* Use a control ping for synchronization */
11638 M (CONTROL_PING, mp_ping);
11646 api_show_version (vat_main_t * vam)
11648 vl_api_show_version_t *mp;
11651 M (SHOW_VERSION, mp);
11660 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11662 unformat_input_t *line_input = vam->input;
11663 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11664 ip4_address_t local4, remote4;
11665 ip6_address_t local6, remote6;
11667 u8 ipv4_set = 0, ipv6_set = 0;
11670 u32 encap_vrf_id = 0;
11671 u32 decap_vrf_id = 0;
11677 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11679 if (unformat (line_input, "del"))
11681 else if (unformat (line_input, "local %U",
11682 unformat_ip4_address, &local4))
11687 else if (unformat (line_input, "remote %U",
11688 unformat_ip4_address, &remote4))
11693 else if (unformat (line_input, "local %U",
11694 unformat_ip6_address, &local6))
11699 else if (unformat (line_input, "remote %U",
11700 unformat_ip6_address, &remote6))
11705 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11707 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11709 else if (unformat (line_input, "vni %d", &vni))
11711 else if (unformat (line_input, "next-ip4"))
11713 else if (unformat (line_input, "next-ip6"))
11715 else if (unformat (line_input, "next-ethernet"))
11717 else if (unformat (line_input, "next-nsh"))
11721 errmsg ("parse error '%U'", format_unformat_error, line_input);
11726 if (local_set == 0)
11728 errmsg ("tunnel local address not specified");
11731 if (remote_set == 0)
11733 errmsg ("tunnel remote address not specified");
11736 if (ipv4_set && ipv6_set)
11738 errmsg ("both IPv4 and IPv6 addresses specified");
11744 errmsg ("vni not specified");
11748 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11753 clib_memcpy (&mp->local, &local6, sizeof (local6));
11754 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11758 clib_memcpy (&mp->local, &local4, sizeof (local4));
11759 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11762 mp->encap_vrf_id = ntohl (encap_vrf_id);
11763 mp->decap_vrf_id = ntohl (decap_vrf_id);
11764 mp->protocol = protocol;
11765 mp->vni = ntohl (vni);
11766 mp->is_add = is_add;
11767 mp->is_ipv6 = ipv6_set;
11774 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11775 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11777 vat_main_t *vam = &vat_main;
11779 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11780 ntohl (mp->sw_if_index),
11781 format_ip46_address, &(mp->local[0]),
11782 format_ip46_address, &(mp->remote[0]),
11784 ntohl (mp->protocol),
11785 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11788 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11789 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11791 vat_main_t *vam = &vat_main;
11792 vat_json_node_t *node = NULL;
11793 struct in_addr ip4;
11794 struct in6_addr ip6;
11796 if (VAT_JSON_ARRAY != vam->json_tree.type)
11798 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11799 vat_json_init_array (&vam->json_tree);
11801 node = vat_json_array_add (&vam->json_tree);
11803 vat_json_init_object (node);
11804 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11807 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11808 vat_json_object_add_ip6 (node, "local", ip6);
11809 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11810 vat_json_object_add_ip6 (node, "remote", ip6);
11814 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11815 vat_json_object_add_ip4 (node, "local", ip4);
11816 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11817 vat_json_object_add_ip4 (node, "remote", ip4);
11819 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11820 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11821 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11822 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11823 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11827 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11829 unformat_input_t *i = vam->input;
11830 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11831 vl_api_control_ping_t *mp_ping;
11833 u8 sw_if_index_set = 0;
11836 /* Parse args required to build the message */
11837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11839 if (unformat (i, "sw_if_index %d", &sw_if_index))
11840 sw_if_index_set = 1;
11845 if (sw_if_index_set == 0)
11850 if (!vam->json_output)
11852 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11853 "sw_if_index", "local", "remote", "vni",
11854 "protocol", "encap_vrf_id", "decap_vrf_id");
11857 /* Get list of vxlan-tunnel interfaces */
11858 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11860 mp->sw_if_index = htonl (sw_if_index);
11864 /* Use a control ping for synchronization */
11865 M (CONTROL_PING, mp_ping);
11873 format_l2_fib_mac_address (u8 * s, va_list * args)
11875 u8 *a = va_arg (*args, u8 *);
11877 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11878 a[2], a[3], a[4], a[5], a[6], a[7]);
11881 static void vl_api_l2_fib_table_entry_t_handler
11882 (vl_api_l2_fib_table_entry_t * mp)
11884 vat_main_t *vam = &vat_main;
11886 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11888 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11889 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11893 static void vl_api_l2_fib_table_entry_t_handler_json
11894 (vl_api_l2_fib_table_entry_t * mp)
11896 vat_main_t *vam = &vat_main;
11897 vat_json_node_t *node = NULL;
11899 if (VAT_JSON_ARRAY != vam->json_tree.type)
11901 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11902 vat_json_init_array (&vam->json_tree);
11904 node = vat_json_array_add (&vam->json_tree);
11906 vat_json_init_object (node);
11907 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11908 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11909 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11910 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11911 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11912 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11916 api_l2_fib_table_dump (vat_main_t * vam)
11918 unformat_input_t *i = vam->input;
11919 vl_api_l2_fib_table_dump_t *mp;
11920 vl_api_control_ping_t *mp_ping;
11925 /* Parse args required to build the message */
11926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11928 if (unformat (i, "bd_id %d", &bd_id))
11934 if (bd_id_set == 0)
11936 errmsg ("missing bridge domain");
11940 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11942 /* Get list of l2 fib entries */
11943 M (L2_FIB_TABLE_DUMP, mp);
11945 mp->bd_id = ntohl (bd_id);
11948 /* Use a control ping for synchronization */
11949 M (CONTROL_PING, mp_ping);
11958 api_interface_name_renumber (vat_main_t * vam)
11960 unformat_input_t *line_input = vam->input;
11961 vl_api_interface_name_renumber_t *mp;
11962 u32 sw_if_index = ~0;
11963 u32 new_show_dev_instance = ~0;
11966 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11968 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11971 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11973 else if (unformat (line_input, "new_show_dev_instance %d",
11974 &new_show_dev_instance))
11980 if (sw_if_index == ~0)
11982 errmsg ("missing interface name or sw_if_index");
11986 if (new_show_dev_instance == ~0)
11988 errmsg ("missing new_show_dev_instance");
11992 M (INTERFACE_NAME_RENUMBER, mp);
11994 mp->sw_if_index = ntohl (sw_if_index);
11995 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
12003 api_want_ip4_arp_events (vat_main_t * vam)
12005 unformat_input_t *line_input = vam->input;
12006 vl_api_want_ip4_arp_events_t *mp;
12007 ip4_address_t address;
12008 int address_set = 0;
12009 u32 enable_disable = 1;
12012 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12014 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
12016 else if (unformat (line_input, "del"))
12017 enable_disable = 0;
12022 if (address_set == 0)
12024 errmsg ("missing addresses");
12028 M (WANT_IP4_ARP_EVENTS, mp);
12029 mp->enable_disable = enable_disable;
12030 mp->pid = htonl (getpid ());
12031 mp->address = address.as_u32;
12039 api_want_ip6_nd_events (vat_main_t * vam)
12041 unformat_input_t *line_input = vam->input;
12042 vl_api_want_ip6_nd_events_t *mp;
12043 ip6_address_t address;
12044 int address_set = 0;
12045 u32 enable_disable = 1;
12048 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12050 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
12052 else if (unformat (line_input, "del"))
12053 enable_disable = 0;
12058 if (address_set == 0)
12060 errmsg ("missing addresses");
12064 M (WANT_IP6_ND_EVENTS, mp);
12065 mp->enable_disable = enable_disable;
12066 mp->pid = htonl (getpid ());
12067 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
12075 api_input_acl_set_interface (vat_main_t * vam)
12077 unformat_input_t *i = vam->input;
12078 vl_api_input_acl_set_interface_t *mp;
12080 int sw_if_index_set;
12081 u32 ip4_table_index = ~0;
12082 u32 ip6_table_index = ~0;
12083 u32 l2_table_index = ~0;
12087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12089 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12090 sw_if_index_set = 1;
12091 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12092 sw_if_index_set = 1;
12093 else if (unformat (i, "del"))
12095 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12097 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12099 else if (unformat (i, "l2-table %d", &l2_table_index))
12103 clib_warning ("parse error '%U'", format_unformat_error, i);
12108 if (sw_if_index_set == 0)
12110 errmsg ("missing interface name or sw_if_index");
12114 M (INPUT_ACL_SET_INTERFACE, mp);
12116 mp->sw_if_index = ntohl (sw_if_index);
12117 mp->ip4_table_index = ntohl (ip4_table_index);
12118 mp->ip6_table_index = ntohl (ip6_table_index);
12119 mp->l2_table_index = ntohl (l2_table_index);
12120 mp->is_add = is_add;
12128 api_ip_address_dump (vat_main_t * vam)
12130 unformat_input_t *i = vam->input;
12131 vl_api_ip_address_dump_t *mp;
12132 vl_api_control_ping_t *mp_ping;
12133 u32 sw_if_index = ~0;
12134 u8 sw_if_index_set = 0;
12139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12141 if (unformat (i, "sw_if_index %d", &sw_if_index))
12142 sw_if_index_set = 1;
12144 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12145 sw_if_index_set = 1;
12146 else if (unformat (i, "ipv4"))
12148 else if (unformat (i, "ipv6"))
12154 if (ipv4_set && ipv6_set)
12156 errmsg ("ipv4 and ipv6 flags cannot be both set");
12160 if ((!ipv4_set) && (!ipv6_set))
12162 errmsg ("no ipv4 nor ipv6 flag set");
12166 if (sw_if_index_set == 0)
12168 errmsg ("missing interface name or sw_if_index");
12172 vam->current_sw_if_index = sw_if_index;
12173 vam->is_ipv6 = ipv6_set;
12175 M (IP_ADDRESS_DUMP, mp);
12176 mp->sw_if_index = ntohl (sw_if_index);
12177 mp->is_ipv6 = ipv6_set;
12180 /* Use a control ping for synchronization */
12181 M (CONTROL_PING, mp_ping);
12189 api_ip_dump (vat_main_t * vam)
12191 vl_api_ip_dump_t *mp;
12192 vl_api_control_ping_t *mp_ping;
12193 unformat_input_t *in = vam->input;
12200 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
12202 if (unformat (in, "ipv4"))
12204 else if (unformat (in, "ipv6"))
12210 if (ipv4_set && ipv6_set)
12212 errmsg ("ipv4 and ipv6 flags cannot be both set");
12216 if ((!ipv4_set) && (!ipv6_set))
12218 errmsg ("no ipv4 nor ipv6 flag set");
12222 is_ipv6 = ipv6_set;
12223 vam->is_ipv6 = is_ipv6;
12225 /* free old data */
12226 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12228 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12230 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12233 mp->is_ipv6 = ipv6_set;
12236 /* Use a control ping for synchronization */
12237 M (CONTROL_PING, mp_ping);
12245 api_ipsec_spd_add_del (vat_main_t * vam)
12247 unformat_input_t *i = vam->input;
12248 vl_api_ipsec_spd_add_del_t *mp;
12253 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12255 if (unformat (i, "spd_id %d", &spd_id))
12257 else if (unformat (i, "del"))
12261 clib_warning ("parse error '%U'", format_unformat_error, i);
12267 errmsg ("spd_id must be set");
12271 M (IPSEC_SPD_ADD_DEL, mp);
12273 mp->spd_id = ntohl (spd_id);
12274 mp->is_add = is_add;
12282 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12284 unformat_input_t *i = vam->input;
12285 vl_api_ipsec_interface_add_del_spd_t *mp;
12287 u8 sw_if_index_set = 0;
12288 u32 spd_id = (u32) ~ 0;
12292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12294 if (unformat (i, "del"))
12296 else if (unformat (i, "spd_id %d", &spd_id))
12299 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12300 sw_if_index_set = 1;
12301 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12302 sw_if_index_set = 1;
12305 clib_warning ("parse error '%U'", format_unformat_error, i);
12311 if (spd_id == (u32) ~ 0)
12313 errmsg ("spd_id must be set");
12317 if (sw_if_index_set == 0)
12319 errmsg ("missing interface name or sw_if_index");
12323 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12325 mp->spd_id = ntohl (spd_id);
12326 mp->sw_if_index = ntohl (sw_if_index);
12327 mp->is_add = is_add;
12335 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12337 unformat_input_t *i = vam->input;
12338 vl_api_ipsec_spd_add_del_entry_t *mp;
12339 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12340 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12342 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12343 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12344 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12345 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12348 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12349 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12350 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12351 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12352 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12353 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12357 if (unformat (i, "del"))
12359 if (unformat (i, "outbound"))
12361 if (unformat (i, "inbound"))
12363 else if (unformat (i, "spd_id %d", &spd_id))
12365 else if (unformat (i, "sa_id %d", &sa_id))
12367 else if (unformat (i, "priority %d", &priority))
12369 else if (unformat (i, "protocol %d", &protocol))
12371 else if (unformat (i, "lport_start %d", &lport_start))
12373 else if (unformat (i, "lport_stop %d", &lport_stop))
12375 else if (unformat (i, "rport_start %d", &rport_start))
12377 else if (unformat (i, "rport_stop %d", &rport_stop))
12381 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12387 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12394 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12400 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12407 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12413 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12420 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12426 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12432 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12434 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12436 clib_warning ("unsupported action: 'resolve'");
12442 clib_warning ("parse error '%U'", format_unformat_error, i);
12448 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12450 mp->spd_id = ntohl (spd_id);
12451 mp->priority = ntohl (priority);
12452 mp->is_outbound = is_outbound;
12454 mp->is_ipv6 = is_ipv6;
12455 if (is_ipv6 || is_ip_any)
12457 clib_memcpy (mp->remote_address_start, &raddr6_start,
12458 sizeof (ip6_address_t));
12459 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12460 sizeof (ip6_address_t));
12461 clib_memcpy (mp->local_address_start, &laddr6_start,
12462 sizeof (ip6_address_t));
12463 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12464 sizeof (ip6_address_t));
12468 clib_memcpy (mp->remote_address_start, &raddr4_start,
12469 sizeof (ip4_address_t));
12470 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12471 sizeof (ip4_address_t));
12472 clib_memcpy (mp->local_address_start, &laddr4_start,
12473 sizeof (ip4_address_t));
12474 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12475 sizeof (ip4_address_t));
12477 mp->protocol = (u8) protocol;
12478 mp->local_port_start = ntohs ((u16) lport_start);
12479 mp->local_port_stop = ntohs ((u16) lport_stop);
12480 mp->remote_port_start = ntohs ((u16) rport_start);
12481 mp->remote_port_stop = ntohs ((u16) rport_stop);
12482 mp->policy = (u8) policy;
12483 mp->sa_id = ntohl (sa_id);
12484 mp->is_add = is_add;
12485 mp->is_ip_any = is_ip_any;
12492 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12494 unformat_input_t *i = vam->input;
12495 vl_api_ipsec_sad_add_del_entry_t *mp;
12496 u32 sad_id = 0, spi = 0;
12497 u8 *ck = 0, *ik = 0;
12500 u8 protocol = IPSEC_PROTOCOL_AH;
12501 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12502 u32 crypto_alg = 0, integ_alg = 0;
12503 ip4_address_t tun_src4;
12504 ip4_address_t tun_dst4;
12505 ip6_address_t tun_src6;
12506 ip6_address_t tun_dst6;
12509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12511 if (unformat (i, "del"))
12513 else if (unformat (i, "sad_id %d", &sad_id))
12515 else if (unformat (i, "spi %d", &spi))
12517 else if (unformat (i, "esp"))
12518 protocol = IPSEC_PROTOCOL_ESP;
12519 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12522 is_tunnel_ipv6 = 0;
12524 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12527 is_tunnel_ipv6 = 0;
12529 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12532 is_tunnel_ipv6 = 1;
12534 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12537 is_tunnel_ipv6 = 1;
12541 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12543 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12544 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12546 clib_warning ("unsupported crypto-alg: '%U'",
12547 format_ipsec_crypto_alg, crypto_alg);
12551 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12555 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12557 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12558 integ_alg >= IPSEC_INTEG_N_ALG)
12560 clib_warning ("unsupported integ-alg: '%U'",
12561 format_ipsec_integ_alg, integ_alg);
12565 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12569 clib_warning ("parse error '%U'", format_unformat_error, i);
12575 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12577 mp->sad_id = ntohl (sad_id);
12578 mp->is_add = is_add;
12579 mp->protocol = protocol;
12580 mp->spi = ntohl (spi);
12581 mp->is_tunnel = is_tunnel;
12582 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12583 mp->crypto_algorithm = crypto_alg;
12584 mp->integrity_algorithm = integ_alg;
12585 mp->crypto_key_length = vec_len (ck);
12586 mp->integrity_key_length = vec_len (ik);
12588 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12589 mp->crypto_key_length = sizeof (mp->crypto_key);
12591 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12592 mp->integrity_key_length = sizeof (mp->integrity_key);
12595 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12597 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12601 if (is_tunnel_ipv6)
12603 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12604 sizeof (ip6_address_t));
12605 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12606 sizeof (ip6_address_t));
12610 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12611 sizeof (ip4_address_t));
12612 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12613 sizeof (ip4_address_t));
12623 api_ipsec_sa_set_key (vat_main_t * vam)
12625 unformat_input_t *i = vam->input;
12626 vl_api_ipsec_sa_set_key_t *mp;
12628 u8 *ck = 0, *ik = 0;
12631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12633 if (unformat (i, "sa_id %d", &sa_id))
12635 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12637 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12641 clib_warning ("parse error '%U'", format_unformat_error, i);
12646 M (IPSEC_SA_SET_KEY, mp);
12648 mp->sa_id = ntohl (sa_id);
12649 mp->crypto_key_length = vec_len (ck);
12650 mp->integrity_key_length = vec_len (ik);
12652 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12653 mp->crypto_key_length = sizeof (mp->crypto_key);
12655 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12656 mp->integrity_key_length = sizeof (mp->integrity_key);
12659 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12661 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12669 api_ikev2_profile_add_del (vat_main_t * vam)
12671 unformat_input_t *i = vam->input;
12672 vl_api_ikev2_profile_add_del_t *mp;
12677 const char *valid_chars = "a-zA-Z0-9_";
12679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12681 if (unformat (i, "del"))
12683 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12684 vec_add1 (name, 0);
12687 errmsg ("parse error '%U'", format_unformat_error, i);
12692 if (!vec_len (name))
12694 errmsg ("profile name must be specified");
12698 if (vec_len (name) > 64)
12700 errmsg ("profile name too long");
12704 M (IKEV2_PROFILE_ADD_DEL, mp);
12706 clib_memcpy (mp->name, name, vec_len (name));
12707 mp->is_add = is_add;
12716 api_ikev2_profile_set_auth (vat_main_t * vam)
12718 unformat_input_t *i = vam->input;
12719 vl_api_ikev2_profile_set_auth_t *mp;
12722 u32 auth_method = 0;
12726 const char *valid_chars = "a-zA-Z0-9_";
12728 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12730 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12731 vec_add1 (name, 0);
12732 else if (unformat (i, "auth_method %U",
12733 unformat_ikev2_auth_method, &auth_method))
12735 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12737 else if (unformat (i, "auth_data %v", &data))
12741 errmsg ("parse error '%U'", format_unformat_error, i);
12746 if (!vec_len (name))
12748 errmsg ("profile name must be specified");
12752 if (vec_len (name) > 64)
12754 errmsg ("profile name too long");
12758 if (!vec_len (data))
12760 errmsg ("auth_data must be specified");
12766 errmsg ("auth_method must be specified");
12770 M (IKEV2_PROFILE_SET_AUTH, mp);
12772 mp->is_hex = is_hex;
12773 mp->auth_method = (u8) auth_method;
12774 mp->data_len = vec_len (data);
12775 clib_memcpy (mp->name, name, vec_len (name));
12776 clib_memcpy (mp->data, data, vec_len (data));
12786 api_ikev2_profile_set_id (vat_main_t * vam)
12788 unformat_input_t *i = vam->input;
12789 vl_api_ikev2_profile_set_id_t *mp;
12797 const char *valid_chars = "a-zA-Z0-9_";
12799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12801 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12802 vec_add1 (name, 0);
12803 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12805 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12807 data = vec_new (u8, 4);
12808 clib_memcpy (data, ip4.as_u8, 4);
12810 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12812 else if (unformat (i, "id_data %v", &data))
12814 else if (unformat (i, "local"))
12816 else if (unformat (i, "remote"))
12820 errmsg ("parse error '%U'", format_unformat_error, i);
12825 if (!vec_len (name))
12827 errmsg ("profile name must be specified");
12831 if (vec_len (name) > 64)
12833 errmsg ("profile name too long");
12837 if (!vec_len (data))
12839 errmsg ("id_data must be specified");
12845 errmsg ("id_type must be specified");
12849 M (IKEV2_PROFILE_SET_ID, mp);
12851 mp->is_local = is_local;
12852 mp->id_type = (u8) id_type;
12853 mp->data_len = vec_len (data);
12854 clib_memcpy (mp->name, name, vec_len (name));
12855 clib_memcpy (mp->data, data, vec_len (data));
12865 api_ikev2_profile_set_ts (vat_main_t * vam)
12867 unformat_input_t *i = vam->input;
12868 vl_api_ikev2_profile_set_ts_t *mp;
12871 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12872 ip4_address_t start_addr, end_addr;
12874 const char *valid_chars = "a-zA-Z0-9_";
12877 start_addr.as_u32 = 0;
12878 end_addr.as_u32 = (u32) ~ 0;
12880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12882 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12883 vec_add1 (name, 0);
12884 else if (unformat (i, "protocol %d", &proto))
12886 else if (unformat (i, "start_port %d", &start_port))
12888 else if (unformat (i, "end_port %d", &end_port))
12891 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12893 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12895 else if (unformat (i, "local"))
12897 else if (unformat (i, "remote"))
12901 errmsg ("parse error '%U'", format_unformat_error, i);
12906 if (!vec_len (name))
12908 errmsg ("profile name must be specified");
12912 if (vec_len (name) > 64)
12914 errmsg ("profile name too long");
12918 M (IKEV2_PROFILE_SET_TS, mp);
12920 mp->is_local = is_local;
12921 mp->proto = (u8) proto;
12922 mp->start_port = (u16) start_port;
12923 mp->end_port = (u16) end_port;
12924 mp->start_addr = start_addr.as_u32;
12925 mp->end_addr = end_addr.as_u32;
12926 clib_memcpy (mp->name, name, vec_len (name));
12935 api_ikev2_set_local_key (vat_main_t * vam)
12937 unformat_input_t *i = vam->input;
12938 vl_api_ikev2_set_local_key_t *mp;
12942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12944 if (unformat (i, "file %v", &file))
12945 vec_add1 (file, 0);
12948 errmsg ("parse error '%U'", format_unformat_error, i);
12953 if (!vec_len (file))
12955 errmsg ("RSA key file must be specified");
12959 if (vec_len (file) > 256)
12961 errmsg ("file name too long");
12965 M (IKEV2_SET_LOCAL_KEY, mp);
12967 clib_memcpy (mp->key_file, file, vec_len (file));
12976 api_ikev2_set_responder (vat_main_t * vam)
12978 unformat_input_t *i = vam->input;
12979 vl_api_ikev2_set_responder_t *mp;
12982 u32 sw_if_index = ~0;
12983 ip4_address_t address;
12985 const char *valid_chars = "a-zA-Z0-9_";
12987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12990 (i, "%U interface %d address %U", unformat_token, valid_chars,
12991 &name, &sw_if_index, unformat_ip4_address, &address))
12992 vec_add1 (name, 0);
12995 errmsg ("parse error '%U'", format_unformat_error, i);
13000 if (!vec_len (name))
13002 errmsg ("profile name must be specified");
13006 if (vec_len (name) > 64)
13008 errmsg ("profile name too long");
13012 M (IKEV2_SET_RESPONDER, mp);
13014 clib_memcpy (mp->name, name, vec_len (name));
13017 mp->sw_if_index = sw_if_index;
13018 clib_memcpy (mp->address, &address, sizeof (address));
13026 api_ikev2_set_ike_transforms (vat_main_t * vam)
13028 unformat_input_t *i = vam->input;
13029 vl_api_ikev2_set_ike_transforms_t *mp;
13032 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13034 const char *valid_chars = "a-zA-Z0-9_";
13036 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13038 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13039 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13040 vec_add1 (name, 0);
13043 errmsg ("parse error '%U'", format_unformat_error, i);
13048 if (!vec_len (name))
13050 errmsg ("profile name must be specified");
13054 if (vec_len (name) > 64)
13056 errmsg ("profile name too long");
13060 M (IKEV2_SET_IKE_TRANSFORMS, mp);
13062 clib_memcpy (mp->name, name, vec_len (name));
13064 mp->crypto_alg = crypto_alg;
13065 mp->crypto_key_size = crypto_key_size;
13066 mp->integ_alg = integ_alg;
13067 mp->dh_group = dh_group;
13076 api_ikev2_set_esp_transforms (vat_main_t * vam)
13078 unformat_input_t *i = vam->input;
13079 vl_api_ikev2_set_esp_transforms_t *mp;
13082 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
13084 const char *valid_chars = "a-zA-Z0-9_";
13086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13088 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
13089 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
13090 vec_add1 (name, 0);
13093 errmsg ("parse error '%U'", format_unformat_error, i);
13098 if (!vec_len (name))
13100 errmsg ("profile name must be specified");
13104 if (vec_len (name) > 64)
13106 errmsg ("profile name too long");
13110 M (IKEV2_SET_ESP_TRANSFORMS, mp);
13112 clib_memcpy (mp->name, name, vec_len (name));
13114 mp->crypto_alg = crypto_alg;
13115 mp->crypto_key_size = crypto_key_size;
13116 mp->integ_alg = integ_alg;
13117 mp->dh_group = dh_group;
13125 api_ikev2_set_sa_lifetime (vat_main_t * vam)
13127 unformat_input_t *i = vam->input;
13128 vl_api_ikev2_set_sa_lifetime_t *mp;
13131 u64 lifetime, lifetime_maxdata;
13132 u32 lifetime_jitter, handover;
13134 const char *valid_chars = "a-zA-Z0-9_";
13136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13138 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
13139 &lifetime, &lifetime_jitter, &handover,
13140 &lifetime_maxdata))
13141 vec_add1 (name, 0);
13144 errmsg ("parse error '%U'", format_unformat_error, i);
13149 if (!vec_len (name))
13151 errmsg ("profile name must be specified");
13155 if (vec_len (name) > 64)
13157 errmsg ("profile name too long");
13161 M (IKEV2_SET_SA_LIFETIME, mp);
13163 clib_memcpy (mp->name, name, vec_len (name));
13165 mp->lifetime = lifetime;
13166 mp->lifetime_jitter = lifetime_jitter;
13167 mp->handover = handover;
13168 mp->lifetime_maxdata = lifetime_maxdata;
13176 api_ikev2_initiate_sa_init (vat_main_t * vam)
13178 unformat_input_t *i = vam->input;
13179 vl_api_ikev2_initiate_sa_init_t *mp;
13183 const char *valid_chars = "a-zA-Z0-9_";
13185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13187 if (unformat (i, "%U", unformat_token, valid_chars, &name))
13188 vec_add1 (name, 0);
13191 errmsg ("parse error '%U'", format_unformat_error, i);
13196 if (!vec_len (name))
13198 errmsg ("profile name must be specified");
13202 if (vec_len (name) > 64)
13204 errmsg ("profile name too long");
13208 M (IKEV2_INITIATE_SA_INIT, mp);
13210 clib_memcpy (mp->name, name, vec_len (name));
13219 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
13221 unformat_input_t *i = vam->input;
13222 vl_api_ikev2_initiate_del_ike_sa_t *mp;
13227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13229 if (unformat (i, "%lx", &ispi))
13233 errmsg ("parse error '%U'", format_unformat_error, i);
13238 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
13248 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
13250 unformat_input_t *i = vam->input;
13251 vl_api_ikev2_initiate_del_child_sa_t *mp;
13256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13258 if (unformat (i, "%x", &ispi))
13262 errmsg ("parse error '%U'", format_unformat_error, i);
13267 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
13277 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
13279 unformat_input_t *i = vam->input;
13280 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
13285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13287 if (unformat (i, "%x", &ispi))
13291 errmsg ("parse error '%U'", format_unformat_error, i);
13296 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
13309 api_map_add_domain (vat_main_t * vam)
13311 unformat_input_t *i = vam->input;
13312 vl_api_map_add_domain_t *mp;
13314 ip4_address_t ip4_prefix;
13315 ip6_address_t ip6_prefix;
13316 ip6_address_t ip6_src;
13317 u32 num_m_args = 0;
13318 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
13319 0, psid_length = 0;
13320 u8 is_translation = 0;
13322 u32 ip6_src_len = 128;
13325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13327 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
13328 &ip4_prefix, &ip4_prefix_len))
13330 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
13331 &ip6_prefix, &ip6_prefix_len))
13335 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
13338 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
13340 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
13342 else if (unformat (i, "psid-offset %d", &psid_offset))
13344 else if (unformat (i, "psid-len %d", &psid_length))
13346 else if (unformat (i, "mtu %d", &mtu))
13348 else if (unformat (i, "map-t"))
13349 is_translation = 1;
13352 clib_warning ("parse error '%U'", format_unformat_error, i);
13357 if (num_m_args < 3)
13359 errmsg ("mandatory argument(s) missing");
13363 /* Construct the API message */
13364 M (MAP_ADD_DOMAIN, mp);
13366 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
13367 mp->ip4_prefix_len = ip4_prefix_len;
13369 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
13370 mp->ip6_prefix_len = ip6_prefix_len;
13372 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
13373 mp->ip6_src_prefix_len = ip6_src_len;
13375 mp->ea_bits_len = ea_bits_len;
13376 mp->psid_offset = psid_offset;
13377 mp->psid_length = psid_length;
13378 mp->is_translation = is_translation;
13379 mp->mtu = htons (mtu);
13384 /* Wait for a reply, return good/bad news */
13390 api_map_del_domain (vat_main_t * vam)
13392 unformat_input_t *i = vam->input;
13393 vl_api_map_del_domain_t *mp;
13395 u32 num_m_args = 0;
13399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13401 if (unformat (i, "index %d", &index))
13405 clib_warning ("parse error '%U'", format_unformat_error, i);
13410 if (num_m_args != 1)
13412 errmsg ("mandatory argument(s) missing");
13416 /* Construct the API message */
13417 M (MAP_DEL_DOMAIN, mp);
13419 mp->index = ntohl (index);
13424 /* Wait for a reply, return good/bad news */
13430 api_map_add_del_rule (vat_main_t * vam)
13432 unformat_input_t *i = vam->input;
13433 vl_api_map_add_del_rule_t *mp;
13435 ip6_address_t ip6_dst;
13436 u32 num_m_args = 0, index, psid = 0;
13439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13441 if (unformat (i, "index %d", &index))
13443 else if (unformat (i, "psid %d", &psid))
13445 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
13447 else if (unformat (i, "del"))
13453 clib_warning ("parse error '%U'", format_unformat_error, i);
13458 /* Construct the API message */
13459 M (MAP_ADD_DEL_RULE, mp);
13461 mp->index = ntohl (index);
13462 mp->is_add = is_add;
13463 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
13464 mp->psid = ntohs (psid);
13469 /* Wait for a reply, return good/bad news */
13475 api_map_domain_dump (vat_main_t * vam)
13477 vl_api_map_domain_dump_t *mp;
13478 vl_api_control_ping_t *mp_ping;
13481 /* Construct the API message */
13482 M (MAP_DOMAIN_DUMP, mp);
13487 /* Use a control ping for synchronization */
13488 M (CONTROL_PING, mp_ping);
13496 api_map_rule_dump (vat_main_t * vam)
13498 unformat_input_t *i = vam->input;
13499 vl_api_map_rule_dump_t *mp;
13500 vl_api_control_ping_t *mp_ping;
13501 u32 domain_index = ~0;
13504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13506 if (unformat (i, "index %u", &domain_index))
13512 if (domain_index == ~0)
13514 clib_warning ("parse error: domain index expected");
13518 /* Construct the API message */
13519 M (MAP_RULE_DUMP, mp);
13521 mp->domain_index = htonl (domain_index);
13526 /* Use a control ping for synchronization */
13527 M (CONTROL_PING, mp_ping);
13534 static void vl_api_map_add_domain_reply_t_handler
13535 (vl_api_map_add_domain_reply_t * mp)
13537 vat_main_t *vam = &vat_main;
13538 i32 retval = ntohl (mp->retval);
13540 if (vam->async_mode)
13542 vam->async_errors += (retval < 0);
13546 vam->retval = retval;
13547 vam->result_ready = 1;
13551 static void vl_api_map_add_domain_reply_t_handler_json
13552 (vl_api_map_add_domain_reply_t * mp)
13554 vat_main_t *vam = &vat_main;
13555 vat_json_node_t node;
13557 vat_json_init_object (&node);
13558 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13559 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13561 vat_json_print (vam->ofp, &node);
13562 vat_json_free (&node);
13564 vam->retval = ntohl (mp->retval);
13565 vam->result_ready = 1;
13569 api_get_first_msg_id (vat_main_t * vam)
13571 vl_api_get_first_msg_id_t *mp;
13572 unformat_input_t *i = vam->input;
13577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13579 if (unformat (i, "client %s", &name))
13587 errmsg ("missing client name");
13590 vec_add1 (name, 0);
13592 if (vec_len (name) > 63)
13594 errmsg ("client name too long");
13598 M (GET_FIRST_MSG_ID, mp);
13599 clib_memcpy (mp->name, name, vec_len (name));
13606 api_cop_interface_enable_disable (vat_main_t * vam)
13608 unformat_input_t *line_input = vam->input;
13609 vl_api_cop_interface_enable_disable_t *mp;
13610 u32 sw_if_index = ~0;
13611 u8 enable_disable = 1;
13614 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13616 if (unformat (line_input, "disable"))
13617 enable_disable = 0;
13618 if (unformat (line_input, "enable"))
13619 enable_disable = 1;
13620 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13621 vam, &sw_if_index))
13623 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13629 if (sw_if_index == ~0)
13631 errmsg ("missing interface name or sw_if_index");
13635 /* Construct the API message */
13636 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13637 mp->sw_if_index = ntohl (sw_if_index);
13638 mp->enable_disable = enable_disable;
13642 /* Wait for the reply */
13648 api_cop_whitelist_enable_disable (vat_main_t * vam)
13650 unformat_input_t *line_input = vam->input;
13651 vl_api_cop_whitelist_enable_disable_t *mp;
13652 u32 sw_if_index = ~0;
13653 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13657 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13659 if (unformat (line_input, "ip4"))
13661 else if (unformat (line_input, "ip6"))
13663 else if (unformat (line_input, "default"))
13665 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13666 vam, &sw_if_index))
13668 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13670 else if (unformat (line_input, "fib-id %d", &fib_id))
13676 if (sw_if_index == ~0)
13678 errmsg ("missing interface name or sw_if_index");
13682 /* Construct the API message */
13683 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13684 mp->sw_if_index = ntohl (sw_if_index);
13685 mp->fib_id = ntohl (fib_id);
13688 mp->default_cop = default_cop;
13692 /* Wait for the reply */
13698 api_get_node_graph (vat_main_t * vam)
13700 vl_api_get_node_graph_t *mp;
13703 M (GET_NODE_GRAPH, mp);
13707 /* Wait for the reply */
13713 /** Used for parsing LISP eids */
13714 typedef CLIB_PACKED(struct{
13715 u8 addr[16]; /**< eid address */
13716 u32 len; /**< prefix length if IP */
13717 u8 type; /**< type of eid */
13722 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13724 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13726 memset (a, 0, sizeof (a[0]));
13728 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13730 a->type = 0; /* ipv4 type */
13732 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13734 a->type = 1; /* ipv6 type */
13736 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13738 a->type = 2; /* mac type */
13745 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13754 lisp_eid_size_vat (u8 type)
13769 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13771 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13775 api_one_add_del_locator_set (vat_main_t * vam)
13777 unformat_input_t *input = vam->input;
13778 vl_api_one_add_del_locator_set_t *mp;
13780 u8 *locator_set_name = NULL;
13781 u8 locator_set_name_set = 0;
13782 vl_api_local_locator_t locator, *locators = 0;
13783 u32 sw_if_index, priority, weight;
13787 /* Parse args required to build the message */
13788 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13790 if (unformat (input, "del"))
13794 else if (unformat (input, "locator-set %s", &locator_set_name))
13796 locator_set_name_set = 1;
13798 else if (unformat (input, "sw_if_index %u p %u w %u",
13799 &sw_if_index, &priority, &weight))
13801 locator.sw_if_index = htonl (sw_if_index);
13802 locator.priority = priority;
13803 locator.weight = weight;
13804 vec_add1 (locators, locator);
13808 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13809 &sw_if_index, &priority, &weight))
13811 locator.sw_if_index = htonl (sw_if_index);
13812 locator.priority = priority;
13813 locator.weight = weight;
13814 vec_add1 (locators, locator);
13820 if (locator_set_name_set == 0)
13822 errmsg ("missing locator-set name");
13823 vec_free (locators);
13827 if (vec_len (locator_set_name) > 64)
13829 errmsg ("locator-set name too long");
13830 vec_free (locator_set_name);
13831 vec_free (locators);
13834 vec_add1 (locator_set_name, 0);
13836 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13838 /* Construct the API message */
13839 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
13841 mp->is_add = is_add;
13842 clib_memcpy (mp->locator_set_name, locator_set_name,
13843 vec_len (locator_set_name));
13844 vec_free (locator_set_name);
13846 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13848 clib_memcpy (mp->locators, locators, data_len);
13849 vec_free (locators);
13854 /* Wait for a reply... */
13859 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
13862 api_one_add_del_locator (vat_main_t * vam)
13864 unformat_input_t *input = vam->input;
13865 vl_api_one_add_del_locator_t *mp;
13866 u32 tmp_if_index = ~0;
13867 u32 sw_if_index = ~0;
13868 u8 sw_if_index_set = 0;
13869 u8 sw_if_index_if_name_set = 0;
13871 u8 priority_set = 0;
13875 u8 *locator_set_name = NULL;
13876 u8 locator_set_name_set = 0;
13879 /* Parse args required to build the message */
13880 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13882 if (unformat (input, "del"))
13886 else if (unformat (input, "locator-set %s", &locator_set_name))
13888 locator_set_name_set = 1;
13890 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13893 sw_if_index_if_name_set = 1;
13894 sw_if_index = tmp_if_index;
13896 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13898 sw_if_index_set = 1;
13899 sw_if_index = tmp_if_index;
13901 else if (unformat (input, "p %d", &priority))
13905 else if (unformat (input, "w %d", &weight))
13913 if (locator_set_name_set == 0)
13915 errmsg ("missing locator-set name");
13919 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13921 errmsg ("missing sw_if_index");
13922 vec_free (locator_set_name);
13926 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13928 errmsg ("cannot use both params interface name and sw_if_index");
13929 vec_free (locator_set_name);
13933 if (priority_set == 0)
13935 errmsg ("missing locator-set priority");
13936 vec_free (locator_set_name);
13940 if (weight_set == 0)
13942 errmsg ("missing locator-set weight");
13943 vec_free (locator_set_name);
13947 if (vec_len (locator_set_name) > 64)
13949 errmsg ("locator-set name too long");
13950 vec_free (locator_set_name);
13953 vec_add1 (locator_set_name, 0);
13955 /* Construct the API message */
13956 M (ONE_ADD_DEL_LOCATOR, mp);
13958 mp->is_add = is_add;
13959 mp->sw_if_index = ntohl (sw_if_index);
13960 mp->priority = priority;
13961 mp->weight = weight;
13962 clib_memcpy (mp->locator_set_name, locator_set_name,
13963 vec_len (locator_set_name));
13964 vec_free (locator_set_name);
13969 /* Wait for a reply... */
13974 #define api_lisp_add_del_locator api_one_add_del_locator
13977 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13979 u32 *key_id = va_arg (*args, u32 *);
13982 if (unformat (input, "%s", &s))
13984 if (!strcmp ((char *) s, "sha1"))
13985 key_id[0] = HMAC_SHA_1_96;
13986 else if (!strcmp ((char *) s, "sha256"))
13987 key_id[0] = HMAC_SHA_256_128;
13990 clib_warning ("invalid key_id: '%s'", s);
13991 key_id[0] = HMAC_NO_KEY;
14002 api_one_add_del_local_eid (vat_main_t * vam)
14004 unformat_input_t *input = vam->input;
14005 vl_api_one_add_del_local_eid_t *mp;
14008 lisp_eid_vat_t _eid, *eid = &_eid;
14009 u8 *locator_set_name = 0;
14010 u8 locator_set_name_set = 0;
14016 /* Parse args required to build the message */
14017 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14019 if (unformat (input, "del"))
14023 else if (unformat (input, "vni %d", &vni))
14027 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14031 else if (unformat (input, "locator-set %s", &locator_set_name))
14033 locator_set_name_set = 1;
14035 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14037 else if (unformat (input, "secret-key %_%v%_", &key))
14043 if (locator_set_name_set == 0)
14045 errmsg ("missing locator-set name");
14051 errmsg ("EID address not set!");
14052 vec_free (locator_set_name);
14056 if (key && (0 == key_id))
14058 errmsg ("invalid key_id!");
14062 if (vec_len (key) > 64)
14064 errmsg ("key too long");
14069 if (vec_len (locator_set_name) > 64)
14071 errmsg ("locator-set name too long");
14072 vec_free (locator_set_name);
14075 vec_add1 (locator_set_name, 0);
14077 /* Construct the API message */
14078 M (ONE_ADD_DEL_LOCAL_EID, mp);
14080 mp->is_add = is_add;
14081 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14082 mp->eid_type = eid->type;
14083 mp->prefix_len = eid->len;
14084 mp->vni = clib_host_to_net_u32 (vni);
14085 mp->key_id = clib_host_to_net_u16 (key_id);
14086 clib_memcpy (mp->locator_set_name, locator_set_name,
14087 vec_len (locator_set_name));
14088 clib_memcpy (mp->key, key, vec_len (key));
14090 vec_free (locator_set_name);
14096 /* Wait for a reply... */
14101 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14104 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14106 u32 dp_table = 0, vni = 0;;
14107 unformat_input_t *input = vam->input;
14108 vl_api_gpe_add_del_fwd_entry_t *mp;
14110 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14111 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14112 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14113 u32 action = ~0, w;
14114 ip4_address_t rmt_rloc4, lcl_rloc4;
14115 ip6_address_t rmt_rloc6, lcl_rloc6;
14116 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14119 memset (&rloc, 0, sizeof (rloc));
14121 /* Parse args required to build the message */
14122 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14124 if (unformat (input, "del"))
14126 else if (unformat (input, "add"))
14128 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14132 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14136 else if (unformat (input, "vrf %d", &dp_table))
14138 else if (unformat (input, "bd %d", &dp_table))
14140 else if (unformat (input, "vni %d", &vni))
14142 else if (unformat (input, "w %d", &w))
14146 errmsg ("No RLOC configured for setting priority/weight!");
14149 curr_rloc->weight = w;
14151 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14152 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14156 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14158 vec_add1 (lcl_locs, rloc);
14160 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14161 vec_add1 (rmt_locs, rloc);
14162 /* weight saved in rmt loc */
14163 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14165 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14166 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14169 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14171 vec_add1 (lcl_locs, rloc);
14173 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14174 vec_add1 (rmt_locs, rloc);
14175 /* weight saved in rmt loc */
14176 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14178 else if (unformat (input, "action %d", &action))
14184 clib_warning ("parse error '%U'", format_unformat_error, input);
14191 errmsg ("remote eid addresses not set");
14195 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14197 errmsg ("eid types don't match");
14201 if (0 == rmt_locs && (u32) ~ 0 == action)
14203 errmsg ("action not set for negative mapping");
14207 /* Construct the API message */
14208 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14209 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14211 mp->is_add = is_add;
14212 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14213 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14214 mp->eid_type = rmt_eid->type;
14215 mp->dp_table = clib_host_to_net_u32 (dp_table);
14216 mp->vni = clib_host_to_net_u32 (vni);
14217 mp->rmt_len = rmt_eid->len;
14218 mp->lcl_len = lcl_eid->len;
14219 mp->action = action;
14221 if (0 != rmt_locs && 0 != lcl_locs)
14223 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14224 clib_memcpy (mp->locs, lcl_locs,
14225 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14227 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14228 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14229 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14231 vec_free (lcl_locs);
14232 vec_free (rmt_locs);
14237 /* Wait for a reply... */
14243 api_one_add_del_map_server (vat_main_t * vam)
14245 unformat_input_t *input = vam->input;
14246 vl_api_one_add_del_map_server_t *mp;
14250 ip4_address_t ipv4;
14251 ip6_address_t ipv6;
14254 /* Parse args required to build the message */
14255 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14257 if (unformat (input, "del"))
14261 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14265 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14273 if (ipv4_set && ipv6_set)
14275 errmsg ("both eid v4 and v6 addresses set");
14279 if (!ipv4_set && !ipv6_set)
14281 errmsg ("eid addresses not set");
14285 /* Construct the API message */
14286 M (ONE_ADD_DEL_MAP_SERVER, mp);
14288 mp->is_add = is_add;
14292 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14297 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14303 /* Wait for a reply... */
14308 #define api_lisp_add_del_map_server api_one_add_del_map_server
14311 api_one_add_del_map_resolver (vat_main_t * vam)
14313 unformat_input_t *input = vam->input;
14314 vl_api_one_add_del_map_resolver_t *mp;
14318 ip4_address_t ipv4;
14319 ip6_address_t ipv6;
14322 /* Parse args required to build the message */
14323 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14325 if (unformat (input, "del"))
14329 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14333 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14341 if (ipv4_set && ipv6_set)
14343 errmsg ("both eid v4 and v6 addresses set");
14347 if (!ipv4_set && !ipv6_set)
14349 errmsg ("eid addresses not set");
14353 /* Construct the API message */
14354 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14356 mp->is_add = is_add;
14360 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14365 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14371 /* Wait for a reply... */
14376 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14379 api_lisp_gpe_enable_disable (vat_main_t * vam)
14381 unformat_input_t *input = vam->input;
14382 vl_api_gpe_enable_disable_t *mp;
14387 /* Parse args required to build the message */
14388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14390 if (unformat (input, "enable"))
14395 else if (unformat (input, "disable"))
14406 errmsg ("Value not set");
14410 /* Construct the API message */
14411 M (GPE_ENABLE_DISABLE, mp);
14418 /* Wait for a reply... */
14424 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14426 unformat_input_t *input = vam->input;
14427 vl_api_one_rloc_probe_enable_disable_t *mp;
14432 /* Parse args required to build the message */
14433 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14435 if (unformat (input, "enable"))
14440 else if (unformat (input, "disable"))
14448 errmsg ("Value not set");
14452 /* Construct the API message */
14453 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14455 mp->is_enabled = is_en;
14460 /* Wait for a reply... */
14465 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14468 api_one_map_register_enable_disable (vat_main_t * vam)
14470 unformat_input_t *input = vam->input;
14471 vl_api_one_map_register_enable_disable_t *mp;
14476 /* Parse args required to build the message */
14477 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14479 if (unformat (input, "enable"))
14484 else if (unformat (input, "disable"))
14492 errmsg ("Value not set");
14496 /* Construct the API message */
14497 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14499 mp->is_enabled = is_en;
14504 /* Wait for a reply... */
14509 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14512 api_one_enable_disable (vat_main_t * vam)
14514 unformat_input_t *input = vam->input;
14515 vl_api_one_enable_disable_t *mp;
14520 /* Parse args required to build the message */
14521 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14523 if (unformat (input, "enable"))
14528 else if (unformat (input, "disable"))
14538 errmsg ("Value not set");
14542 /* Construct the API message */
14543 M (ONE_ENABLE_DISABLE, mp);
14550 /* Wait for a reply... */
14555 #define api_lisp_enable_disable api_one_enable_disable
14558 api_show_one_map_register_state (vat_main_t * vam)
14560 vl_api_show_one_map_register_state_t *mp;
14563 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
14568 /* wait for reply */
14573 #define api_show_lisp_map_register_state api_show_one_map_register_state
14576 api_show_one_rloc_probe_state (vat_main_t * vam)
14578 vl_api_show_one_rloc_probe_state_t *mp;
14581 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
14586 /* wait for reply */
14591 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
14594 api_one_stats_enable_disable (vat_main_t * vam)
14596 vl_api_one_stats_enable_disable_t *mp;
14597 unformat_input_t *input = vam->input;
14602 /* Parse args required to build the message */
14603 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14605 if (unformat (input, "enable"))
14610 else if (unformat (input, "disable"))
14620 errmsg ("Value not set");
14624 M (ONE_STATS_ENABLE_DISABLE, mp);
14630 /* wait for reply */
14636 api_show_one_stats_enable_disable (vat_main_t * vam)
14638 vl_api_show_one_stats_enable_disable_t *mp;
14641 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
14646 /* wait for reply */
14652 api_show_one_map_request_mode (vat_main_t * vam)
14654 vl_api_show_one_map_request_mode_t *mp;
14657 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
14662 /* wait for reply */
14667 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
14670 api_one_map_request_mode (vat_main_t * vam)
14672 unformat_input_t *input = vam->input;
14673 vl_api_one_map_request_mode_t *mp;
14677 /* Parse args required to build the message */
14678 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14680 if (unformat (input, "dst-only"))
14682 else if (unformat (input, "src-dst"))
14686 errmsg ("parse error '%U'", format_unformat_error, input);
14691 M (ONE_MAP_REQUEST_MODE, mp);
14698 /* wait for reply */
14703 #define api_lisp_map_request_mode api_one_map_request_mode
14706 * Enable/disable ONE proxy ITR.
14708 * @param vam vpp API test context
14709 * @return return code
14712 api_one_pitr_set_locator_set (vat_main_t * vam)
14714 u8 ls_name_set = 0;
14715 unformat_input_t *input = vam->input;
14716 vl_api_one_pitr_set_locator_set_t *mp;
14721 /* Parse args required to build the message */
14722 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14724 if (unformat (input, "del"))
14726 else if (unformat (input, "locator-set %s", &ls_name))
14730 errmsg ("parse error '%U'", format_unformat_error, input);
14737 errmsg ("locator-set name not set!");
14741 M (ONE_PITR_SET_LOCATOR_SET, mp);
14743 mp->is_add = is_add;
14744 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14745 vec_free (ls_name);
14750 /* wait for reply */
14755 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
14758 api_show_one_pitr (vat_main_t * vam)
14760 vl_api_show_one_pitr_t *mp;
14763 if (!vam->json_output)
14765 print (vam->ofp, "%=20s", "lisp status:");
14768 M (SHOW_ONE_PITR, mp);
14772 /* Wait for a reply... */
14777 #define api_show_lisp_pitr api_show_one_pitr
14780 api_one_use_petr (vat_main_t * vam)
14782 unformat_input_t *input = vam->input;
14783 vl_api_one_use_petr_t *mp;
14788 memset (&ip, 0, sizeof (ip));
14790 /* Parse args required to build the message */
14791 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14793 if (unformat (input, "disable"))
14796 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
14799 ip_addr_version (&ip) = IP4;
14802 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
14805 ip_addr_version (&ip) = IP6;
14809 errmsg ("parse error '%U'", format_unformat_error, input);
14814 M (ONE_USE_PETR, mp);
14816 mp->is_add = is_add;
14819 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
14821 clib_memcpy (mp->address, &ip, 4);
14823 clib_memcpy (mp->address, &ip, 16);
14829 /* wait for reply */
14834 #define api_lisp_use_petr api_one_use_petr
14837 api_show_one_use_petr (vat_main_t * vam)
14839 vl_api_show_one_use_petr_t *mp;
14842 if (!vam->json_output)
14844 print (vam->ofp, "%=20s", "Proxy-ETR status:");
14847 M (SHOW_ONE_USE_PETR, mp);
14851 /* Wait for a reply... */
14856 #define api_show_lisp_use_petr api_show_one_use_petr
14859 * Add/delete mapping between vni and vrf
14862 api_one_eid_table_add_del_map (vat_main_t * vam)
14864 unformat_input_t *input = vam->input;
14865 vl_api_one_eid_table_add_del_map_t *mp;
14866 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14867 u32 vni, vrf, bd_index;
14870 /* Parse args required to build the message */
14871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14873 if (unformat (input, "del"))
14875 else if (unformat (input, "vrf %d", &vrf))
14877 else if (unformat (input, "bd_index %d", &bd_index))
14879 else if (unformat (input, "vni %d", &vni))
14885 if (!vni_set || (!vrf_set && !bd_index_set))
14887 errmsg ("missing arguments!");
14891 if (vrf_set && bd_index_set)
14893 errmsg ("error: both vrf and bd entered!");
14897 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
14899 mp->is_add = is_add;
14900 mp->vni = htonl (vni);
14901 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14902 mp->is_l2 = bd_index_set;
14907 /* wait for reply */
14912 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
14915 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14917 u32 *action = va_arg (*args, u32 *);
14920 if (unformat (input, "%s", &s))
14922 if (!strcmp ((char *) s, "no-action"))
14924 else if (!strcmp ((char *) s, "natively-forward"))
14926 else if (!strcmp ((char *) s, "send-map-request"))
14928 else if (!strcmp ((char *) s, "drop"))
14932 clib_warning ("invalid action: '%s'", s);
14944 * Add/del remote mapping to/from ONE control plane
14946 * @param vam vpp API test context
14947 * @return return code
14950 api_one_add_del_remote_mapping (vat_main_t * vam)
14952 unformat_input_t *input = vam->input;
14953 vl_api_one_add_del_remote_mapping_t *mp;
14955 lisp_eid_vat_t _eid, *eid = &_eid;
14956 lisp_eid_vat_t _seid, *seid = &_seid;
14957 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14958 u32 action = ~0, p, w, data_len;
14959 ip4_address_t rloc4;
14960 ip6_address_t rloc6;
14961 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14964 memset (&rloc, 0, sizeof (rloc));
14966 /* Parse args required to build the message */
14967 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14969 if (unformat (input, "del-all"))
14973 else if (unformat (input, "del"))
14977 else if (unformat (input, "add"))
14981 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14985 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14989 else if (unformat (input, "vni %d", &vni))
14993 else if (unformat (input, "p %d w %d", &p, &w))
14997 errmsg ("No RLOC configured for setting priority/weight!");
15000 curr_rloc->priority = p;
15001 curr_rloc->weight = w;
15003 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15006 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15007 vec_add1 (rlocs, rloc);
15008 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15010 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15013 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15014 vec_add1 (rlocs, rloc);
15015 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15017 else if (unformat (input, "action %U",
15018 unformat_negative_mapping_action, &action))
15024 clib_warning ("parse error '%U'", format_unformat_error, input);
15031 errmsg ("missing params!");
15035 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15037 errmsg ("no action set for negative map-reply!");
15041 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15043 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15044 mp->is_add = is_add;
15045 mp->vni = htonl (vni);
15046 mp->action = (u8) action;
15047 mp->is_src_dst = seid_set;
15048 mp->eid_len = eid->len;
15049 mp->seid_len = seid->len;
15050 mp->del_all = del_all;
15051 mp->eid_type = eid->type;
15052 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15053 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15055 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15056 clib_memcpy (mp->rlocs, rlocs, data_len);
15062 /* Wait for a reply... */
15067 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15070 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15071 * forwarding entries in data-plane accordingly.
15073 * @param vam vpp API test context
15074 * @return return code
15077 api_one_add_del_adjacency (vat_main_t * vam)
15079 unformat_input_t *input = vam->input;
15080 vl_api_one_add_del_adjacency_t *mp;
15082 ip4_address_t leid4, reid4;
15083 ip6_address_t leid6, reid6;
15084 u8 reid_mac[6] = { 0 };
15085 u8 leid_mac[6] = { 0 };
15086 u8 reid_type, leid_type;
15087 u32 leid_len = 0, reid_len = 0, len;
15091 leid_type = reid_type = (u8) ~ 0;
15093 /* Parse args required to build the message */
15094 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15096 if (unformat (input, "del"))
15100 else if (unformat (input, "add"))
15104 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15107 reid_type = 0; /* ipv4 */
15110 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15113 reid_type = 1; /* ipv6 */
15116 else if (unformat (input, "reid %U", unformat_ethernet_address,
15119 reid_type = 2; /* mac */
15121 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15124 leid_type = 0; /* ipv4 */
15127 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15130 leid_type = 1; /* ipv6 */
15133 else if (unformat (input, "leid %U", unformat_ethernet_address,
15136 leid_type = 2; /* mac */
15138 else if (unformat (input, "vni %d", &vni))
15144 errmsg ("parse error '%U'", format_unformat_error, input);
15149 if ((u8) ~ 0 == reid_type)
15151 errmsg ("missing params!");
15155 if (leid_type != reid_type)
15157 errmsg ("remote and local EIDs are of different types!");
15161 M (ONE_ADD_DEL_ADJACENCY, mp);
15162 mp->is_add = is_add;
15163 mp->vni = htonl (vni);
15164 mp->leid_len = leid_len;
15165 mp->reid_len = reid_len;
15166 mp->eid_type = reid_type;
15168 switch (mp->eid_type)
15171 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
15172 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
15175 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
15176 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
15179 clib_memcpy (mp->leid, leid_mac, 6);
15180 clib_memcpy (mp->reid, reid_mac, 6);
15183 errmsg ("unknown EID type %d!", mp->eid_type);
15190 /* Wait for a reply... */
15195 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
15198 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
15200 u32 *mode = va_arg (*args, u32 *);
15202 if (unformat (input, "lisp"))
15204 else if (unformat (input, "vxlan"))
15213 api_gpe_get_encap_mode (vat_main_t * vam)
15215 vl_api_gpe_get_encap_mode_t *mp;
15218 /* Construct the API message */
15219 M (GPE_GET_ENCAP_MODE, mp);
15224 /* Wait for a reply... */
15230 api_gpe_set_encap_mode (vat_main_t * vam)
15232 unformat_input_t *input = vam->input;
15233 vl_api_gpe_set_encap_mode_t *mp;
15237 /* Parse args required to build the message */
15238 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15240 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
15246 /* Construct the API message */
15247 M (GPE_SET_ENCAP_MODE, mp);
15254 /* Wait for a reply... */
15260 api_lisp_gpe_add_del_iface (vat_main_t * vam)
15262 unformat_input_t *input = vam->input;
15263 vl_api_gpe_add_del_iface_t *mp;
15264 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
15265 u32 dp_table = 0, vni = 0;
15268 /* Parse args required to build the message */
15269 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15271 if (unformat (input, "up"))
15276 else if (unformat (input, "down"))
15281 else if (unformat (input, "table_id %d", &dp_table))
15285 else if (unformat (input, "bd_id %d", &dp_table))
15290 else if (unformat (input, "vni %d", &vni))
15298 if (action_set == 0)
15300 errmsg ("Action not set");
15303 if (dp_table_set == 0 || vni_set == 0)
15305 errmsg ("vni and dp_table must be set");
15309 /* Construct the API message */
15310 M (GPE_ADD_DEL_IFACE, mp);
15312 mp->is_add = is_add;
15313 mp->dp_table = dp_table;
15320 /* Wait for a reply... */
15326 * Add/del map request itr rlocs from ONE control plane and updates
15328 * @param vam vpp API test context
15329 * @return return code
15332 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
15334 unformat_input_t *input = vam->input;
15335 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
15336 u8 *locator_set_name = 0;
15337 u8 locator_set_name_set = 0;
15341 /* Parse args required to build the message */
15342 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15344 if (unformat (input, "del"))
15348 else if (unformat (input, "%_%v%_", &locator_set_name))
15350 locator_set_name_set = 1;
15354 clib_warning ("parse error '%U'", format_unformat_error, input);
15359 if (is_add && !locator_set_name_set)
15361 errmsg ("itr-rloc is not set!");
15365 if (is_add && vec_len (locator_set_name) > 64)
15367 errmsg ("itr-rloc locator-set name too long");
15368 vec_free (locator_set_name);
15372 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
15373 mp->is_add = is_add;
15376 clib_memcpy (mp->locator_set_name, locator_set_name,
15377 vec_len (locator_set_name));
15381 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
15383 vec_free (locator_set_name);
15388 /* Wait for a reply... */
15393 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
15396 api_one_locator_dump (vat_main_t * vam)
15398 unformat_input_t *input = vam->input;
15399 vl_api_one_locator_dump_t *mp;
15400 vl_api_control_ping_t *mp_ping;
15401 u8 is_index_set = 0, is_name_set = 0;
15406 /* Parse args required to build the message */
15407 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15409 if (unformat (input, "ls_name %_%v%_", &ls_name))
15413 else if (unformat (input, "ls_index %d", &ls_index))
15419 errmsg ("parse error '%U'", format_unformat_error, input);
15424 if (!is_index_set && !is_name_set)
15426 errmsg ("error: expected one of index or name!");
15430 if (is_index_set && is_name_set)
15432 errmsg ("error: only one param expected!");
15436 if (vec_len (ls_name) > 62)
15438 errmsg ("error: locator set name too long!");
15442 if (!vam->json_output)
15444 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
15447 M (ONE_LOCATOR_DUMP, mp);
15448 mp->is_index_set = is_index_set;
15451 mp->ls_index = clib_host_to_net_u32 (ls_index);
15454 vec_add1 (ls_name, 0);
15455 strncpy ((char *) mp->ls_name, (char *) ls_name,
15456 sizeof (mp->ls_name) - 1);
15462 /* Use a control ping for synchronization */
15463 M (CONTROL_PING, mp_ping);
15466 /* Wait for a reply... */
15471 #define api_lisp_locator_dump api_one_locator_dump
15474 api_one_locator_set_dump (vat_main_t * vam)
15476 vl_api_one_locator_set_dump_t *mp;
15477 vl_api_control_ping_t *mp_ping;
15478 unformat_input_t *input = vam->input;
15482 /* Parse args required to build the message */
15483 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15485 if (unformat (input, "local"))
15489 else if (unformat (input, "remote"))
15495 errmsg ("parse error '%U'", format_unformat_error, input);
15500 if (!vam->json_output)
15502 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
15505 M (ONE_LOCATOR_SET_DUMP, mp);
15507 mp->filter = filter;
15512 /* Use a control ping for synchronization */
15513 M (CONTROL_PING, mp_ping);
15516 /* Wait for a reply... */
15521 #define api_lisp_locator_set_dump api_one_locator_set_dump
15524 api_one_eid_table_map_dump (vat_main_t * vam)
15528 unformat_input_t *input = vam->input;
15529 vl_api_one_eid_table_map_dump_t *mp;
15530 vl_api_control_ping_t *mp_ping;
15533 /* Parse args required to build the message */
15534 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15536 if (unformat (input, "l2"))
15541 else if (unformat (input, "l3"))
15548 errmsg ("parse error '%U'", format_unformat_error, input);
15555 errmsg ("expected one of 'l2' or 'l3' parameter!");
15559 if (!vam->json_output)
15561 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
15564 M (ONE_EID_TABLE_MAP_DUMP, mp);
15570 /* Use a control ping for synchronization */
15571 M (CONTROL_PING, mp_ping);
15574 /* Wait for a reply... */
15579 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
15582 api_one_eid_table_vni_dump (vat_main_t * vam)
15584 vl_api_one_eid_table_vni_dump_t *mp;
15585 vl_api_control_ping_t *mp_ping;
15588 if (!vam->json_output)
15590 print (vam->ofp, "VNI");
15593 M (ONE_EID_TABLE_VNI_DUMP, mp);
15598 /* Use a control ping for synchronization */
15599 M (CONTROL_PING, mp_ping);
15602 /* Wait for a reply... */
15607 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
15610 api_one_eid_table_dump (vat_main_t * vam)
15612 unformat_input_t *i = vam->input;
15613 vl_api_one_eid_table_dump_t *mp;
15614 vl_api_control_ping_t *mp_ping;
15615 struct in_addr ip4;
15616 struct in6_addr ip6;
15618 u8 eid_type = ~0, eid_set = 0;
15619 u32 prefix_length = ~0, t, vni = 0;
15623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15625 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
15631 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
15637 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
15642 else if (unformat (i, "vni %d", &t))
15646 else if (unformat (i, "local"))
15650 else if (unformat (i, "remote"))
15656 errmsg ("parse error '%U'", format_unformat_error, i);
15661 if (!vam->json_output)
15663 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
15664 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
15667 M (ONE_EID_TABLE_DUMP, mp);
15669 mp->filter = filter;
15673 mp->vni = htonl (vni);
15674 mp->eid_type = eid_type;
15678 mp->prefix_length = prefix_length;
15679 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
15682 mp->prefix_length = prefix_length;
15683 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
15686 clib_memcpy (mp->eid, mac, sizeof (mac));
15689 errmsg ("unknown EID type %d!", eid_type);
15697 /* Use a control ping for synchronization */
15698 M (CONTROL_PING, mp_ping);
15701 /* Wait for a reply... */
15706 #define api_lisp_eid_table_dump api_one_eid_table_dump
15709 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15711 unformat_input_t *i = vam->input;
15712 vl_api_gpe_fwd_entries_get_t *mp;
15717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15719 if (unformat (i, "vni %d", &vni))
15725 errmsg ("parse error '%U'", format_unformat_error, i);
15732 errmsg ("vni not set!");
15736 if (!vam->json_output)
15738 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15742 M (GPE_FWD_ENTRIES_GET, mp);
15743 mp->vni = clib_host_to_net_u32 (vni);
15748 /* Wait for a reply... */
15753 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15754 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15755 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15756 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
15759 api_one_adjacencies_get (vat_main_t * vam)
15761 unformat_input_t *i = vam->input;
15762 vl_api_one_adjacencies_get_t *mp;
15767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15769 if (unformat (i, "vni %d", &vni))
15775 errmsg ("parse error '%U'", format_unformat_error, i);
15782 errmsg ("vni not set!");
15786 if (!vam->json_output)
15788 print (vam->ofp, "%s %40s", "leid", "reid");
15791 M (ONE_ADJACENCIES_GET, mp);
15792 mp->vni = clib_host_to_net_u32 (vni);
15797 /* Wait for a reply... */
15802 #define api_lisp_adjacencies_get api_one_adjacencies_get
15805 api_one_map_server_dump (vat_main_t * vam)
15807 vl_api_one_map_server_dump_t *mp;
15808 vl_api_control_ping_t *mp_ping;
15811 if (!vam->json_output)
15813 print (vam->ofp, "%=20s", "Map server");
15816 M (ONE_MAP_SERVER_DUMP, mp);
15820 /* Use a control ping for synchronization */
15821 M (CONTROL_PING, mp_ping);
15824 /* Wait for a reply... */
15829 #define api_lisp_map_server_dump api_one_map_server_dump
15832 api_one_map_resolver_dump (vat_main_t * vam)
15834 vl_api_one_map_resolver_dump_t *mp;
15835 vl_api_control_ping_t *mp_ping;
15838 if (!vam->json_output)
15840 print (vam->ofp, "%=20s", "Map resolver");
15843 M (ONE_MAP_RESOLVER_DUMP, mp);
15847 /* Use a control ping for synchronization */
15848 M (CONTROL_PING, mp_ping);
15851 /* Wait for a reply... */
15856 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
15859 api_one_stats_dump (vat_main_t * vam)
15861 vl_api_one_stats_dump_t *mp;
15862 vl_api_control_ping_t *mp_ping;
15865 M (ONE_STATS_DUMP, mp);
15869 /* Use a control ping for synchronization */
15870 M (CONTROL_PING, mp_ping);
15873 /* Wait for a reply... */
15879 api_show_one_status (vat_main_t * vam)
15881 vl_api_show_one_status_t *mp;
15884 if (!vam->json_output)
15886 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
15889 M (SHOW_ONE_STATUS, mp);
15892 /* Wait for a reply... */
15897 #define api_show_lisp_status api_show_one_status
15900 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15902 vl_api_gpe_fwd_entry_path_dump_t *mp;
15903 vl_api_control_ping_t *mp_ping;
15904 unformat_input_t *i = vam->input;
15905 u32 fwd_entry_index = ~0;
15908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15910 if (unformat (i, "index %d", &fwd_entry_index))
15916 if (~0 == fwd_entry_index)
15918 errmsg ("no index specified!");
15922 if (!vam->json_output)
15924 print (vam->ofp, "first line");
15927 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
15931 /* Use a control ping for synchronization */
15932 M (CONTROL_PING, mp_ping);
15935 /* Wait for a reply... */
15941 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
15943 vl_api_one_get_map_request_itr_rlocs_t *mp;
15946 if (!vam->json_output)
15948 print (vam->ofp, "%=20s", "itr-rlocs:");
15951 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
15954 /* Wait for a reply... */
15959 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
15962 api_af_packet_create (vat_main_t * vam)
15964 unformat_input_t *i = vam->input;
15965 vl_api_af_packet_create_t *mp;
15966 u8 *host_if_name = 0;
15968 u8 random_hw_addr = 1;
15971 memset (hw_addr, 0, sizeof (hw_addr));
15973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15975 if (unformat (i, "name %s", &host_if_name))
15976 vec_add1 (host_if_name, 0);
15977 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15978 random_hw_addr = 0;
15983 if (!vec_len (host_if_name))
15985 errmsg ("host-interface name must be specified");
15989 if (vec_len (host_if_name) > 64)
15991 errmsg ("host-interface name too long");
15995 M (AF_PACKET_CREATE, mp);
15997 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15998 clib_memcpy (mp->hw_addr, hw_addr, 6);
15999 mp->use_random_hw_addr = random_hw_addr;
16000 vec_free (host_if_name);
16008 fprintf (vam->ofp ? vam->ofp : stderr,
16009 " new sw_if_index = %d\n", vam->sw_if_index);
16016 api_af_packet_delete (vat_main_t * vam)
16018 unformat_input_t *i = vam->input;
16019 vl_api_af_packet_delete_t *mp;
16020 u8 *host_if_name = 0;
16023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16025 if (unformat (i, "name %s", &host_if_name))
16026 vec_add1 (host_if_name, 0);
16031 if (!vec_len (host_if_name))
16033 errmsg ("host-interface name must be specified");
16037 if (vec_len (host_if_name) > 64)
16039 errmsg ("host-interface name too long");
16043 M (AF_PACKET_DELETE, mp);
16045 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
16046 vec_free (host_if_name);
16054 api_policer_add_del (vat_main_t * vam)
16056 unformat_input_t *i = vam->input;
16057 vl_api_policer_add_del_t *mp;
16067 u8 color_aware = 0;
16068 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
16071 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
16072 conform_action.dscp = 0;
16073 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
16074 exceed_action.dscp = 0;
16075 violate_action.action_type = SSE2_QOS_ACTION_DROP;
16076 violate_action.dscp = 0;
16078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16080 if (unformat (i, "del"))
16082 else if (unformat (i, "name %s", &name))
16083 vec_add1 (name, 0);
16084 else if (unformat (i, "cir %u", &cir))
16086 else if (unformat (i, "eir %u", &eir))
16088 else if (unformat (i, "cb %u", &cb))
16090 else if (unformat (i, "eb %u", &eb))
16092 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
16095 else if (unformat (i, "round_type %U", unformat_policer_round_type,
16098 else if (unformat (i, "type %U", unformat_policer_type, &type))
16100 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
16103 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
16106 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
16109 else if (unformat (i, "color-aware"))
16115 if (!vec_len (name))
16117 errmsg ("policer name must be specified");
16121 if (vec_len (name) > 64)
16123 errmsg ("policer name too long");
16127 M (POLICER_ADD_DEL, mp);
16129 clib_memcpy (mp->name, name, vec_len (name));
16131 mp->is_add = is_add;
16136 mp->rate_type = rate_type;
16137 mp->round_type = round_type;
16139 mp->conform_action_type = conform_action.action_type;
16140 mp->conform_dscp = conform_action.dscp;
16141 mp->exceed_action_type = exceed_action.action_type;
16142 mp->exceed_dscp = exceed_action.dscp;
16143 mp->violate_action_type = violate_action.action_type;
16144 mp->violate_dscp = violate_action.dscp;
16145 mp->color_aware = color_aware;
16153 api_policer_dump (vat_main_t * vam)
16155 unformat_input_t *i = vam->input;
16156 vl_api_policer_dump_t *mp;
16157 vl_api_control_ping_t *mp_ping;
16158 u8 *match_name = 0;
16159 u8 match_name_valid = 0;
16162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16164 if (unformat (i, "name %s", &match_name))
16166 vec_add1 (match_name, 0);
16167 match_name_valid = 1;
16173 M (POLICER_DUMP, mp);
16174 mp->match_name_valid = match_name_valid;
16175 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
16176 vec_free (match_name);
16180 /* Use a control ping for synchronization */
16181 M (CONTROL_PING, mp_ping);
16184 /* Wait for a reply... */
16190 api_policer_classify_set_interface (vat_main_t * vam)
16192 unformat_input_t *i = vam->input;
16193 vl_api_policer_classify_set_interface_t *mp;
16195 int sw_if_index_set;
16196 u32 ip4_table_index = ~0;
16197 u32 ip6_table_index = ~0;
16198 u32 l2_table_index = ~0;
16202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16205 sw_if_index_set = 1;
16206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16207 sw_if_index_set = 1;
16208 else if (unformat (i, "del"))
16210 else if (unformat (i, "ip4-table %d", &ip4_table_index))
16212 else if (unformat (i, "ip6-table %d", &ip6_table_index))
16214 else if (unformat (i, "l2-table %d", &l2_table_index))
16218 clib_warning ("parse error '%U'", format_unformat_error, i);
16223 if (sw_if_index_set == 0)
16225 errmsg ("missing interface name or sw_if_index");
16229 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
16231 mp->sw_if_index = ntohl (sw_if_index);
16232 mp->ip4_table_index = ntohl (ip4_table_index);
16233 mp->ip6_table_index = ntohl (ip6_table_index);
16234 mp->l2_table_index = ntohl (l2_table_index);
16235 mp->is_add = is_add;
16243 api_policer_classify_dump (vat_main_t * vam)
16245 unformat_input_t *i = vam->input;
16246 vl_api_policer_classify_dump_t *mp;
16247 vl_api_control_ping_t *mp_ping;
16248 u8 type = POLICER_CLASSIFY_N_TABLES;
16251 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
16255 errmsg ("classify table type must be specified");
16259 if (!vam->json_output)
16261 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
16264 M (POLICER_CLASSIFY_DUMP, mp);
16269 /* Use a control ping for synchronization */
16270 M (CONTROL_PING, mp_ping);
16273 /* Wait for a reply... */
16279 api_netmap_create (vat_main_t * vam)
16281 unformat_input_t *i = vam->input;
16282 vl_api_netmap_create_t *mp;
16285 u8 random_hw_addr = 1;
16290 memset (hw_addr, 0, sizeof (hw_addr));
16292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16294 if (unformat (i, "name %s", &if_name))
16295 vec_add1 (if_name, 0);
16296 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
16297 random_hw_addr = 0;
16298 else if (unformat (i, "pipe"))
16300 else if (unformat (i, "master"))
16302 else if (unformat (i, "slave"))
16308 if (!vec_len (if_name))
16310 errmsg ("interface name must be specified");
16314 if (vec_len (if_name) > 64)
16316 errmsg ("interface name too long");
16320 M (NETMAP_CREATE, mp);
16322 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
16323 clib_memcpy (mp->hw_addr, hw_addr, 6);
16324 mp->use_random_hw_addr = random_hw_addr;
16325 mp->is_pipe = is_pipe;
16326 mp->is_master = is_master;
16327 vec_free (if_name);
16335 api_netmap_delete (vat_main_t * vam)
16337 unformat_input_t *i = vam->input;
16338 vl_api_netmap_delete_t *mp;
16342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16344 if (unformat (i, "name %s", &if_name))
16345 vec_add1 (if_name, 0);
16350 if (!vec_len (if_name))
16352 errmsg ("interface name must be specified");
16356 if (vec_len (if_name) > 64)
16358 errmsg ("interface name too long");
16362 M (NETMAP_DELETE, mp);
16364 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
16365 vec_free (if_name);
16373 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
16375 if (fp->afi == IP46_TYPE_IP6)
16377 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16378 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16379 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16380 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16381 format_ip6_address, fp->next_hop);
16382 else if (fp->afi == IP46_TYPE_IP4)
16384 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16385 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16386 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16387 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16388 format_ip4_address, fp->next_hop);
16392 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
16393 vl_api_fib_path2_t * fp)
16395 struct in_addr ip4;
16396 struct in6_addr ip6;
16398 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16399 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16400 vat_json_object_add_uint (node, "is_local", fp->is_local);
16401 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16402 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16403 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16404 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16405 if (fp->afi == IP46_TYPE_IP4)
16407 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16408 vat_json_object_add_ip4 (node, "next_hop", ip4);
16410 else if (fp->afi == IP46_TYPE_IP6)
16412 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16413 vat_json_object_add_ip6 (node, "next_hop", ip6);
16418 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
16420 vat_main_t *vam = &vat_main;
16421 int count = ntohl (mp->mt_count);
16422 vl_api_fib_path2_t *fp;
16425 print (vam->ofp, "[%d]: sw_if_index %d via:",
16426 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
16428 for (i = 0; i < count; i++)
16430 vl_api_mpls_fib_path_print (vam, fp);
16434 print (vam->ofp, "");
16437 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
16438 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
16441 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
16443 vat_main_t *vam = &vat_main;
16444 vat_json_node_t *node = NULL;
16445 int count = ntohl (mp->mt_count);
16446 vl_api_fib_path2_t *fp;
16449 if (VAT_JSON_ARRAY != vam->json_tree.type)
16451 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16452 vat_json_init_array (&vam->json_tree);
16454 node = vat_json_array_add (&vam->json_tree);
16456 vat_json_init_object (node);
16457 vat_json_object_add_uint (node, "tunnel_index",
16458 ntohl (mp->mt_tunnel_index));
16459 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
16461 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
16464 for (i = 0; i < count; i++)
16466 vl_api_mpls_fib_path_json_print (node, fp);
16472 api_mpls_tunnel_dump (vat_main_t * vam)
16474 vl_api_mpls_tunnel_dump_t *mp;
16475 vl_api_control_ping_t *mp_ping;
16479 /* Parse args required to build the message */
16480 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
16482 if (!unformat (vam->input, "tunnel_index %d", &index))
16489 print (vam->ofp, " tunnel_index %d", index);
16491 M (MPLS_TUNNEL_DUMP, mp);
16492 mp->tunnel_index = htonl (index);
16495 /* Use a control ping for synchronization */
16496 M (CONTROL_PING, mp_ping);
16503 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
16504 #define vl_api_mpls_fib_details_t_print vl_noop_handler
16508 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
16510 vat_main_t *vam = &vat_main;
16511 int count = ntohl (mp->count);
16512 vl_api_fib_path2_t *fp;
16516 "table-id %d, label %u, ess_bit %u",
16517 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
16519 for (i = 0; i < count; i++)
16521 vl_api_mpls_fib_path_print (vam, fp);
16526 static void vl_api_mpls_fib_details_t_handler_json
16527 (vl_api_mpls_fib_details_t * mp)
16529 vat_main_t *vam = &vat_main;
16530 int count = ntohl (mp->count);
16531 vat_json_node_t *node = NULL;
16532 vl_api_fib_path2_t *fp;
16535 if (VAT_JSON_ARRAY != vam->json_tree.type)
16537 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16538 vat_json_init_array (&vam->json_tree);
16540 node = vat_json_array_add (&vam->json_tree);
16542 vat_json_init_object (node);
16543 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16544 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
16545 vat_json_object_add_uint (node, "label", ntohl (mp->label));
16546 vat_json_object_add_uint (node, "path_count", count);
16548 for (i = 0; i < count; i++)
16550 vl_api_mpls_fib_path_json_print (node, fp);
16556 api_mpls_fib_dump (vat_main_t * vam)
16558 vl_api_mpls_fib_dump_t *mp;
16559 vl_api_control_ping_t *mp_ping;
16562 M (MPLS_FIB_DUMP, mp);
16565 /* Use a control ping for synchronization */
16566 M (CONTROL_PING, mp_ping);
16573 #define vl_api_ip_fib_details_t_endian vl_noop_handler
16574 #define vl_api_ip_fib_details_t_print vl_noop_handler
16577 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
16579 vat_main_t *vam = &vat_main;
16580 int count = ntohl (mp->count);
16581 vl_api_fib_path_t *fp;
16585 "table-id %d, prefix %U/%d",
16586 ntohl (mp->table_id), format_ip4_address, mp->address,
16587 mp->address_length);
16589 for (i = 0; i < count; i++)
16591 if (fp->afi == IP46_TYPE_IP6)
16593 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16594 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16595 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16596 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16597 format_ip6_address, fp->next_hop);
16598 else if (fp->afi == IP46_TYPE_IP4)
16600 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16601 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16602 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16603 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16604 format_ip4_address, fp->next_hop);
16609 static void vl_api_ip_fib_details_t_handler_json
16610 (vl_api_ip_fib_details_t * mp)
16612 vat_main_t *vam = &vat_main;
16613 int count = ntohl (mp->count);
16614 vat_json_node_t *node = NULL;
16615 struct in_addr ip4;
16616 struct in6_addr ip6;
16617 vl_api_fib_path_t *fp;
16620 if (VAT_JSON_ARRAY != vam->json_tree.type)
16622 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16623 vat_json_init_array (&vam->json_tree);
16625 node = vat_json_array_add (&vam->json_tree);
16627 vat_json_init_object (node);
16628 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16629 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
16630 vat_json_object_add_ip4 (node, "prefix", ip4);
16631 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16632 vat_json_object_add_uint (node, "path_count", count);
16634 for (i = 0; i < count; i++)
16636 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16637 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16638 vat_json_object_add_uint (node, "is_local", fp->is_local);
16639 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16640 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16641 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16642 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16643 if (fp->afi == IP46_TYPE_IP4)
16645 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16646 vat_json_object_add_ip4 (node, "next_hop", ip4);
16648 else if (fp->afi == IP46_TYPE_IP6)
16650 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16651 vat_json_object_add_ip6 (node, "next_hop", ip6);
16657 api_ip_fib_dump (vat_main_t * vam)
16659 vl_api_ip_fib_dump_t *mp;
16660 vl_api_control_ping_t *mp_ping;
16663 M (IP_FIB_DUMP, mp);
16666 /* Use a control ping for synchronization */
16667 M (CONTROL_PING, mp_ping);
16675 api_ip_mfib_dump (vat_main_t * vam)
16677 vl_api_ip_mfib_dump_t *mp;
16678 vl_api_control_ping_t *mp_ping;
16681 M (IP_MFIB_DUMP, mp);
16684 /* Use a control ping for synchronization */
16685 M (CONTROL_PING, mp_ping);
16692 static void vl_api_ip_neighbor_details_t_handler
16693 (vl_api_ip_neighbor_details_t * mp)
16695 vat_main_t *vam = &vat_main;
16697 print (vam->ofp, "%c %U %U",
16698 (mp->is_static) ? 'S' : 'D',
16699 format_ethernet_address, &mp->mac_address,
16700 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
16704 static void vl_api_ip_neighbor_details_t_handler_json
16705 (vl_api_ip_neighbor_details_t * mp)
16708 vat_main_t *vam = &vat_main;
16709 vat_json_node_t *node;
16710 struct in_addr ip4;
16711 struct in6_addr ip6;
16713 if (VAT_JSON_ARRAY != vam->json_tree.type)
16715 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16716 vat_json_init_array (&vam->json_tree);
16718 node = vat_json_array_add (&vam->json_tree);
16720 vat_json_init_object (node);
16721 vat_json_object_add_string_copy (node, "flag",
16722 (mp->is_static) ? (u8 *) "static" : (u8 *)
16725 vat_json_object_add_string_copy (node, "link_layer",
16726 format (0, "%U", format_ethernet_address,
16727 &mp->mac_address));
16731 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
16732 vat_json_object_add_ip6 (node, "ip_address", ip6);
16736 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
16737 vat_json_object_add_ip4 (node, "ip_address", ip4);
16742 api_ip_neighbor_dump (vat_main_t * vam)
16744 unformat_input_t *i = vam->input;
16745 vl_api_ip_neighbor_dump_t *mp;
16746 vl_api_control_ping_t *mp_ping;
16748 u32 sw_if_index = ~0;
16751 /* Parse args required to build the message */
16752 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16754 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16756 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16758 else if (unformat (i, "ip6"))
16764 if (sw_if_index == ~0)
16766 errmsg ("missing interface name or sw_if_index");
16770 M (IP_NEIGHBOR_DUMP, mp);
16771 mp->is_ipv6 = (u8) is_ipv6;
16772 mp->sw_if_index = ntohl (sw_if_index);
16775 /* Use a control ping for synchronization */
16776 M (CONTROL_PING, mp_ping);
16783 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16784 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16787 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16789 vat_main_t *vam = &vat_main;
16790 int count = ntohl (mp->count);
16791 vl_api_fib_path_t *fp;
16795 "table-id %d, prefix %U/%d",
16796 ntohl (mp->table_id), format_ip6_address, mp->address,
16797 mp->address_length);
16799 for (i = 0; i < count; i++)
16801 if (fp->afi == IP46_TYPE_IP6)
16803 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16804 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16805 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16806 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16807 format_ip6_address, fp->next_hop);
16808 else if (fp->afi == IP46_TYPE_IP4)
16810 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16811 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16812 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16813 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16814 format_ip4_address, fp->next_hop);
16819 static void vl_api_ip6_fib_details_t_handler_json
16820 (vl_api_ip6_fib_details_t * mp)
16822 vat_main_t *vam = &vat_main;
16823 int count = ntohl (mp->count);
16824 vat_json_node_t *node = NULL;
16825 struct in_addr ip4;
16826 struct in6_addr ip6;
16827 vl_api_fib_path_t *fp;
16830 if (VAT_JSON_ARRAY != vam->json_tree.type)
16832 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16833 vat_json_init_array (&vam->json_tree);
16835 node = vat_json_array_add (&vam->json_tree);
16837 vat_json_init_object (node);
16838 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16839 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16840 vat_json_object_add_ip6 (node, "prefix", ip6);
16841 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16842 vat_json_object_add_uint (node, "path_count", count);
16844 for (i = 0; i < count; i++)
16846 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16847 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16848 vat_json_object_add_uint (node, "is_local", fp->is_local);
16849 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16850 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16851 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16852 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16853 if (fp->afi == IP46_TYPE_IP4)
16855 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16856 vat_json_object_add_ip4 (node, "next_hop", ip4);
16858 else if (fp->afi == IP46_TYPE_IP6)
16860 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16861 vat_json_object_add_ip6 (node, "next_hop", ip6);
16867 api_ip6_fib_dump (vat_main_t * vam)
16869 vl_api_ip6_fib_dump_t *mp;
16870 vl_api_control_ping_t *mp_ping;
16873 M (IP6_FIB_DUMP, mp);
16876 /* Use a control ping for synchronization */
16877 M (CONTROL_PING, mp_ping);
16885 api_ip6_mfib_dump (vat_main_t * vam)
16887 vl_api_ip6_mfib_dump_t *mp;
16888 vl_api_control_ping_t *mp_ping;
16891 M (IP6_MFIB_DUMP, mp);
16894 /* Use a control ping for synchronization */
16895 M (CONTROL_PING, mp_ping);
16903 api_classify_table_ids (vat_main_t * vam)
16905 vl_api_classify_table_ids_t *mp;
16908 /* Construct the API message */
16909 M (CLASSIFY_TABLE_IDS, mp);
16918 api_classify_table_by_interface (vat_main_t * vam)
16920 unformat_input_t *input = vam->input;
16921 vl_api_classify_table_by_interface_t *mp;
16923 u32 sw_if_index = ~0;
16925 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16927 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16929 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16934 if (sw_if_index == ~0)
16936 errmsg ("missing interface name or sw_if_index");
16940 /* Construct the API message */
16941 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16943 mp->sw_if_index = ntohl (sw_if_index);
16951 api_classify_table_info (vat_main_t * vam)
16953 unformat_input_t *input = vam->input;
16954 vl_api_classify_table_info_t *mp;
16958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16960 if (unformat (input, "table_id %d", &table_id))
16965 if (table_id == ~0)
16967 errmsg ("missing table id");
16971 /* Construct the API message */
16972 M (CLASSIFY_TABLE_INFO, mp);
16974 mp->table_id = ntohl (table_id);
16982 api_classify_session_dump (vat_main_t * vam)
16984 unformat_input_t *input = vam->input;
16985 vl_api_classify_session_dump_t *mp;
16986 vl_api_control_ping_t *mp_ping;
16990 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16992 if (unformat (input, "table_id %d", &table_id))
16997 if (table_id == ~0)
16999 errmsg ("missing table id");
17003 /* Construct the API message */
17004 M (CLASSIFY_SESSION_DUMP, mp);
17006 mp->table_id = ntohl (table_id);
17009 /* Use a control ping for synchronization */
17010 M (CONTROL_PING, mp_ping);
17018 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
17020 vat_main_t *vam = &vat_main;
17022 print (vam->ofp, "collector_address %U, collector_port %d, "
17023 "src_address %U, vrf_id %d, path_mtu %u, "
17024 "template_interval %u, udp_checksum %d",
17025 format_ip4_address, mp->collector_address,
17026 ntohs (mp->collector_port),
17027 format_ip4_address, mp->src_address,
17028 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
17029 ntohl (mp->template_interval), mp->udp_checksum);
17032 vam->result_ready = 1;
17036 vl_api_ipfix_exporter_details_t_handler_json
17037 (vl_api_ipfix_exporter_details_t * mp)
17039 vat_main_t *vam = &vat_main;
17040 vat_json_node_t node;
17041 struct in_addr collector_address;
17042 struct in_addr src_address;
17044 vat_json_init_object (&node);
17045 clib_memcpy (&collector_address, &mp->collector_address,
17046 sizeof (collector_address));
17047 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
17048 vat_json_object_add_uint (&node, "collector_port",
17049 ntohs (mp->collector_port));
17050 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
17051 vat_json_object_add_ip4 (&node, "src_address", src_address);
17052 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
17053 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
17054 vat_json_object_add_uint (&node, "template_interval",
17055 ntohl (mp->template_interval));
17056 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
17058 vat_json_print (vam->ofp, &node);
17059 vat_json_free (&node);
17061 vam->result_ready = 1;
17065 api_ipfix_exporter_dump (vat_main_t * vam)
17067 vl_api_ipfix_exporter_dump_t *mp;
17070 /* Construct the API message */
17071 M (IPFIX_EXPORTER_DUMP, mp);
17080 api_ipfix_classify_stream_dump (vat_main_t * vam)
17082 vl_api_ipfix_classify_stream_dump_t *mp;
17085 /* Construct the API message */
17086 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
17097 vl_api_ipfix_classify_stream_details_t_handler
17098 (vl_api_ipfix_classify_stream_details_t * mp)
17100 vat_main_t *vam = &vat_main;
17101 print (vam->ofp, "domain_id %d, src_port %d",
17102 ntohl (mp->domain_id), ntohs (mp->src_port));
17104 vam->result_ready = 1;
17108 vl_api_ipfix_classify_stream_details_t_handler_json
17109 (vl_api_ipfix_classify_stream_details_t * mp)
17111 vat_main_t *vam = &vat_main;
17112 vat_json_node_t node;
17114 vat_json_init_object (&node);
17115 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
17116 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
17118 vat_json_print (vam->ofp, &node);
17119 vat_json_free (&node);
17121 vam->result_ready = 1;
17125 api_ipfix_classify_table_dump (vat_main_t * vam)
17127 vl_api_ipfix_classify_table_dump_t *mp;
17128 vl_api_control_ping_t *mp_ping;
17131 if (!vam->json_output)
17133 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
17134 "transport_protocol");
17137 /* Construct the API message */
17138 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
17143 /* Use a control ping for synchronization */
17144 M (CONTROL_PING, mp_ping);
17152 vl_api_ipfix_classify_table_details_t_handler
17153 (vl_api_ipfix_classify_table_details_t * mp)
17155 vat_main_t *vam = &vat_main;
17156 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
17157 mp->transport_protocol);
17161 vl_api_ipfix_classify_table_details_t_handler_json
17162 (vl_api_ipfix_classify_table_details_t * mp)
17164 vat_json_node_t *node = NULL;
17165 vat_main_t *vam = &vat_main;
17167 if (VAT_JSON_ARRAY != vam->json_tree.type)
17169 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17170 vat_json_init_array (&vam->json_tree);
17173 node = vat_json_array_add (&vam->json_tree);
17174 vat_json_init_object (node);
17176 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
17177 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
17178 vat_json_object_add_uint (node, "transport_protocol",
17179 mp->transport_protocol);
17183 api_sw_interface_span_enable_disable (vat_main_t * vam)
17185 unformat_input_t *i = vam->input;
17186 vl_api_sw_interface_span_enable_disable_t *mp;
17187 u32 src_sw_if_index = ~0;
17188 u32 dst_sw_if_index = ~0;
17192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17195 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
17197 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
17201 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
17203 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
17205 else if (unformat (i, "disable"))
17207 else if (unformat (i, "rx"))
17209 else if (unformat (i, "tx"))
17211 else if (unformat (i, "both"))
17217 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
17219 mp->sw_if_index_from = htonl (src_sw_if_index);
17220 mp->sw_if_index_to = htonl (dst_sw_if_index);
17229 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
17232 vat_main_t *vam = &vat_main;
17233 u8 *sw_if_from_name = 0;
17234 u8 *sw_if_to_name = 0;
17235 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
17236 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
17237 char *states[] = { "none", "rx", "tx", "both" };
17241 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
17243 if ((u32) p->value[0] == sw_if_index_from)
17245 sw_if_from_name = (u8 *)(p->key);
17249 if ((u32) p->value[0] == sw_if_index_to)
17251 sw_if_to_name = (u8 *)(p->key);
17252 if (sw_if_from_name)
17257 print (vam->ofp, "%20s => %20s (%s)",
17258 sw_if_from_name, sw_if_to_name, states[mp->state]);
17262 vl_api_sw_interface_span_details_t_handler_json
17263 (vl_api_sw_interface_span_details_t * mp)
17265 vat_main_t *vam = &vat_main;
17266 vat_json_node_t *node = NULL;
17267 u8 *sw_if_from_name = 0;
17268 u8 *sw_if_to_name = 0;
17269 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
17270 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
17274 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
17276 if ((u32) p->value[0] == sw_if_index_from)
17278 sw_if_from_name = (u8 *)(p->key);
17282 if ((u32) p->value[0] == sw_if_index_to)
17284 sw_if_to_name = (u8 *)(p->key);
17285 if (sw_if_from_name)
17291 if (VAT_JSON_ARRAY != vam->json_tree.type)
17293 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17294 vat_json_init_array (&vam->json_tree);
17296 node = vat_json_array_add (&vam->json_tree);
17298 vat_json_init_object (node);
17299 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
17300 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
17301 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
17302 if (0 != sw_if_to_name)
17304 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
17306 vat_json_object_add_uint (node, "state", mp->state);
17310 api_sw_interface_span_dump (vat_main_t * vam)
17312 vl_api_sw_interface_span_dump_t *mp;
17313 vl_api_control_ping_t *mp_ping;
17316 M (SW_INTERFACE_SPAN_DUMP, mp);
17319 /* Use a control ping for synchronization */
17320 M (CONTROL_PING, mp_ping);
17328 api_pg_create_interface (vat_main_t * vam)
17330 unformat_input_t *input = vam->input;
17331 vl_api_pg_create_interface_t *mp;
17335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17337 if (unformat (input, "if_id %d", &if_id))
17344 errmsg ("missing pg interface index");
17348 /* Construct the API message */
17349 M (PG_CREATE_INTERFACE, mp);
17351 mp->interface_id = ntohl (if_id);
17359 api_pg_capture (vat_main_t * vam)
17361 unformat_input_t *input = vam->input;
17362 vl_api_pg_capture_t *mp;
17367 u8 pcap_file_set = 0;
17370 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17372 if (unformat (input, "if_id %d", &if_id))
17374 else if (unformat (input, "pcap %s", &pcap_file))
17376 else if (unformat (input, "count %d", &count))
17378 else if (unformat (input, "disable"))
17385 errmsg ("missing pg interface index");
17388 if (pcap_file_set > 0)
17390 if (vec_len (pcap_file) > 255)
17392 errmsg ("pcap file name is too long");
17397 u32 name_len = vec_len (pcap_file);
17398 /* Construct the API message */
17399 M (PG_CAPTURE, mp);
17401 mp->interface_id = ntohl (if_id);
17402 mp->is_enabled = enable;
17403 mp->count = ntohl (count);
17404 mp->pcap_name_length = ntohl (name_len);
17405 if (pcap_file_set != 0)
17407 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
17409 vec_free (pcap_file);
17417 api_pg_enable_disable (vat_main_t * vam)
17419 unformat_input_t *input = vam->input;
17420 vl_api_pg_enable_disable_t *mp;
17423 u8 stream_name_set = 0;
17424 u8 *stream_name = 0;
17426 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17428 if (unformat (input, "stream %s", &stream_name))
17429 stream_name_set = 1;
17430 else if (unformat (input, "disable"))
17436 if (stream_name_set > 0)
17438 if (vec_len (stream_name) > 255)
17440 errmsg ("stream name too long");
17445 u32 name_len = vec_len (stream_name);
17446 /* Construct the API message */
17447 M (PG_ENABLE_DISABLE, mp);
17449 mp->is_enabled = enable;
17450 if (stream_name_set != 0)
17452 mp->stream_name_length = ntohl (name_len);
17453 clib_memcpy (mp->stream_name, stream_name, name_len);
17455 vec_free (stream_name);
17463 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
17465 unformat_input_t *input = vam->input;
17466 vl_api_ip_source_and_port_range_check_add_del_t *mp;
17468 u16 *low_ports = 0;
17469 u16 *high_ports = 0;
17472 ip4_address_t ip4_addr;
17473 ip6_address_t ip6_addr;
17482 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17484 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
17490 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
17495 else if (unformat (input, "vrf %d", &vrf_id))
17497 else if (unformat (input, "del"))
17499 else if (unformat (input, "port %d", &tmp))
17501 if (tmp == 0 || tmp > 65535)
17503 errmsg ("port %d out of range", tmp);
17507 this_hi = this_low + 1;
17508 vec_add1 (low_ports, this_low);
17509 vec_add1 (high_ports, this_hi);
17511 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
17513 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
17515 errmsg ("incorrect range parameters");
17519 /* Note: in debug CLI +1 is added to high before
17520 passing to real fn that does "the work"
17521 (ip_source_and_port_range_check_add_del).
17522 This fn is a wrapper around the binary API fn a
17523 control plane will call, which expects this increment
17524 to have occurred. Hence letting the binary API control
17525 plane fn do the increment for consistency between VAT
17526 and other control planes.
17529 vec_add1 (low_ports, this_low);
17530 vec_add1 (high_ports, this_hi);
17536 if (prefix_set == 0)
17538 errmsg ("<address>/<mask> not specified");
17544 errmsg ("VRF ID required, not specified");
17551 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17555 if (vec_len (low_ports) == 0)
17557 errmsg ("At least one port or port range required");
17561 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
17563 mp->is_add = is_add;
17568 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
17573 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
17576 mp->mask_length = length;
17577 mp->number_of_ranges = vec_len (low_ports);
17579 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
17580 vec_free (low_ports);
17582 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
17583 vec_free (high_ports);
17585 mp->vrf_id = ntohl (vrf_id);
17593 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
17595 unformat_input_t *input = vam->input;
17596 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
17597 u32 sw_if_index = ~0;
17599 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
17600 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
17604 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17606 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17608 else if (unformat (input, "sw_if_index %d", &sw_if_index))
17610 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
17612 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
17614 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
17616 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
17618 else if (unformat (input, "del"))
17624 if (sw_if_index == ~0)
17626 errmsg ("Interface required but not specified");
17632 errmsg ("VRF ID required but not specified");
17636 if (tcp_out_vrf_id == 0
17637 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
17640 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17644 /* Construct the API message */
17645 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
17647 mp->sw_if_index = ntohl (sw_if_index);
17648 mp->is_add = is_add;
17649 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
17650 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
17651 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
17652 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
17657 /* Wait for a reply... */
17663 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
17665 unformat_input_t *i = vam->input;
17666 vl_api_ipsec_gre_add_del_tunnel_t *mp;
17667 u32 local_sa_id = 0;
17668 u32 remote_sa_id = 0;
17669 ip4_address_t src_address;
17670 ip4_address_t dst_address;
17674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17676 if (unformat (i, "local_sa %d", &local_sa_id))
17678 else if (unformat (i, "remote_sa %d", &remote_sa_id))
17680 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
17682 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
17684 else if (unformat (i, "del"))
17688 clib_warning ("parse error '%U'", format_unformat_error, i);
17693 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
17695 mp->local_sa_id = ntohl (local_sa_id);
17696 mp->remote_sa_id = ntohl (remote_sa_id);
17697 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
17698 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
17699 mp->is_add = is_add;
17707 api_punt (vat_main_t * vam)
17709 unformat_input_t *i = vam->input;
17717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17719 if (unformat (i, "ip %d", &ipv))
17721 else if (unformat (i, "protocol %d", &protocol))
17723 else if (unformat (i, "port %d", &port))
17725 else if (unformat (i, "del"))
17729 clib_warning ("parse error '%U'", format_unformat_error, i);
17736 mp->is_add = (u8) is_add;
17737 mp->ipv = (u8) ipv;
17738 mp->l4_protocol = (u8) protocol;
17739 mp->l4_port = htons ((u16) port);
17746 static void vl_api_ipsec_gre_tunnel_details_t_handler
17747 (vl_api_ipsec_gre_tunnel_details_t * mp)
17749 vat_main_t *vam = &vat_main;
17751 print (vam->ofp, "%11d%15U%15U%14d%14d",
17752 ntohl (mp->sw_if_index),
17753 format_ip4_address, &mp->src_address,
17754 format_ip4_address, &mp->dst_address,
17755 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17758 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17759 (vl_api_ipsec_gre_tunnel_details_t * mp)
17761 vat_main_t *vam = &vat_main;
17762 vat_json_node_t *node = NULL;
17763 struct in_addr ip4;
17765 if (VAT_JSON_ARRAY != vam->json_tree.type)
17767 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17768 vat_json_init_array (&vam->json_tree);
17770 node = vat_json_array_add (&vam->json_tree);
17772 vat_json_init_object (node);
17773 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17774 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17775 vat_json_object_add_ip4 (node, "src_address", ip4);
17776 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17777 vat_json_object_add_ip4 (node, "dst_address", ip4);
17778 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17779 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17783 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17785 unformat_input_t *i = vam->input;
17786 vl_api_ipsec_gre_tunnel_dump_t *mp;
17787 vl_api_control_ping_t *mp_ping;
17789 u8 sw_if_index_set = 0;
17792 /* Parse args required to build the message */
17793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17795 if (unformat (i, "sw_if_index %d", &sw_if_index))
17796 sw_if_index_set = 1;
17801 if (sw_if_index_set == 0)
17806 if (!vam->json_output)
17808 print (vam->ofp, "%11s%15s%15s%14s%14s",
17809 "sw_if_index", "src_address", "dst_address",
17810 "local_sa_id", "remote_sa_id");
17813 /* Get list of gre-tunnel interfaces */
17814 M (IPSEC_GRE_TUNNEL_DUMP, mp);
17816 mp->sw_if_index = htonl (sw_if_index);
17820 /* Use a control ping for synchronization */
17821 M (CONTROL_PING, mp_ping);
17829 api_delete_subif (vat_main_t * vam)
17831 unformat_input_t *i = vam->input;
17832 vl_api_delete_subif_t *mp;
17833 u32 sw_if_index = ~0;
17836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17838 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17840 if (unformat (i, "sw_if_index %d", &sw_if_index))
17846 if (sw_if_index == ~0)
17848 errmsg ("missing sw_if_index");
17852 /* Construct the API message */
17853 M (DELETE_SUBIF, mp);
17854 mp->sw_if_index = ntohl (sw_if_index);
17861 #define foreach_pbb_vtr_op \
17862 _("disable", L2_VTR_DISABLED) \
17863 _("pop", L2_VTR_POP_2) \
17864 _("push", L2_VTR_PUSH_2)
17867 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17869 unformat_input_t *i = vam->input;
17870 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17871 u32 sw_if_index = ~0, vtr_op = ~0;
17872 u16 outer_tag = ~0;
17873 u8 dmac[6], smac[6];
17874 u8 dmac_set = 0, smac_set = 0;
17880 /* Shut up coverity */
17881 memset (dmac, 0, sizeof (dmac));
17882 memset (smac, 0, sizeof (smac));
17884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17886 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17888 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17890 else if (unformat (i, "vtr_op %d", &vtr_op))
17892 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17895 else if (unformat (i, "translate_pbb_stag"))
17897 if (unformat (i, "%d", &tmp))
17899 vtr_op = L2_VTR_TRANSLATE_2_1;
17905 ("translate_pbb_stag operation requires outer tag definition");
17909 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17911 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17913 else if (unformat (i, "sid %d", &sid))
17915 else if (unformat (i, "vlanid %d", &tmp))
17919 clib_warning ("parse error '%U'", format_unformat_error, i);
17924 if ((sw_if_index == ~0) || (vtr_op == ~0))
17926 errmsg ("missing sw_if_index or vtr operation");
17929 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17930 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17933 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17937 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17938 mp->sw_if_index = ntohl (sw_if_index);
17939 mp->vtr_op = ntohl (vtr_op);
17940 mp->outer_tag = ntohs (outer_tag);
17941 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17942 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17943 mp->b_vlanid = ntohs (vlanid);
17944 mp->i_sid = ntohl (sid);
17952 api_flow_classify_set_interface (vat_main_t * vam)
17954 unformat_input_t *i = vam->input;
17955 vl_api_flow_classify_set_interface_t *mp;
17957 int sw_if_index_set;
17958 u32 ip4_table_index = ~0;
17959 u32 ip6_table_index = ~0;
17963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17965 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17966 sw_if_index_set = 1;
17967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17968 sw_if_index_set = 1;
17969 else if (unformat (i, "del"))
17971 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17973 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17977 clib_warning ("parse error '%U'", format_unformat_error, i);
17982 if (sw_if_index_set == 0)
17984 errmsg ("missing interface name or sw_if_index");
17988 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17990 mp->sw_if_index = ntohl (sw_if_index);
17991 mp->ip4_table_index = ntohl (ip4_table_index);
17992 mp->ip6_table_index = ntohl (ip6_table_index);
17993 mp->is_add = is_add;
18001 api_flow_classify_dump (vat_main_t * vam)
18003 unformat_input_t *i = vam->input;
18004 vl_api_flow_classify_dump_t *mp;
18005 vl_api_control_ping_t *mp_ping;
18006 u8 type = FLOW_CLASSIFY_N_TABLES;
18009 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
18013 errmsg ("classify table type must be specified");
18017 if (!vam->json_output)
18019 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18022 M (FLOW_CLASSIFY_DUMP, mp);
18027 /* Use a control ping for synchronization */
18028 M (CONTROL_PING, mp_ping);
18031 /* Wait for a reply... */
18037 api_feature_enable_disable (vat_main_t * vam)
18039 unformat_input_t *i = vam->input;
18040 vl_api_feature_enable_disable_t *mp;
18042 u8 *feature_name = 0;
18043 u32 sw_if_index = ~0;
18047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18049 if (unformat (i, "arc_name %s", &arc_name))
18051 else if (unformat (i, "feature_name %s", &feature_name))
18054 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18056 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18058 else if (unformat (i, "disable"))
18066 errmsg ("missing arc name");
18069 if (vec_len (arc_name) > 63)
18071 errmsg ("arc name too long");
18074 if (feature_name == 0)
18076 errmsg ("missing feature name");
18079 if (vec_len (feature_name) > 63)
18081 errmsg ("feature name too long");
18084 if (sw_if_index == ~0)
18086 errmsg ("missing interface name or sw_if_index");
18090 /* Construct the API message */
18091 M (FEATURE_ENABLE_DISABLE, mp);
18092 mp->sw_if_index = ntohl (sw_if_index);
18093 mp->enable = enable;
18094 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
18095 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
18096 vec_free (arc_name);
18097 vec_free (feature_name);
18105 api_sw_interface_tag_add_del (vat_main_t * vam)
18107 unformat_input_t *i = vam->input;
18108 vl_api_sw_interface_tag_add_del_t *mp;
18109 u32 sw_if_index = ~0;
18114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18116 if (unformat (i, "tag %s", &tag))
18118 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18120 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18122 else if (unformat (i, "del"))
18128 if (sw_if_index == ~0)
18130 errmsg ("missing interface name or sw_if_index");
18134 if (enable && (tag == 0))
18136 errmsg ("no tag specified");
18140 /* Construct the API message */
18141 M (SW_INTERFACE_TAG_ADD_DEL, mp);
18142 mp->sw_if_index = ntohl (sw_if_index);
18143 mp->is_add = enable;
18145 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
18153 static void vl_api_l2_xconnect_details_t_handler
18154 (vl_api_l2_xconnect_details_t * mp)
18156 vat_main_t *vam = &vat_main;
18158 print (vam->ofp, "%15d%15d",
18159 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
18162 static void vl_api_l2_xconnect_details_t_handler_json
18163 (vl_api_l2_xconnect_details_t * mp)
18165 vat_main_t *vam = &vat_main;
18166 vat_json_node_t *node = NULL;
18168 if (VAT_JSON_ARRAY != vam->json_tree.type)
18170 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18171 vat_json_init_array (&vam->json_tree);
18173 node = vat_json_array_add (&vam->json_tree);
18175 vat_json_init_object (node);
18176 vat_json_object_add_uint (node, "rx_sw_if_index",
18177 ntohl (mp->rx_sw_if_index));
18178 vat_json_object_add_uint (node, "tx_sw_if_index",
18179 ntohl (mp->tx_sw_if_index));
18183 api_l2_xconnect_dump (vat_main_t * vam)
18185 vl_api_l2_xconnect_dump_t *mp;
18186 vl_api_control_ping_t *mp_ping;
18189 if (!vam->json_output)
18191 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
18194 M (L2_XCONNECT_DUMP, mp);
18198 /* Use a control ping for synchronization */
18199 M (CONTROL_PING, mp_ping);
18207 api_sw_interface_set_mtu (vat_main_t * vam)
18209 unformat_input_t *i = vam->input;
18210 vl_api_sw_interface_set_mtu_t *mp;
18211 u32 sw_if_index = ~0;
18215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18217 if (unformat (i, "mtu %d", &mtu))
18219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18221 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18227 if (sw_if_index == ~0)
18229 errmsg ("missing interface name or sw_if_index");
18235 errmsg ("no mtu specified");
18239 /* Construct the API message */
18240 M (SW_INTERFACE_SET_MTU, mp);
18241 mp->sw_if_index = ntohl (sw_if_index);
18242 mp->mtu = ntohs ((u16) mtu);
18251 q_or_quit (vat_main_t * vam)
18253 #if VPP_API_TEST_BUILTIN == 0
18254 longjmp (vam->jump_buf, 1);
18256 return 0; /* not so much */
18260 q (vat_main_t * vam)
18262 return q_or_quit (vam);
18266 quit (vat_main_t * vam)
18268 return q_or_quit (vam);
18272 comment (vat_main_t * vam)
18278 cmd_cmp (void *a1, void *a2)
18283 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
18287 help (vat_main_t * vam)
18292 unformat_input_t *i = vam->input;
18295 if (unformat (i, "%s", &name))
18299 vec_add1 (name, 0);
18301 hs = hash_get_mem (vam->help_by_name, name);
18303 print (vam->ofp, "usage: %s %s", name, hs[0]);
18305 print (vam->ofp, "No such msg / command '%s'", name);
18310 print (vam->ofp, "Help is available for the following:");
18313 hash_foreach_pair (p, vam->function_by_name,
18315 vec_add1 (cmds, (u8 *)(p->key));
18319 vec_sort_with_function (cmds, cmd_cmp);
18321 for (j = 0; j < vec_len (cmds); j++)
18322 print (vam->ofp, "%s", cmds[j]);
18329 set (vat_main_t * vam)
18331 u8 *name = 0, *value = 0;
18332 unformat_input_t *i = vam->input;
18334 if (unformat (i, "%s", &name))
18336 /* The input buffer is a vector, not a string. */
18337 value = vec_dup (i->buffer);
18338 vec_delete (value, i->index, 0);
18339 /* Almost certainly has a trailing newline */
18340 if (value[vec_len (value) - 1] == '\n')
18341 value[vec_len (value) - 1] = 0;
18342 /* Make sure it's a proper string, one way or the other */
18343 vec_add1 (value, 0);
18344 (void) clib_macro_set_value (&vam->macro_main,
18345 (char *) name, (char *) value);
18348 errmsg ("usage: set <name> <value>");
18356 unset (vat_main_t * vam)
18360 if (unformat (vam->input, "%s", &name))
18361 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
18362 errmsg ("unset: %s wasn't set", name);
18375 macro_sort_cmp (void *a1, void *a2)
18377 macro_sort_t *s1 = a1;
18378 macro_sort_t *s2 = a2;
18380 return strcmp ((char *) (s1->name), (char *) (s2->name));
18384 dump_macro_table (vat_main_t * vam)
18386 macro_sort_t *sort_me = 0, *sm;
18391 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
18393 vec_add2 (sort_me, sm, 1);
18394 sm->name = (u8 *)(p->key);
18395 sm->value = (u8 *) (p->value[0]);
18399 vec_sort_with_function (sort_me, macro_sort_cmp);
18401 if (vec_len (sort_me))
18402 print (vam->ofp, "%-15s%s", "Name", "Value");
18404 print (vam->ofp, "The macro table is empty...");
18406 for (i = 0; i < vec_len (sort_me); i++)
18407 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
18412 dump_node_table (vat_main_t * vam)
18415 vlib_node_t *node, *next_node;
18417 if (vec_len (vam->graph_nodes) == 0)
18419 print (vam->ofp, "Node table empty, issue get_node_graph...");
18423 for (i = 0; i < vec_len (vam->graph_nodes); i++)
18425 node = vam->graph_nodes[i];
18426 print (vam->ofp, "[%d] %s", i, node->name);
18427 for (j = 0; j < vec_len (node->next_nodes); j++)
18429 if (node->next_nodes[j] != ~0)
18431 next_node = vam->graph_nodes[node->next_nodes[j]];
18432 print (vam->ofp, " [%d] %s", j, next_node->name);
18440 value_sort_cmp (void *a1, void *a2)
18442 name_sort_t *n1 = a1;
18443 name_sort_t *n2 = a2;
18445 if (n1->value < n2->value)
18447 if (n1->value > n2->value)
18454 dump_msg_api_table (vat_main_t * vam)
18456 api_main_t *am = &api_main;
18457 name_sort_t *nses = 0, *ns;
18462 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
18464 vec_add2 (nses, ns, 1);
18465 ns->name = (u8 *)(hp->key);
18466 ns->value = (u32) hp->value[0];
18470 vec_sort_with_function (nses, value_sort_cmp);
18472 for (i = 0; i < vec_len (nses); i++)
18473 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
18479 get_msg_id (vat_main_t * vam)
18484 if (unformat (vam->input, "%s", &name_and_crc))
18486 message_index = vl_api_get_msg_index (name_and_crc);
18487 if (message_index == ~0)
18489 print (vam->ofp, " '%s' not found", name_and_crc);
18492 print (vam->ofp, " '%s' has message index %d",
18493 name_and_crc, message_index);
18496 errmsg ("name_and_crc required...");
18501 search_node_table (vat_main_t * vam)
18503 unformat_input_t *line_input = vam->input;
18506 vlib_node_t *node, *next_node;
18509 if (vam->graph_node_index_by_name == 0)
18511 print (vam->ofp, "Node table empty, issue get_node_graph...");
18515 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
18517 if (unformat (line_input, "%s", &node_to_find))
18519 vec_add1 (node_to_find, 0);
18520 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
18523 print (vam->ofp, "%s not found...", node_to_find);
18526 node = vam->graph_nodes[p[0]];
18527 print (vam->ofp, "[%d] %s", p[0], node->name);
18528 for (j = 0; j < vec_len (node->next_nodes); j++)
18530 if (node->next_nodes[j] != ~0)
18532 next_node = vam->graph_nodes[node->next_nodes[j]];
18533 print (vam->ofp, " [%d] %s", j, next_node->name);
18540 clib_warning ("parse error '%U'", format_unformat_error,
18546 vec_free (node_to_find);
18555 script (vat_main_t * vam)
18557 #if (VPP_API_TEST_BUILTIN==0)
18559 char *save_current_file;
18560 unformat_input_t save_input;
18561 jmp_buf save_jump_buf;
18562 u32 save_line_number;
18564 FILE *new_fp, *save_ifp;
18566 if (unformat (vam->input, "%s", &s))
18568 new_fp = fopen ((char *) s, "r");
18571 errmsg ("Couldn't open script file %s", s);
18578 errmsg ("Missing script name");
18582 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
18583 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
18584 save_ifp = vam->ifp;
18585 save_line_number = vam->input_line_number;
18586 save_current_file = (char *) vam->current_file;
18588 vam->input_line_number = 0;
18590 vam->current_file = s;
18593 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
18594 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
18595 vam->ifp = save_ifp;
18596 vam->input_line_number = save_line_number;
18597 vam->current_file = (u8 *) save_current_file;
18602 clib_warning ("use the exec command...");
18608 echo (vat_main_t * vam)
18610 print (vam->ofp, "%v", vam->input->buffer);
18614 /* List of API message constructors, CLI names map to api_xxx */
18615 #define foreach_vpe_api_msg \
18616 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
18617 _(sw_interface_dump,"") \
18618 _(sw_interface_set_flags, \
18619 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
18620 _(sw_interface_add_del_address, \
18621 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
18622 _(sw_interface_set_table, \
18623 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
18624 _(sw_interface_set_mpls_enable, \
18625 "<intfc> | sw_if_index [disable | dis]") \
18626 _(sw_interface_set_vpath, \
18627 "<intfc> | sw_if_index <id> enable | disable") \
18628 _(sw_interface_set_vxlan_bypass, \
18629 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
18630 _(sw_interface_set_l2_xconnect, \
18631 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18632 "enable | disable") \
18633 _(sw_interface_set_l2_bridge, \
18634 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
18635 "[shg <split-horizon-group>] [bvi]\n" \
18636 "enable | disable") \
18637 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
18638 _(bridge_domain_add_del, \
18639 "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") \
18640 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
18642 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
18643 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
18644 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
18646 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
18648 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
18650 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
18652 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
18654 "<vpp-if-name> | sw_if_index <id>") \
18655 _(sw_interface_tap_dump, "") \
18656 _(ip_add_del_route, \
18657 "<addr>/<mask> via <addr> [table-id <n>]\n" \
18658 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18659 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18660 "[multipath] [count <n>]") \
18661 _(ip_mroute_add_del, \
18662 "<src> <grp>/<mask> [table-id <n>]\n" \
18663 "[<intfc> | sw_if_index <id>] [local] [del]") \
18664 _(mpls_route_add_del, \
18665 "<label> <eos> via <addr> [table-id <n>]\n" \
18666 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18667 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18668 "[multipath] [count <n>]") \
18669 _(mpls_ip_bind_unbind, \
18670 "<label> <addr/len>") \
18671 _(mpls_tunnel_add_del, \
18672 " via <addr> [table-id <n>]\n" \
18673 "sw_if_index <id>] [l2] [del]") \
18674 _(proxy_arp_add_del, \
18675 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
18676 _(proxy_arp_intfc_enable_disable, \
18677 "<intfc> | sw_if_index <id> enable | disable") \
18678 _(sw_interface_set_unnumbered, \
18679 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
18680 _(ip_neighbor_add_del, \
18681 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
18682 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
18683 _(reset_vrf, "vrf <id> [ipv6]") \
18684 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
18685 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
18686 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
18687 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
18688 "[outer_vlan_id_any][inner_vlan_id_any]") \
18689 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
18690 _(reset_fib, "vrf <n> [ipv6]") \
18691 _(dhcp_proxy_config, \
18692 "svr <v46-address> src <v46-address>\n" \
18693 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
18694 _(dhcp_proxy_set_vss, \
18695 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
18696 _(dhcp_proxy_dump, "ip6") \
18697 _(dhcp_client_config, \
18698 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
18699 _(set_ip_flow_hash, \
18700 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
18701 _(sw_interface_ip6_enable_disable, \
18702 "<intfc> | sw_if_index <id> enable | disable") \
18703 _(sw_interface_ip6_set_link_local_address, \
18704 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
18705 _(ip6nd_proxy_add_del, \
18706 "<intfc> | sw_if_index <id> <ip6-address>") \
18707 _(ip6nd_proxy_dump, "") \
18708 _(sw_interface_ip6nd_ra_prefix, \
18709 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
18710 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
18711 "[nolink] [isno]") \
18712 _(sw_interface_ip6nd_ra_config, \
18713 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
18714 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
18715 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
18716 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
18717 _(l2_patch_add_del, \
18718 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18719 "enable | disable") \
18720 _(sr_localsid_add_del, \
18721 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
18722 "fib-table <num> (end.psp) sw_if_index <num>") \
18723 _(classify_add_del_table, \
18724 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
18725 " [del] [del-chain] mask <mask-value>\n" \
18726 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
18727 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
18728 _(classify_add_del_session, \
18729 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
18730 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
18731 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
18732 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
18733 _(classify_set_interface_ip_table, \
18734 "<intfc> | sw_if_index <nn> table <nn>") \
18735 _(classify_set_interface_l2_tables, \
18736 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18737 " [other-table <nn>]") \
18738 _(get_node_index, "node <node-name") \
18739 _(add_node_next, "node <node-name> next <next-node-name>") \
18740 _(l2tpv3_create_tunnel, \
18741 "client_address <ip6-addr> our_address <ip6-addr>\n" \
18742 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
18743 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
18744 _(l2tpv3_set_tunnel_cookies, \
18745 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
18746 "[new_remote_cookie <nn>]\n") \
18747 _(l2tpv3_interface_enable_disable, \
18748 "<intfc> | sw_if_index <nn> enable | disable") \
18749 _(l2tpv3_set_lookup_key, \
18750 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18751 _(sw_if_l2tpv3_tunnel_dump, "") \
18752 _(vxlan_add_del_tunnel, \
18753 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18754 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18755 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18756 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18757 _(gre_add_del_tunnel, \
18758 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18759 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18760 _(l2_fib_clear_table, "") \
18761 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18762 _(l2_interface_vlan_tag_rewrite, \
18763 "<intfc> | sw_if_index <nn> \n" \
18764 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18765 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18766 _(create_vhost_user_if, \
18767 "socket <filename> [server] [renumber <dev_instance>] " \
18768 "[mac <mac_address>] " \
18769 "[mode <interrupt | polling>]") \
18770 _(modify_vhost_user_if, \
18771 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18772 "[server] [renumber <dev_instance>] " \
18773 "[mode <interrupt | polling>]") \
18774 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18775 _(sw_interface_vhost_user_dump, "") \
18776 _(show_version, "") \
18777 _(vxlan_gpe_add_del_tunnel, \
18778 "local <addr> remote <addr> vni <nn>\n" \
18779 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18780 "[next-ethernet] [next-nsh]\n") \
18781 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18782 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18783 _(interface_name_renumber, \
18784 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18785 _(input_acl_set_interface, \
18786 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18787 " [l2-table <nn>] [del]") \
18788 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18789 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18790 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18791 _(ip_dump, "ipv4 | ipv6") \
18792 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18793 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18795 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18796 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18797 " integ_alg <alg> integ_key <hex>") \
18798 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18799 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18800 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18801 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18802 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18803 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18804 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18805 "(auth_data 0x<data> | auth_data <data>)") \
18806 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18807 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18808 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18809 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18810 "(local|remote)") \
18811 _(ikev2_set_local_key, "file <absolute_file_path>") \
18812 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
18813 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18814 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18815 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
18816 _(ikev2_initiate_sa_init, "<profile_name>") \
18817 _(ikev2_initiate_del_ike_sa, "<ispi>") \
18818 _(ikev2_initiate_del_child_sa, "<ispi>") \
18819 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
18820 _(delete_loopback,"sw_if_index <nn>") \
18821 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18822 _(map_add_domain, \
18823 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18824 "ip6-src <ip6addr> " \
18825 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18826 _(map_del_domain, "index <n>") \
18827 _(map_add_del_rule, \
18828 "index <n> psid <n> dst <ip6addr> [del]") \
18829 _(map_domain_dump, "") \
18830 _(map_rule_dump, "index <map-domain>") \
18831 _(want_interface_events, "enable|disable") \
18832 _(want_stats,"enable|disable") \
18833 _(get_first_msg_id, "client <name>") \
18834 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18835 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18836 "fib-id <nn> [ip4][ip6][default]") \
18837 _(get_node_graph, " ") \
18838 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18839 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18840 _(ioam_disable, "") \
18841 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18842 " sw_if_index <sw_if_index> p <priority> " \
18843 "w <weight>] [del]") \
18844 _(one_add_del_locator, "locator-set <locator_name> " \
18845 "iface <intf> | sw_if_index <sw_if_index> " \
18846 "p <priority> w <weight> [del]") \
18847 _(one_add_del_local_eid,"vni <vni> eid " \
18848 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18849 "locator-set <locator_name> [del]" \
18850 "[key-id sha1|sha256 secret-key <secret-key>]")\
18851 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
18852 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
18853 _(one_enable_disable, "enable|disable") \
18854 _(one_map_register_enable_disable, "enable|disable") \
18855 _(one_rloc_probe_enable_disable, "enable|disable") \
18856 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18858 "rloc <locator> p <prio> " \
18859 "w <weight> [rloc <loc> ... ] " \
18860 "action <action> [del-all]") \
18861 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18863 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18864 _(one_use_petr, "ip-address> | disable") \
18865 _(one_map_request_mode, "src-dst|dst-only") \
18866 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18867 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18868 _(one_locator_set_dump, "[local | remote]") \
18869 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
18870 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18871 "[local] | [remote]") \
18872 _(one_stats_enable_disable, "enable|disalbe") \
18873 _(show_one_stats_enable_disable, "") \
18874 _(one_eid_table_vni_dump, "") \
18875 _(one_eid_table_map_dump, "l2|l3") \
18876 _(one_map_resolver_dump, "") \
18877 _(one_map_server_dump, "") \
18878 _(one_adjacencies_get, "vni <vni>") \
18879 _(show_one_rloc_probe_state, "") \
18880 _(show_one_map_register_state, "") \
18881 _(show_one_status, "") \
18882 _(one_stats_dump, "") \
18883 _(one_get_map_request_itr_rlocs, "") \
18884 _(show_one_pitr, "") \
18885 _(show_one_use_petr, "") \
18886 _(show_one_map_request_mode, "") \
18887 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
18888 " sw_if_index <sw_if_index> p <priority> " \
18889 "w <weight>] [del]") \
18890 _(lisp_add_del_locator, "locator-set <locator_name> " \
18891 "iface <intf> | sw_if_index <sw_if_index> " \
18892 "p <priority> w <weight> [del]") \
18893 _(lisp_add_del_local_eid,"vni <vni> eid " \
18894 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18895 "locator-set <locator_name> [del]" \
18896 "[key-id sha1|sha256 secret-key <secret-key>]") \
18897 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18898 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18899 _(lisp_enable_disable, "enable|disable") \
18900 _(lisp_map_register_enable_disable, "enable|disable") \
18901 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18902 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18904 "rloc <locator> p <prio> " \
18905 "w <weight> [rloc <loc> ... ] " \
18906 "action <action> [del-all]") \
18907 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18909 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18910 _(lisp_use_petr, "<ip-address> | disable") \
18911 _(lisp_map_request_mode, "src-dst|dst-only") \
18912 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18913 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18914 _(lisp_locator_set_dump, "[local | remote]") \
18915 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18916 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18917 "[local] | [remote]") \
18918 _(lisp_eid_table_vni_dump, "") \
18919 _(lisp_eid_table_map_dump, "l2|l3") \
18920 _(lisp_map_resolver_dump, "") \
18921 _(lisp_map_server_dump, "") \
18922 _(lisp_adjacencies_get, "vni <vni>") \
18923 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18924 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18925 _(gpe_set_encap_mode, "lisp|vxlan") \
18926 _(gpe_get_encap_mode, "") \
18927 _(lisp_gpe_add_del_iface, "up|down") \
18928 _(lisp_gpe_enable_disable, "enable|disable") \
18929 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18930 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18931 _(show_lisp_rloc_probe_state, "") \
18932 _(show_lisp_map_register_state, "") \
18933 _(show_lisp_status, "") \
18934 _(lisp_get_map_request_itr_rlocs, "") \
18935 _(show_lisp_pitr, "") \
18936 _(show_lisp_use_petr, "") \
18937 _(show_lisp_map_request_mode, "") \
18938 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18939 _(af_packet_delete, "name <host interface name>") \
18940 _(policer_add_del, "name <policer name> <params> [del]") \
18941 _(policer_dump, "[name <policer name>]") \
18942 _(policer_classify_set_interface, \
18943 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18944 " [l2-table <nn>] [del]") \
18945 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18946 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18947 "[master|slave]") \
18948 _(netmap_delete, "name <interface name>") \
18949 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18950 _(mpls_fib_dump, "") \
18951 _(classify_table_ids, "") \
18952 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18953 _(classify_table_info, "table_id <nn>") \
18954 _(classify_session_dump, "table_id <nn>") \
18955 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18956 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18957 "[template_interval <nn>] [udp_checksum]") \
18958 _(ipfix_exporter_dump, "") \
18959 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18960 _(ipfix_classify_stream_dump, "") \
18961 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18962 _(ipfix_classify_table_dump, "") \
18963 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18964 _(sw_interface_span_dump, "") \
18965 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18966 _(pg_create_interface, "if_id <nn>") \
18967 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18968 _(pg_enable_disable, "[stream <id>] disable") \
18969 _(ip_source_and_port_range_check_add_del, \
18970 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18971 _(ip_source_and_port_range_check_interface_add_del, \
18972 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18973 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18974 _(ipsec_gre_add_del_tunnel, \
18975 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18976 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18977 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18978 _(l2_interface_pbb_tag_rewrite, \
18979 "<intfc> | sw_if_index <nn> \n" \
18980 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18981 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18982 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18983 _(flow_classify_set_interface, \
18984 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18985 _(flow_classify_dump, "type [ip4|ip6]") \
18986 _(ip_fib_dump, "") \
18987 _(ip_mfib_dump, "") \
18988 _(ip6_fib_dump, "") \
18989 _(ip6_mfib_dump, "") \
18990 _(feature_enable_disable, "arc_name <arc_name> " \
18991 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18992 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18994 _(l2_xconnect_dump, "") \
18995 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18996 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18997 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18999 /* List of command functions, CLI names map directly to functions */
19000 #define foreach_cli_function \
19001 _(comment, "usage: comment <ignore-rest-of-line>") \
19002 _(dump_interface_table, "usage: dump_interface_table") \
19003 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
19004 _(dump_ipv4_table, "usage: dump_ipv4_table") \
19005 _(dump_ipv6_table, "usage: dump_ipv6_table") \
19006 _(dump_stats_table, "usage: dump_stats_table") \
19007 _(dump_macro_table, "usage: dump_macro_table ") \
19008 _(dump_node_table, "usage: dump_node_table") \
19009 _(dump_msg_api_table, "usage: dump_msg_api_table") \
19010 _(get_msg_id, "usage: get_msg_id name_and_crc") \
19011 _(echo, "usage: echo <message>") \
19012 _(exec, "usage: exec <vpe-debug-CLI-command>") \
19013 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
19014 _(help, "usage: help") \
19015 _(q, "usage: quit") \
19016 _(quit, "usage: quit") \
19017 _(search_node_table, "usage: search_node_table <name>...") \
19018 _(set, "usage: set <variable-name> <value>") \
19019 _(script, "usage: script <file-name>") \
19020 _(unset, "usage: unset <variable-name>")
19023 static void vl_api_##n##_t_handler_uni \
19024 (vl_api_##n##_t * mp) \
19026 vat_main_t * vam = &vat_main; \
19027 if (vam->json_output) { \
19028 vl_api_##n##_t_handler_json(mp); \
19030 vl_api_##n##_t_handler(mp); \
19033 foreach_vpe_api_reply_msg;
19034 #if VPP_API_TEST_BUILTIN == 0
19035 foreach_standalone_reply_msg;
19040 vat_api_hookup (vat_main_t * vam)
19043 vl_msg_api_set_handlers(VL_API_##N, #n, \
19044 vl_api_##n##_t_handler_uni, \
19046 vl_api_##n##_t_endian, \
19047 vl_api_##n##_t_print, \
19048 sizeof(vl_api_##n##_t), 1);
19049 foreach_vpe_api_reply_msg;
19050 #if VPP_API_TEST_BUILTIN == 0
19051 foreach_standalone_reply_msg;
19055 #if (VPP_API_TEST_BUILTIN==0)
19056 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
19058 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
19060 vam->function_by_name = hash_create_string (0, sizeof (uword));
19062 vam->help_by_name = hash_create_string (0, sizeof (uword));
19065 /* API messages we can send */
19066 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
19067 foreach_vpe_api_msg;
19071 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
19072 foreach_vpe_api_msg;
19075 /* CLI functions */
19076 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
19077 foreach_cli_function;
19081 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
19082 foreach_cli_function;
19086 #if VPP_API_TEST_BUILTIN
19087 static clib_error_t *
19088 vat_api_hookup_shim (vlib_main_t * vm)
19090 vat_api_hookup (&vat_main);
19094 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
19098 * fd.io coding-style-patch-verification: ON
19101 * eval: (c-set-style "gnu")