2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vppinfra/socket.h>
22 #include <svm/memfd.h>
23 #include <vlibapi/api.h>
24 #include <vlibmemory/api.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/geneve/geneve.h>
30 #include <vnet/gre/gre.h>
31 #include <vnet/vxlan-gpe/vxlan_gpe.h>
32 #include <vnet/lisp-gpe/lisp_gpe.h>
34 #include <vpp/api/vpe_msg_enum.h>
35 #include <vnet/l2/l2_classify.h>
36 #include <vnet/l2/l2_vtr.h>
37 #include <vnet/classify/input_acl.h>
38 #include <vnet/classify/policer_classify.h>
39 #include <vnet/classify/flow_classify.h>
40 #include <vnet/mpls/mpls.h>
41 #include <vnet/ipsec/ipsec.h>
42 #include <vnet/ipsec/ikev2.h>
44 #include <vnet/map/map.h>
45 #include <vnet/cop/cop.h>
46 #include <vnet/ip/ip6_hop_by_hop.h>
47 #include <vnet/ip/ip_source_and_port_range_check.h>
48 #include <vnet/policer/xlate.h>
49 #include <vnet/span/span.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
52 #include <vnet/mfib/mfib_types.h>
54 #include "vat/json_format.h"
59 #define vl_typedefs /* define message structures */
60 #include <vpp/api/vpe_all_api_h.h>
63 /* declare message handlers for each api */
65 #define vl_endianfun /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* instantiate all the print functions we know about */
70 #define vl_print(handle, ...)
72 #include <vpp/api/vpe_all_api_h.h>
75 #define __plugin_msg_base 0
76 #include <vlibapi/vat_helper_macros.h>
78 #if VPP_API_TEST_BUILTIN == 0
88 vat_socket_connect (vat_main_t * vam)
90 return vl_socket_client_connect
91 (&vam->socket_client_main, (char *) vam->socket_name,
92 "vpp_api_test(s)", 0 /* default socket rx, tx buffer */ );
94 #else /* vpp built-in case, we don't do sockets... */
96 vat_socket_connect (vat_main_t * vam)
102 vl_socket_client_read_reply (socket_client_main_t * scm)
109 vat_time_now (vat_main_t * vam)
111 #if VPP_API_TEST_BUILTIN
112 return vlib_time_now (vam->vlib_main);
114 return clib_time_now (&vam->clib_time);
119 errmsg (char *fmt, ...)
121 vat_main_t *vam = &vat_main;
126 s = va_format (0, fmt, &va);
131 #if VPP_API_TEST_BUILTIN
132 vlib_cli_output (vam->vlib_main, (char *) s);
135 if (vam->ifp != stdin)
136 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
137 vam->input_line_number);
138 fformat (vam->ofp, (char *) s);
146 #if VPP_API_TEST_BUILTIN == 0
148 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
150 vat_main_t *vam = va_arg (*args, vat_main_t *);
151 u32 *result = va_arg (*args, u32 *);
155 if (!unformat (input, "%s", &if_name))
158 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
165 /* Parse an IP4 address %d.%d.%d.%d. */
167 unformat_ip4_address (unformat_input_t * input, va_list * args)
169 u8 *result = va_arg (*args, u8 *);
172 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
175 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
187 unformat_ethernet_address (unformat_input_t * input, va_list * args)
189 u8 *result = va_arg (*args, u8 *);
192 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
193 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
197 for (i = 0; i < 6; i++)
198 if (a[i] >= (1 << 8))
201 for (i = 0; i < 6; i++)
207 /* Returns ethernet type as an int in host byte order. */
209 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
212 u16 *result = va_arg (*args, u16 *);
216 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
218 if (type >= (1 << 16))
226 /* Parse an IP6 address. */
228 unformat_ip6_address (unformat_input_t * input, va_list * args)
230 ip6_address_t *result = va_arg (*args, ip6_address_t *);
232 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
233 uword c, n_colon, double_colon_index;
235 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
236 double_colon_index = ARRAY_LEN (hex_quads);
237 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
240 if (c >= '0' && c <= '9')
242 else if (c >= 'a' && c <= 'f')
243 hex_digit = c + 10 - 'a';
244 else if (c >= 'A' && c <= 'F')
245 hex_digit = c + 10 - 'A';
246 else if (c == ':' && n_colon < 2)
250 unformat_put_input (input);
254 /* Too many hex quads. */
255 if (n_hex_quads >= ARRAY_LEN (hex_quads))
260 hex_quad = (hex_quad << 4) | hex_digit;
262 /* Hex quad must fit in 16 bits. */
263 if (n_hex_digits >= 4)
270 /* Save position of :: */
273 /* More than one :: ? */
274 if (double_colon_index < ARRAY_LEN (hex_quads))
276 double_colon_index = n_hex_quads;
279 if (n_colon > 0 && n_hex_digits > 0)
281 hex_quads[n_hex_quads++] = hex_quad;
287 if (n_hex_digits > 0)
288 hex_quads[n_hex_quads++] = hex_quad;
293 /* Expand :: to appropriate number of zero hex quads. */
294 if (double_colon_index < ARRAY_LEN (hex_quads))
296 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
298 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
299 hex_quads[n_zero + i] = hex_quads[i];
301 for (i = 0; i < n_zero; i++)
302 hex_quads[double_colon_index + i] = 0;
304 n_hex_quads = ARRAY_LEN (hex_quads);
307 /* Too few hex quads given. */
308 if (n_hex_quads < ARRAY_LEN (hex_quads))
311 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
312 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
319 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
321 u32 *r = va_arg (*args, u32 *);
324 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
325 foreach_ipsec_policy_action
333 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
335 u32 *r = va_arg (*args, u32 *);
338 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
339 foreach_ipsec_crypto_alg
347 format_ipsec_crypto_alg (u8 * s, va_list * args)
349 u32 i = va_arg (*args, u32);
354 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
355 foreach_ipsec_crypto_alg
358 return format (s, "unknown");
360 return format (s, "%s", t);
364 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
366 u32 *r = va_arg (*args, u32 *);
369 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
370 foreach_ipsec_integ_alg
378 format_ipsec_integ_alg (u8 * s, va_list * args)
380 u32 i = va_arg (*args, u32);
385 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
386 foreach_ipsec_integ_alg
389 return format (s, "unknown");
391 return format (s, "%s", t);
395 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
397 u32 *r = va_arg (*args, u32 *);
400 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
401 foreach_ikev2_auth_method
409 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
411 u32 *r = va_arg (*args, u32 *);
414 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
415 foreach_ikev2_id_type
421 #else /* VPP_API_TEST_BUILTIN == 1 */
423 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
425 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
426 vnet_main_t *vnm = vnet_get_main ();
427 u32 *result = va_arg (*args, u32 *);
430 if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
433 *result = sw_if_index;
436 #endif /* VPP_API_TEST_BUILTIN */
439 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
441 u8 *r = va_arg (*args, u8 *);
443 if (unformat (input, "kbps"))
444 *r = SSE2_QOS_RATE_KBPS;
445 else if (unformat (input, "pps"))
446 *r = SSE2_QOS_RATE_PPS;
453 unformat_policer_round_type (unformat_input_t * input, va_list * args)
455 u8 *r = va_arg (*args, u8 *);
457 if (unformat (input, "closest"))
458 *r = SSE2_QOS_ROUND_TO_CLOSEST;
459 else if (unformat (input, "up"))
460 *r = SSE2_QOS_ROUND_TO_UP;
461 else if (unformat (input, "down"))
462 *r = SSE2_QOS_ROUND_TO_DOWN;
469 unformat_policer_type (unformat_input_t * input, va_list * args)
471 u8 *r = va_arg (*args, u8 *);
473 if (unformat (input, "1r2c"))
474 *r = SSE2_QOS_POLICER_TYPE_1R2C;
475 else if (unformat (input, "1r3c"))
476 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
477 else if (unformat (input, "2r3c-2698"))
478 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
479 else if (unformat (input, "2r3c-4115"))
480 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
481 else if (unformat (input, "2r3c-mef5cf1"))
482 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
489 unformat_dscp (unformat_input_t * input, va_list * va)
491 u8 *r = va_arg (*va, u8 *);
494 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
503 unformat_policer_action_type (unformat_input_t * input, va_list * va)
505 sse2_qos_pol_action_params_st *a
506 = va_arg (*va, sse2_qos_pol_action_params_st *);
508 if (unformat (input, "drop"))
509 a->action_type = SSE2_QOS_ACTION_DROP;
510 else if (unformat (input, "transmit"))
511 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
512 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
513 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
520 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
522 u32 *r = va_arg (*va, u32 *);
525 if (unformat (input, "ip4"))
526 tid = POLICER_CLASSIFY_TABLE_IP4;
527 else if (unformat (input, "ip6"))
528 tid = POLICER_CLASSIFY_TABLE_IP6;
529 else if (unformat (input, "l2"))
530 tid = POLICER_CLASSIFY_TABLE_L2;
539 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
541 u32 *r = va_arg (*va, u32 *);
544 if (unformat (input, "ip4"))
545 tid = FLOW_CLASSIFY_TABLE_IP4;
546 else if (unformat (input, "ip6"))
547 tid = FLOW_CLASSIFY_TABLE_IP6;
555 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
556 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
557 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
558 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
560 #if (VPP_API_TEST_BUILTIN==0)
562 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
564 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
565 mfib_itf_attribute_t attr;
568 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
570 if (unformat (input, mfib_itf_flag_long_names[attr]))
571 *iflags |= (1 << attr);
573 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
575 if (unformat (input, mfib_itf_flag_names[attr]))
576 *iflags |= (1 << attr);
579 return (old == *iflags ? 0 : 1);
583 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
585 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
586 mfib_entry_attribute_t attr;
589 FOR_EACH_MFIB_ATTRIBUTE (attr)
591 if (unformat (input, mfib_flag_long_names[attr]))
592 *eflags |= (1 << attr);
594 FOR_EACH_MFIB_ATTRIBUTE (attr)
596 if (unformat (input, mfib_flag_names[attr]))
597 *eflags |= (1 << attr);
600 return (old == *eflags ? 0 : 1);
604 format_ip4_address (u8 * s, va_list * args)
606 u8 *a = va_arg (*args, u8 *);
607 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
611 format_ip6_address (u8 * s, va_list * args)
613 ip6_address_t *a = va_arg (*args, ip6_address_t *);
614 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
616 i_max_n_zero = ARRAY_LEN (a->as_u16);
618 i_first_zero = i_max_n_zero;
620 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
622 u32 is_zero = a->as_u16[i] == 0;
623 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
629 if ((!is_zero && n_zeros > max_n_zeros)
630 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
632 i_max_n_zero = i_first_zero;
633 max_n_zeros = n_zeros;
634 i_first_zero = ARRAY_LEN (a->as_u16);
639 last_double_colon = 0;
640 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
642 if (i == i_max_n_zero && max_n_zeros > 1)
644 s = format (s, "::");
645 i += max_n_zeros - 1;
646 last_double_colon = 1;
650 s = format (s, "%s%x",
651 (last_double_colon || i == 0) ? "" : ":",
652 clib_net_to_host_u16 (a->as_u16[i]));
653 last_double_colon = 0;
660 /* Format an IP46 address. */
662 format_ip46_address (u8 * s, va_list * args)
664 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
665 ip46_type_t type = va_arg (*args, ip46_type_t);
671 is_ip4 = ip46_address_is_ip4 (ip46);
682 format (s, "%U", format_ip4_address, &ip46->ip4) :
683 format (s, "%U", format_ip6_address, &ip46->ip6);
687 format_ethernet_address (u8 * s, va_list * args)
689 u8 *a = va_arg (*args, u8 *);
691 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
692 a[0], a[1], a[2], a[3], a[4], a[5]);
697 increment_v4_address (ip4_address_t * a)
701 v = ntohl (a->as_u32) + 1;
702 a->as_u32 = ntohl (v);
706 increment_v6_address (ip6_address_t * a)
710 v0 = clib_net_to_host_u64 (a->as_u64[0]);
711 v1 = clib_net_to_host_u64 (a->as_u64[1]);
716 a->as_u64[0] = clib_net_to_host_u64 (v0);
717 a->as_u64[1] = clib_net_to_host_u64 (v1);
721 increment_mac_address (u8 * mac)
723 u64 tmp = *((u64 *) mac);
724 tmp = clib_net_to_host_u64 (tmp);
725 tmp += 1 << 16; /* skip unused (least significant) octets */
726 tmp = clib_host_to_net_u64 (tmp);
728 clib_memcpy (mac, &tmp, 6);
731 static void vl_api_create_loopback_reply_t_handler
732 (vl_api_create_loopback_reply_t * mp)
734 vat_main_t *vam = &vat_main;
735 i32 retval = ntohl (mp->retval);
737 vam->retval = retval;
738 vam->regenerate_interface_table = 1;
739 vam->sw_if_index = ntohl (mp->sw_if_index);
740 vam->result_ready = 1;
743 static void vl_api_create_loopback_reply_t_handler_json
744 (vl_api_create_loopback_reply_t * mp)
746 vat_main_t *vam = &vat_main;
747 vat_json_node_t node;
749 vat_json_init_object (&node);
750 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
751 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
753 vat_json_print (vam->ofp, &node);
754 vat_json_free (&node);
755 vam->retval = ntohl (mp->retval);
756 vam->result_ready = 1;
759 static void vl_api_create_loopback_instance_reply_t_handler
760 (vl_api_create_loopback_instance_reply_t * mp)
762 vat_main_t *vam = &vat_main;
763 i32 retval = ntohl (mp->retval);
765 vam->retval = retval;
766 vam->regenerate_interface_table = 1;
767 vam->sw_if_index = ntohl (mp->sw_if_index);
768 vam->result_ready = 1;
771 static void vl_api_create_loopback_instance_reply_t_handler_json
772 (vl_api_create_loopback_instance_reply_t * mp)
774 vat_main_t *vam = &vat_main;
775 vat_json_node_t node;
777 vat_json_init_object (&node);
778 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
779 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
781 vat_json_print (vam->ofp, &node);
782 vat_json_free (&node);
783 vam->retval = ntohl (mp->retval);
784 vam->result_ready = 1;
787 static void vl_api_af_packet_create_reply_t_handler
788 (vl_api_af_packet_create_reply_t * mp)
790 vat_main_t *vam = &vat_main;
791 i32 retval = ntohl (mp->retval);
793 vam->retval = retval;
794 vam->regenerate_interface_table = 1;
795 vam->sw_if_index = ntohl (mp->sw_if_index);
796 vam->result_ready = 1;
799 static void vl_api_af_packet_create_reply_t_handler_json
800 (vl_api_af_packet_create_reply_t * mp)
802 vat_main_t *vam = &vat_main;
803 vat_json_node_t node;
805 vat_json_init_object (&node);
806 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
807 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
809 vat_json_print (vam->ofp, &node);
810 vat_json_free (&node);
812 vam->retval = ntohl (mp->retval);
813 vam->result_ready = 1;
816 static void vl_api_create_vlan_subif_reply_t_handler
817 (vl_api_create_vlan_subif_reply_t * mp)
819 vat_main_t *vam = &vat_main;
820 i32 retval = ntohl (mp->retval);
822 vam->retval = retval;
823 vam->regenerate_interface_table = 1;
824 vam->sw_if_index = ntohl (mp->sw_if_index);
825 vam->result_ready = 1;
828 static void vl_api_create_vlan_subif_reply_t_handler_json
829 (vl_api_create_vlan_subif_reply_t * mp)
831 vat_main_t *vam = &vat_main;
832 vat_json_node_t node;
834 vat_json_init_object (&node);
835 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
836 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
838 vat_json_print (vam->ofp, &node);
839 vat_json_free (&node);
841 vam->retval = ntohl (mp->retval);
842 vam->result_ready = 1;
845 static void vl_api_create_subif_reply_t_handler
846 (vl_api_create_subif_reply_t * mp)
848 vat_main_t *vam = &vat_main;
849 i32 retval = ntohl (mp->retval);
851 vam->retval = retval;
852 vam->regenerate_interface_table = 1;
853 vam->sw_if_index = ntohl (mp->sw_if_index);
854 vam->result_ready = 1;
857 static void vl_api_create_subif_reply_t_handler_json
858 (vl_api_create_subif_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 vat_json_node_t node;
863 vat_json_init_object (&node);
864 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
865 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
867 vat_json_print (vam->ofp, &node);
868 vat_json_free (&node);
870 vam->retval = ntohl (mp->retval);
871 vam->result_ready = 1;
874 static void vl_api_interface_name_renumber_reply_t_handler
875 (vl_api_interface_name_renumber_reply_t * mp)
877 vat_main_t *vam = &vat_main;
878 i32 retval = ntohl (mp->retval);
880 vam->retval = retval;
881 vam->regenerate_interface_table = 1;
882 vam->result_ready = 1;
885 static void vl_api_interface_name_renumber_reply_t_handler_json
886 (vl_api_interface_name_renumber_reply_t * mp)
888 vat_main_t *vam = &vat_main;
889 vat_json_node_t node;
891 vat_json_init_object (&node);
892 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
894 vat_json_print (vam->ofp, &node);
895 vat_json_free (&node);
897 vam->retval = ntohl (mp->retval);
898 vam->result_ready = 1;
902 * Special-case: build the interface table, maintain
903 * the next loopback sw_if_index vbl.
905 static void vl_api_sw_interface_details_t_handler
906 (vl_api_sw_interface_details_t * mp)
908 vat_main_t *vam = &vat_main;
909 u8 *s = format (0, "%s%c", mp->interface_name, 0);
911 hash_set_mem (vam->sw_if_index_by_interface_name, s,
912 ntohl (mp->sw_if_index));
914 /* In sub interface case, fill the sub interface table entry */
915 if (mp->sw_if_index != mp->sup_sw_if_index)
917 sw_interface_subif_t *sub = NULL;
919 vec_add2 (vam->sw_if_subif_table, sub, 1);
921 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
922 strncpy ((char *) sub->interface_name, (char *) s,
923 vec_len (sub->interface_name));
924 sub->sw_if_index = ntohl (mp->sw_if_index);
925 sub->sub_id = ntohl (mp->sub_id);
927 sub->sub_dot1ad = mp->sub_dot1ad;
928 sub->sub_number_of_tags = mp->sub_number_of_tags;
929 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
930 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
931 sub->sub_exact_match = mp->sub_exact_match;
932 sub->sub_default = mp->sub_default;
933 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
934 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
936 /* vlan tag rewrite */
937 sub->vtr_op = ntohl (mp->vtr_op);
938 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
939 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
940 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
944 static void vl_api_sw_interface_details_t_handler_json
945 (vl_api_sw_interface_details_t * mp)
947 vat_main_t *vam = &vat_main;
948 vat_json_node_t *node = NULL;
950 if (VAT_JSON_ARRAY != vam->json_tree.type)
952 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
953 vat_json_init_array (&vam->json_tree);
955 node = vat_json_array_add (&vam->json_tree);
957 vat_json_init_object (node);
958 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
959 vat_json_object_add_uint (node, "sup_sw_if_index",
960 ntohl (mp->sup_sw_if_index));
961 vat_json_object_add_uint (node, "l2_address_length",
962 ntohl (mp->l2_address_length));
963 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
964 sizeof (mp->l2_address));
965 vat_json_object_add_string_copy (node, "interface_name",
967 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
968 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
969 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
970 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
971 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
972 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
973 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
974 vat_json_object_add_uint (node, "sub_number_of_tags",
975 mp->sub_number_of_tags);
976 vat_json_object_add_uint (node, "sub_outer_vlan_id",
977 ntohs (mp->sub_outer_vlan_id));
978 vat_json_object_add_uint (node, "sub_inner_vlan_id",
979 ntohs (mp->sub_inner_vlan_id));
980 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
981 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
982 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
983 mp->sub_outer_vlan_id_any);
984 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
985 mp->sub_inner_vlan_id_any);
986 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
987 vat_json_object_add_uint (node, "vtr_push_dot1q",
988 ntohl (mp->vtr_push_dot1q));
989 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
990 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
993 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
995 format_ethernet_address,
997 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
999 format_ethernet_address,
1001 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1002 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1006 #if VPP_API_TEST_BUILTIN == 0
1007 static void vl_api_sw_interface_event_t_handler
1008 (vl_api_sw_interface_event_t * mp)
1010 vat_main_t *vam = &vat_main;
1011 if (vam->interface_event_display)
1012 errmsg ("interface flags: sw_if_index %d %s %s",
1013 ntohl (mp->sw_if_index),
1014 mp->admin_up_down ? "admin-up" : "admin-down",
1015 mp->link_up_down ? "link-up" : "link-down");
1019 static void vl_api_sw_interface_event_t_handler_json
1020 (vl_api_sw_interface_event_t * mp)
1022 /* JSON output not supported */
1026 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1028 vat_main_t *vam = &vat_main;
1029 i32 retval = ntohl (mp->retval);
1031 vam->retval = retval;
1032 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1033 vam->result_ready = 1;
1037 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1039 vat_main_t *vam = &vat_main;
1040 vat_json_node_t node;
1041 api_main_t *am = &api_main;
1045 vat_json_init_object (&node);
1046 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1047 vat_json_object_add_uint (&node, "reply_in_shmem",
1048 ntohl (mp->reply_in_shmem));
1049 /* Toss the shared-memory original... */
1050 pthread_mutex_lock (&am->vlib_rp->mutex);
1051 oldheap = svm_push_data_heap (am->vlib_rp);
1053 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1056 svm_pop_heap (oldheap);
1057 pthread_mutex_unlock (&am->vlib_rp->mutex);
1059 vat_json_print (vam->ofp, &node);
1060 vat_json_free (&node);
1062 vam->retval = ntohl (mp->retval);
1063 vam->result_ready = 1;
1067 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1069 vat_main_t *vam = &vat_main;
1070 i32 retval = ntohl (mp->retval);
1071 u32 length = ntohl (mp->length);
1073 vec_reset_length (vam->cmd_reply);
1075 vam->retval = retval;
1078 vec_validate (vam->cmd_reply, length);
1079 clib_memcpy ((char *) (vam->cmd_reply), mp->reply, length);
1080 vam->cmd_reply[length] = 0;
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 vec_reset_length (vam->cmd_reply);
1093 vat_json_init_object (&node);
1094 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1095 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1097 vat_json_print (vam->ofp, &node);
1098 vat_json_free (&node);
1100 vam->retval = ntohl (mp->retval);
1101 vam->result_ready = 1;
1104 static void vl_api_classify_add_del_table_reply_t_handler
1105 (vl_api_classify_add_del_table_reply_t * mp)
1107 vat_main_t *vam = &vat_main;
1108 i32 retval = ntohl (mp->retval);
1109 if (vam->async_mode)
1111 vam->async_errors += (retval < 0);
1115 vam->retval = retval;
1117 ((mp->new_table_index != 0xFFFFFFFF) ||
1118 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1119 (mp->match_n_vectors != 0xFFFFFFFF)))
1121 * Note: this is just barely thread-safe, depends on
1122 * the main thread spinning waiting for an answer...
1124 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1125 ntohl (mp->new_table_index),
1126 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1127 vam->result_ready = 1;
1131 static void vl_api_classify_add_del_table_reply_t_handler_json
1132 (vl_api_classify_add_del_table_reply_t * mp)
1134 vat_main_t *vam = &vat_main;
1135 vat_json_node_t node;
1137 vat_json_init_object (&node);
1138 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1139 vat_json_object_add_uint (&node, "new_table_index",
1140 ntohl (mp->new_table_index));
1141 vat_json_object_add_uint (&node, "skip_n_vectors",
1142 ntohl (mp->skip_n_vectors));
1143 vat_json_object_add_uint (&node, "match_n_vectors",
1144 ntohl (mp->match_n_vectors));
1146 vat_json_print (vam->ofp, &node);
1147 vat_json_free (&node);
1149 vam->retval = ntohl (mp->retval);
1150 vam->result_ready = 1;
1153 static void vl_api_get_node_index_reply_t_handler
1154 (vl_api_get_node_index_reply_t * mp)
1156 vat_main_t *vam = &vat_main;
1157 i32 retval = ntohl (mp->retval);
1158 if (vam->async_mode)
1160 vam->async_errors += (retval < 0);
1164 vam->retval = retval;
1166 errmsg ("node index %d", ntohl (mp->node_index));
1167 vam->result_ready = 1;
1171 static void vl_api_get_node_index_reply_t_handler_json
1172 (vl_api_get_node_index_reply_t * mp)
1174 vat_main_t *vam = &vat_main;
1175 vat_json_node_t node;
1177 vat_json_init_object (&node);
1178 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1179 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1181 vat_json_print (vam->ofp, &node);
1182 vat_json_free (&node);
1184 vam->retval = ntohl (mp->retval);
1185 vam->result_ready = 1;
1188 static void vl_api_get_next_index_reply_t_handler
1189 (vl_api_get_next_index_reply_t * mp)
1191 vat_main_t *vam = &vat_main;
1192 i32 retval = ntohl (mp->retval);
1193 if (vam->async_mode)
1195 vam->async_errors += (retval < 0);
1199 vam->retval = retval;
1201 errmsg ("next node index %d", ntohl (mp->next_index));
1202 vam->result_ready = 1;
1206 static void vl_api_get_next_index_reply_t_handler_json
1207 (vl_api_get_next_index_reply_t * mp)
1209 vat_main_t *vam = &vat_main;
1210 vat_json_node_t node;
1212 vat_json_init_object (&node);
1213 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1214 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1216 vat_json_print (vam->ofp, &node);
1217 vat_json_free (&node);
1219 vam->retval = ntohl (mp->retval);
1220 vam->result_ready = 1;
1223 static void vl_api_add_node_next_reply_t_handler
1224 (vl_api_add_node_next_reply_t * mp)
1226 vat_main_t *vam = &vat_main;
1227 i32 retval = ntohl (mp->retval);
1228 if (vam->async_mode)
1230 vam->async_errors += (retval < 0);
1234 vam->retval = retval;
1236 errmsg ("next index %d", ntohl (mp->next_index));
1237 vam->result_ready = 1;
1241 static void vl_api_add_node_next_reply_t_handler_json
1242 (vl_api_add_node_next_reply_t * mp)
1244 vat_main_t *vam = &vat_main;
1245 vat_json_node_t node;
1247 vat_json_init_object (&node);
1248 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1249 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1251 vat_json_print (vam->ofp, &node);
1252 vat_json_free (&node);
1254 vam->retval = ntohl (mp->retval);
1255 vam->result_ready = 1;
1258 static void vl_api_show_version_reply_t_handler
1259 (vl_api_show_version_reply_t * mp)
1261 vat_main_t *vam = &vat_main;
1262 i32 retval = ntohl (mp->retval);
1266 errmsg (" program: %s", mp->program);
1267 errmsg (" version: %s", mp->version);
1268 errmsg (" build date: %s", mp->build_date);
1269 errmsg ("build directory: %s", mp->build_directory);
1271 vam->retval = retval;
1272 vam->result_ready = 1;
1275 static void vl_api_show_version_reply_t_handler_json
1276 (vl_api_show_version_reply_t * mp)
1278 vat_main_t *vam = &vat_main;
1279 vat_json_node_t node;
1281 vat_json_init_object (&node);
1282 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1283 vat_json_object_add_string_copy (&node, "program", mp->program);
1284 vat_json_object_add_string_copy (&node, "version", mp->version);
1285 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1286 vat_json_object_add_string_copy (&node, "build_directory",
1287 mp->build_directory);
1289 vat_json_print (vam->ofp, &node);
1290 vat_json_free (&node);
1292 vam->retval = ntohl (mp->retval);
1293 vam->result_ready = 1;
1297 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1299 u32 sw_if_index = ntohl (mp->sw_if_index);
1300 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1301 mp->mac_ip ? "mac/ip binding" : "address resolution",
1302 ntohl (mp->pid), format_ip4_address, &mp->address,
1303 format_ethernet_address, mp->new_mac, sw_if_index);
1307 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1309 /* JSON output not supported */
1313 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1315 u32 sw_if_index = ntohl (mp->sw_if_index);
1316 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1317 mp->mac_ip ? "mac/ip binding" : "address resolution",
1318 ntohl (mp->pid), format_ip6_address, mp->address,
1319 format_ethernet_address, mp->new_mac, sw_if_index);
1323 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1325 /* JSON output not supported */
1329 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1331 u32 n_macs = ntohl (mp->n_macs);
1332 errmsg ("L2MAC event recived with pid %d cl-idx %d for %d macs: \n",
1333 ntohl (mp->pid), mp->client_index, n_macs);
1335 for (i = 0; i < n_macs; i++)
1337 vl_api_mac_entry_t *mac = &mp->mac[i];
1338 errmsg (" [%d] sw_if_index %d mac_addr %U is_del %d \n",
1339 i + 1, ntohl (mac->sw_if_index),
1340 format_ethernet_address, mac->mac_addr, mac->is_del);
1347 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1349 /* JSON output not supported */
1352 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1353 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1356 * Special-case: build the bridge domain table, maintain
1357 * the next bd id vbl.
1359 static void vl_api_bridge_domain_details_t_handler
1360 (vl_api_bridge_domain_details_t * mp)
1362 vat_main_t *vam = &vat_main;
1363 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1366 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1367 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1369 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1370 ntohl (mp->bd_id), mp->learn, mp->forward,
1371 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1375 vl_api_bridge_domain_sw_if_t *sw_ifs;
1376 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1379 sw_ifs = mp->sw_if_details;
1380 for (i = 0; i < n_sw_ifs; i++)
1386 sw_if_index = ntohl (sw_ifs->sw_if_index);
1389 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1391 if ((u32) p->value[0] == sw_if_index)
1393 sw_if_name = (u8 *)(p->key);
1398 print (vam->ofp, "%7d %3d %s", sw_if_index,
1399 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1400 "sw_if_index not found!");
1407 static void vl_api_bridge_domain_details_t_handler_json
1408 (vl_api_bridge_domain_details_t * mp)
1410 vat_main_t *vam = &vat_main;
1411 vat_json_node_t *node, *array = NULL;
1412 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1414 if (VAT_JSON_ARRAY != vam->json_tree.type)
1416 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1417 vat_json_init_array (&vam->json_tree);
1419 node = vat_json_array_add (&vam->json_tree);
1421 vat_json_init_object (node);
1422 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1423 vat_json_object_add_uint (node, "flood", mp->flood);
1424 vat_json_object_add_uint (node, "forward", mp->forward);
1425 vat_json_object_add_uint (node, "learn", mp->learn);
1426 vat_json_object_add_uint (node, "bvi_sw_if_index",
1427 ntohl (mp->bvi_sw_if_index));
1428 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1429 array = vat_json_object_add (node, "sw_if");
1430 vat_json_init_array (array);
1436 vl_api_bridge_domain_sw_if_t *sw_ifs;
1439 sw_ifs = mp->sw_if_details;
1440 for (i = 0; i < n_sw_ifs; i++)
1442 node = vat_json_array_add (array);
1443 vat_json_init_object (node);
1444 vat_json_object_add_uint (node, "sw_if_index",
1445 ntohl (sw_ifs->sw_if_index));
1446 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1452 static void vl_api_control_ping_reply_t_handler
1453 (vl_api_control_ping_reply_t * mp)
1455 vat_main_t *vam = &vat_main;
1456 i32 retval = ntohl (mp->retval);
1457 if (vam->async_mode)
1459 vam->async_errors += (retval < 0);
1463 vam->retval = retval;
1464 vam->result_ready = 1;
1466 vam->socket_client_main.control_pings_outstanding--;
1469 static void vl_api_control_ping_reply_t_handler_json
1470 (vl_api_control_ping_reply_t * mp)
1472 vat_main_t *vam = &vat_main;
1473 i32 retval = ntohl (mp->retval);
1475 if (VAT_JSON_NONE != vam->json_tree.type)
1477 vat_json_print (vam->ofp, &vam->json_tree);
1478 vat_json_free (&vam->json_tree);
1479 vam->json_tree.type = VAT_JSON_NONE;
1484 vat_json_init_array (&vam->json_tree);
1485 vat_json_print (vam->ofp, &vam->json_tree);
1486 vam->json_tree.type = VAT_JSON_NONE;
1489 vam->retval = retval;
1490 vam->result_ready = 1;
1494 vl_api_bridge_domain_set_mac_age_reply_t_handler
1495 (vl_api_bridge_domain_set_mac_age_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_bridge_domain_set_mac_age_reply_t_handler_json
1511 (vl_api_bridge_domain_set_mac_age_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));
1519 vat_json_print (vam->ofp, &node);
1520 vat_json_free (&node);
1522 vam->retval = ntohl (mp->retval);
1523 vam->result_ready = 1;
1527 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1529 vat_main_t *vam = &vat_main;
1530 i32 retval = ntohl (mp->retval);
1531 if (vam->async_mode)
1533 vam->async_errors += (retval < 0);
1537 vam->retval = retval;
1538 vam->result_ready = 1;
1542 static void vl_api_l2_flags_reply_t_handler_json
1543 (vl_api_l2_flags_reply_t * mp)
1545 vat_main_t *vam = &vat_main;
1546 vat_json_node_t node;
1548 vat_json_init_object (&node);
1549 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1550 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1551 ntohl (mp->resulting_feature_bitmap));
1553 vat_json_print (vam->ofp, &node);
1554 vat_json_free (&node);
1556 vam->retval = ntohl (mp->retval);
1557 vam->result_ready = 1;
1560 static void vl_api_bridge_flags_reply_t_handler
1561 (vl_api_bridge_flags_reply_t * mp)
1563 vat_main_t *vam = &vat_main;
1564 i32 retval = ntohl (mp->retval);
1565 if (vam->async_mode)
1567 vam->async_errors += (retval < 0);
1571 vam->retval = retval;
1572 vam->result_ready = 1;
1576 static void vl_api_bridge_flags_reply_t_handler_json
1577 (vl_api_bridge_flags_reply_t * mp)
1579 vat_main_t *vam = &vat_main;
1580 vat_json_node_t node;
1582 vat_json_init_object (&node);
1583 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1584 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1585 ntohl (mp->resulting_feature_bitmap));
1587 vat_json_print (vam->ofp, &node);
1588 vat_json_free (&node);
1590 vam->retval = ntohl (mp->retval);
1591 vam->result_ready = 1;
1594 static void vl_api_tap_connect_reply_t_handler
1595 (vl_api_tap_connect_reply_t * mp)
1597 vat_main_t *vam = &vat_main;
1598 i32 retval = ntohl (mp->retval);
1599 if (vam->async_mode)
1601 vam->async_errors += (retval < 0);
1605 vam->retval = retval;
1606 vam->sw_if_index = ntohl (mp->sw_if_index);
1607 vam->result_ready = 1;
1612 static void vl_api_tap_connect_reply_t_handler_json
1613 (vl_api_tap_connect_reply_t * mp)
1615 vat_main_t *vam = &vat_main;
1616 vat_json_node_t node;
1618 vat_json_init_object (&node);
1619 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1620 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1622 vat_json_print (vam->ofp, &node);
1623 vat_json_free (&node);
1625 vam->retval = ntohl (mp->retval);
1626 vam->result_ready = 1;
1631 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1633 vat_main_t *vam = &vat_main;
1634 i32 retval = ntohl (mp->retval);
1635 if (vam->async_mode)
1637 vam->async_errors += (retval < 0);
1641 vam->retval = retval;
1642 vam->sw_if_index = ntohl (mp->sw_if_index);
1643 vam->result_ready = 1;
1647 static void vl_api_tap_modify_reply_t_handler_json
1648 (vl_api_tap_modify_reply_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 vat_json_node_t node;
1653 vat_json_init_object (&node);
1654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1657 vat_json_print (vam->ofp, &node);
1658 vat_json_free (&node);
1660 vam->retval = ntohl (mp->retval);
1661 vam->result_ready = 1;
1665 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_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_tap_delete_reply_t_handler_json
1681 (vl_api_tap_delete_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));
1689 vat_json_print (vam->ofp, &node);
1690 vat_json_free (&node);
1692 vam->retval = ntohl (mp->retval);
1693 vam->result_ready = 1;
1696 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1697 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1699 vat_main_t *vam = &vat_main;
1700 i32 retval = ntohl (mp->retval);
1701 if (vam->async_mode)
1703 vam->async_errors += (retval < 0);
1707 vam->retval = retval;
1708 vam->result_ready = 1;
1712 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1713 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1715 vat_main_t *vam = &vat_main;
1716 vat_json_node_t node;
1718 vat_json_init_object (&node);
1719 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1720 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1721 ntohl (mp->sw_if_index));
1723 vat_json_print (vam->ofp, &node);
1724 vat_json_free (&node);
1726 vam->retval = ntohl (mp->retval);
1727 vam->result_ready = 1;
1730 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1731 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1733 vat_main_t *vam = &vat_main;
1734 i32 retval = ntohl (mp->retval);
1735 if (vam->async_mode)
1737 vam->async_errors += (retval < 0);
1741 vam->retval = retval;
1742 vam->sw_if_index = ntohl (mp->sw_if_index);
1743 vam->result_ready = 1;
1747 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1748 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1750 vat_main_t *vam = &vat_main;
1751 vat_json_node_t node;
1753 vat_json_init_object (&node);
1754 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1755 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1757 vat_json_print (vam->ofp, &node);
1758 vat_json_free (&node);
1760 vam->retval = ntohl (mp->retval);
1761 vam->result_ready = 1;
1764 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
1765 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1767 vat_main_t *vam = &vat_main;
1768 i32 retval = ntohl (mp->retval);
1769 if (vam->async_mode)
1771 vam->async_errors += (retval < 0);
1775 vam->retval = retval;
1776 vam->result_ready = 1;
1780 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
1781 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1783 vat_main_t *vam = &vat_main;
1784 vat_json_node_t node;
1786 vat_json_init_object (&node);
1787 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1788 vat_json_object_add_uint (&node, "fwd_entry_index",
1789 clib_net_to_host_u32 (mp->fwd_entry_index));
1791 vat_json_print (vam->ofp, &node);
1792 vat_json_free (&node);
1794 vam->retval = ntohl (mp->retval);
1795 vam->result_ready = 1;
1799 format_lisp_transport_protocol (u8 * s, va_list * args)
1801 u32 proto = va_arg (*args, u32);
1806 return format (s, "udp");
1808 return format (s, "api");
1815 static void vl_api_one_get_transport_protocol_reply_t_handler
1816 (vl_api_one_get_transport_protocol_reply_t * mp)
1818 vat_main_t *vam = &vat_main;
1819 i32 retval = ntohl (mp->retval);
1820 if (vam->async_mode)
1822 vam->async_errors += (retval < 0);
1826 u32 proto = mp->protocol;
1827 print (vam->ofp, "Transport protocol: %U",
1828 format_lisp_transport_protocol, proto);
1829 vam->retval = retval;
1830 vam->result_ready = 1;
1834 static void vl_api_one_get_transport_protocol_reply_t_handler_json
1835 (vl_api_one_get_transport_protocol_reply_t * mp)
1837 vat_main_t *vam = &vat_main;
1838 vat_json_node_t node;
1841 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
1844 vat_json_init_object (&node);
1845 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1846 vat_json_object_add_string_copy (&node, "transport-protocol", s);
1849 vat_json_print (vam->ofp, &node);
1850 vat_json_free (&node);
1852 vam->retval = ntohl (mp->retval);
1853 vam->result_ready = 1;
1856 static void vl_api_one_add_del_locator_set_reply_t_handler
1857 (vl_api_one_add_del_locator_set_reply_t * mp)
1859 vat_main_t *vam = &vat_main;
1860 i32 retval = ntohl (mp->retval);
1861 if (vam->async_mode)
1863 vam->async_errors += (retval < 0);
1867 vam->retval = retval;
1868 vam->result_ready = 1;
1872 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1873 (vl_api_one_add_del_locator_set_reply_t * mp)
1875 vat_main_t *vam = &vat_main;
1876 vat_json_node_t node;
1878 vat_json_init_object (&node);
1879 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1880 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1882 vat_json_print (vam->ofp, &node);
1883 vat_json_free (&node);
1885 vam->retval = ntohl (mp->retval);
1886 vam->result_ready = 1;
1889 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1890 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1892 vat_main_t *vam = &vat_main;
1893 i32 retval = ntohl (mp->retval);
1894 if (vam->async_mode)
1896 vam->async_errors += (retval < 0);
1900 vam->retval = retval;
1901 vam->sw_if_index = ntohl (mp->sw_if_index);
1902 vam->result_ready = 1;
1906 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1907 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1909 vat_main_t *vam = &vat_main;
1910 vat_json_node_t node;
1912 vat_json_init_object (&node);
1913 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1914 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1916 vat_json_print (vam->ofp, &node);
1917 vat_json_free (&node);
1919 vam->retval = ntohl (mp->retval);
1920 vam->result_ready = 1;
1923 static void vl_api_geneve_add_del_tunnel_reply_t_handler
1924 (vl_api_geneve_add_del_tunnel_reply_t * mp)
1926 vat_main_t *vam = &vat_main;
1927 i32 retval = ntohl (mp->retval);
1928 if (vam->async_mode)
1930 vam->async_errors += (retval < 0);
1934 vam->retval = retval;
1935 vam->sw_if_index = ntohl (mp->sw_if_index);
1936 vam->result_ready = 1;
1940 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
1941 (vl_api_geneve_add_del_tunnel_reply_t * mp)
1943 vat_main_t *vam = &vat_main;
1944 vat_json_node_t node;
1946 vat_json_init_object (&node);
1947 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1948 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1950 vat_json_print (vam->ofp, &node);
1951 vat_json_free (&node);
1953 vam->retval = ntohl (mp->retval);
1954 vam->result_ready = 1;
1957 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
1958 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
1960 vat_main_t *vam = &vat_main;
1961 i32 retval = ntohl (mp->retval);
1962 if (vam->async_mode)
1964 vam->async_errors += (retval < 0);
1968 vam->retval = retval;
1969 vam->sw_if_index = ntohl (mp->sw_if_index);
1970 vam->result_ready = 1;
1974 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
1975 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
1977 vat_main_t *vam = &vat_main;
1978 vat_json_node_t node;
1980 vat_json_init_object (&node);
1981 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1982 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1984 vat_json_print (vam->ofp, &node);
1985 vat_json_free (&node);
1987 vam->retval = ntohl (mp->retval);
1988 vam->result_ready = 1;
1991 static void vl_api_gre_add_del_tunnel_reply_t_handler
1992 (vl_api_gre_add_del_tunnel_reply_t * mp)
1994 vat_main_t *vam = &vat_main;
1995 i32 retval = ntohl (mp->retval);
1996 if (vam->async_mode)
1998 vam->async_errors += (retval < 0);
2002 vam->retval = retval;
2003 vam->sw_if_index = ntohl (mp->sw_if_index);
2004 vam->result_ready = 1;
2008 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2009 (vl_api_gre_add_del_tunnel_reply_t * mp)
2011 vat_main_t *vam = &vat_main;
2012 vat_json_node_t node;
2014 vat_json_init_object (&node);
2015 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2016 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2018 vat_json_print (vam->ofp, &node);
2019 vat_json_free (&node);
2021 vam->retval = ntohl (mp->retval);
2022 vam->result_ready = 1;
2025 static void vl_api_create_vhost_user_if_reply_t_handler
2026 (vl_api_create_vhost_user_if_reply_t * mp)
2028 vat_main_t *vam = &vat_main;
2029 i32 retval = ntohl (mp->retval);
2030 if (vam->async_mode)
2032 vam->async_errors += (retval < 0);
2036 vam->retval = retval;
2037 vam->sw_if_index = ntohl (mp->sw_if_index);
2038 vam->result_ready = 1;
2042 static void vl_api_create_vhost_user_if_reply_t_handler_json
2043 (vl_api_create_vhost_user_if_reply_t * mp)
2045 vat_main_t *vam = &vat_main;
2046 vat_json_node_t node;
2048 vat_json_init_object (&node);
2049 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2050 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2052 vat_json_print (vam->ofp, &node);
2053 vat_json_free (&node);
2055 vam->retval = ntohl (mp->retval);
2056 vam->result_ready = 1;
2059 static clib_error_t *
2060 receive_fd_msg (int socket_fd, int *my_fd)
2063 char ctl[CMSG_SPACE (sizeof (int)) + CMSG_SPACE (sizeof (struct ucred))];
2064 struct msghdr mh = { 0 };
2065 struct iovec iov[1];
2067 struct ucred *cr = 0;
2068 struct cmsghdr *cmsg;
2069 pid_t pid __attribute__ ((unused));
2070 uid_t uid __attribute__ ((unused));
2071 gid_t gid __attribute__ ((unused));
2073 iov[0].iov_base = msgbuf;
2077 mh.msg_control = ctl;
2078 mh.msg_controllen = sizeof (ctl);
2080 memset (ctl, 0, sizeof (ctl));
2082 /* receive the incoming message */
2083 size = recvmsg (socket_fd, &mh, 0);
2086 return (size == 0) ? clib_error_return (0, "disconnected") :
2087 clib_error_return_unix (0, "recvmsg: malformed message (fd %d)",
2091 cmsg = CMSG_FIRSTHDR (&mh);
2094 if (cmsg->cmsg_level == SOL_SOCKET)
2096 if (cmsg->cmsg_type == SCM_CREDENTIALS)
2098 cr = (struct ucred *) CMSG_DATA (cmsg);
2103 else if (cmsg->cmsg_type == SCM_RIGHTS)
2105 clib_memcpy (my_fd, CMSG_DATA (cmsg), sizeof (int));
2108 cmsg = CMSG_NXTHDR (&mh, cmsg);
2113 static void vl_api_memfd_segment_create_reply_t_handler
2114 (vl_api_memfd_segment_create_reply_t * mp)
2116 /* Dont bother in the builtin version */
2117 #if VPP_API_TEST_BUILTIN == 0
2118 vat_main_t *vam = &vat_main;
2119 api_main_t *am = &api_main;
2120 socket_client_main_t *scm = &vam->socket_client_main;
2122 clib_error_t *error;
2123 memfd_private_t memfd;
2124 i32 retval = ntohl (mp->retval);
2128 error = receive_fd_msg (scm->socket_fd, &my_fd);
2135 memset (&memfd, 0, sizeof (memfd));
2138 vam->client_index_invalid = 1;
2140 /* Note: this closes memfd.fd */
2141 retval = memfd_slave_init (&memfd);
2143 clib_warning ("WARNING: segment map returned %d", retval);
2145 /* Pivot to the memory client segment that vpp just created */
2147 am->vlib_rp = (void *) (memfd.requested_va + MMAP_PAGESIZE);
2149 am->shmem_hdr = (void *) am->vlib_rp->user_ctx;
2151 vl_client_install_client_message_handlers ();
2153 vl_client_connect_to_vlib_no_map ("pvt",
2155 32 /* input_queue_length */ );
2156 vam->vl_input_queue = am->shmem_hdr->vl_input_queue;
2158 vl_socket_client_enable_disable (&vam->socket_client_main,
2159 0 /* disable socket */ );
2163 if (vam->async_mode)
2165 vam->async_errors += (retval < 0);
2169 vam->retval = retval;
2170 vam->result_ready = 1;
2175 static void vl_api_memfd_segment_create_reply_t_handler_json
2176 (vl_api_memfd_segment_create_reply_t * mp)
2178 clib_warning ("no");
2181 static void vl_api_dns_resolve_name_reply_t_handler
2182 (vl_api_dns_resolve_name_reply_t * mp)
2184 vat_main_t *vam = &vat_main;
2185 i32 retval = ntohl (mp->retval);
2186 if (vam->async_mode)
2188 vam->async_errors += (retval < 0);
2192 vam->retval = retval;
2193 vam->result_ready = 1;
2198 clib_warning ("ip4 address %U", format_ip4_address,
2199 (ip4_address_t *) mp->ip4_address);
2201 clib_warning ("ip6 address %U", format_ip6_address,
2202 (ip6_address_t *) mp->ip6_address);
2205 clib_warning ("retval %d", retval);
2209 static void vl_api_dns_resolve_name_reply_t_handler_json
2210 (vl_api_dns_resolve_name_reply_t * mp)
2212 clib_warning ("not implemented");
2215 static void vl_api_dns_resolve_ip_reply_t_handler
2216 (vl_api_dns_resolve_ip_reply_t * mp)
2218 vat_main_t *vam = &vat_main;
2219 i32 retval = ntohl (mp->retval);
2220 if (vam->async_mode)
2222 vam->async_errors += (retval < 0);
2226 vam->retval = retval;
2227 vam->result_ready = 1;
2231 clib_warning ("canonical name %s", mp->name);
2234 clib_warning ("retval %d", retval);
2238 static void vl_api_dns_resolve_ip_reply_t_handler_json
2239 (vl_api_dns_resolve_ip_reply_t * mp)
2241 clib_warning ("not implemented");
2245 static void vl_api_ip_address_details_t_handler
2246 (vl_api_ip_address_details_t * mp)
2248 vat_main_t *vam = &vat_main;
2249 static ip_address_details_t empty_ip_address_details = { {0} };
2250 ip_address_details_t *address = NULL;
2251 ip_details_t *current_ip_details = NULL;
2252 ip_details_t *details = NULL;
2254 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2256 if (!details || vam->current_sw_if_index >= vec_len (details)
2257 || !details[vam->current_sw_if_index].present)
2259 errmsg ("ip address details arrived but not stored");
2260 errmsg ("ip_dump should be called first");
2264 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2266 #define addresses (current_ip_details->addr)
2268 vec_validate_init_empty (addresses, vec_len (addresses),
2269 empty_ip_address_details);
2271 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2273 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2274 address->prefix_length = mp->prefix_length;
2278 static void vl_api_ip_address_details_t_handler_json
2279 (vl_api_ip_address_details_t * mp)
2281 vat_main_t *vam = &vat_main;
2282 vat_json_node_t *node = NULL;
2283 struct in6_addr ip6;
2286 if (VAT_JSON_ARRAY != vam->json_tree.type)
2288 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2289 vat_json_init_array (&vam->json_tree);
2291 node = vat_json_array_add (&vam->json_tree);
2293 vat_json_init_object (node);
2296 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2297 vat_json_object_add_ip6 (node, "ip", ip6);
2301 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2302 vat_json_object_add_ip4 (node, "ip", ip4);
2304 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2308 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2310 vat_main_t *vam = &vat_main;
2311 static ip_details_t empty_ip_details = { 0 };
2312 ip_details_t *ip = NULL;
2313 u32 sw_if_index = ~0;
2315 sw_if_index = ntohl (mp->sw_if_index);
2317 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2318 sw_if_index, empty_ip_details);
2320 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2327 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2329 vat_main_t *vam = &vat_main;
2331 if (VAT_JSON_ARRAY != vam->json_tree.type)
2333 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2334 vat_json_init_array (&vam->json_tree);
2336 vat_json_array_add_uint (&vam->json_tree,
2337 clib_net_to_host_u32 (mp->sw_if_index));
2340 static void vl_api_map_domain_details_t_handler_json
2341 (vl_api_map_domain_details_t * mp)
2343 vat_json_node_t *node = NULL;
2344 vat_main_t *vam = &vat_main;
2345 struct in6_addr ip6;
2348 if (VAT_JSON_ARRAY != vam->json_tree.type)
2350 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2351 vat_json_init_array (&vam->json_tree);
2354 node = vat_json_array_add (&vam->json_tree);
2355 vat_json_init_object (node);
2357 vat_json_object_add_uint (node, "domain_index",
2358 clib_net_to_host_u32 (mp->domain_index));
2359 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
2360 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
2361 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
2362 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
2363 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
2364 vat_json_object_add_ip6 (node, "ip6_src", ip6);
2365 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
2366 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
2367 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
2368 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
2369 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
2370 vat_json_object_add_int (node, "psid_length", mp->psid_length);
2371 vat_json_object_add_uint (node, "flags", mp->flags);
2372 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
2373 vat_json_object_add_int (node, "is_translation", mp->is_translation);
2376 static void vl_api_map_domain_details_t_handler
2377 (vl_api_map_domain_details_t * mp)
2379 vat_main_t *vam = &vat_main;
2381 if (mp->is_translation)
2384 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2385 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2386 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2387 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2388 clib_net_to_host_u32 (mp->domain_index));
2393 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2394 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2395 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2396 format_ip6_address, mp->ip6_src,
2397 clib_net_to_host_u32 (mp->domain_index));
2399 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2400 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2401 mp->is_translation ? "map-t" : "");
2404 static void vl_api_map_rule_details_t_handler_json
2405 (vl_api_map_rule_details_t * mp)
2407 struct in6_addr ip6;
2408 vat_json_node_t *node = NULL;
2409 vat_main_t *vam = &vat_main;
2411 if (VAT_JSON_ARRAY != vam->json_tree.type)
2413 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2414 vat_json_init_array (&vam->json_tree);
2417 node = vat_json_array_add (&vam->json_tree);
2418 vat_json_init_object (node);
2420 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2421 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2422 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2426 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2428 vat_main_t *vam = &vat_main;
2429 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2430 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2434 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2436 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2437 "router_addr %U host_mac %U",
2438 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2439 format_ip4_address, &mp->host_address,
2440 format_ip4_address, &mp->router_address,
2441 format_ethernet_address, mp->host_mac);
2444 static void vl_api_dhcp_compl_event_t_handler_json
2445 (vl_api_dhcp_compl_event_t * mp)
2447 /* JSON output not supported */
2451 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2454 vat_main_t *vam = &vat_main;
2455 static u64 default_counter = 0;
2457 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2459 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2460 sw_if_index, default_counter);
2461 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2465 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2466 interface_counter_t counter)
2468 vat_main_t *vam = &vat_main;
2469 static interface_counter_t default_counter = { 0, };
2471 vec_validate_init_empty (vam->combined_interface_counters,
2472 vnet_counter_type, NULL);
2473 vec_validate_init_empty (vam->combined_interface_counters
2474 [vnet_counter_type], sw_if_index, default_counter);
2475 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2478 static void vl_api_vnet_interface_simple_counters_t_handler
2479 (vl_api_vnet_interface_simple_counters_t * mp)
2484 static void vl_api_vnet_interface_combined_counters_t_handler
2485 (vl_api_vnet_interface_combined_counters_t * mp)
2490 static void vl_api_vnet_interface_simple_counters_t_handler_json
2491 (vl_api_vnet_interface_simple_counters_t * mp)
2496 u32 first_sw_if_index;
2499 count = ntohl (mp->count);
2500 first_sw_if_index = ntohl (mp->first_sw_if_index);
2502 v_packets = (u64 *) & mp->data;
2503 for (i = 0; i < count; i++)
2505 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2506 set_simple_interface_counter (mp->vnet_counter_type,
2507 first_sw_if_index + i, packets);
2512 static void vl_api_vnet_interface_combined_counters_t_handler_json
2513 (vl_api_vnet_interface_combined_counters_t * mp)
2515 interface_counter_t counter;
2517 u32 first_sw_if_index;
2521 count = ntohl (mp->count);
2522 first_sw_if_index = ntohl (mp->first_sw_if_index);
2524 v = (vlib_counter_t *) & mp->data;
2525 for (i = 0; i < count; i++)
2528 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2530 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2531 set_combined_interface_counter (mp->vnet_counter_type,
2532 first_sw_if_index + i, counter);
2538 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2540 vat_main_t *vam = &vat_main;
2543 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2545 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2554 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2556 vat_main_t *vam = &vat_main;
2559 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2561 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2569 static void vl_api_vnet_ip4_fib_counters_t_handler
2570 (vl_api_vnet_ip4_fib_counters_t * mp)
2575 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2576 (vl_api_vnet_ip4_fib_counters_t * mp)
2578 vat_main_t *vam = &vat_main;
2579 vl_api_ip4_fib_counter_t *v;
2580 ip4_fib_counter_t *counter;
2587 vrf_id = ntohl (mp->vrf_id);
2588 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2589 if (~0 == vrf_index)
2591 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2592 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2593 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2594 vec_validate (vam->ip4_fib_counters, vrf_index);
2595 vam->ip4_fib_counters[vrf_index] = NULL;
2598 vec_free (vam->ip4_fib_counters[vrf_index]);
2599 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2600 count = ntohl (mp->count);
2601 for (i = 0; i < count; i++)
2603 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2604 counter = &vam->ip4_fib_counters[vrf_index][i];
2605 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2606 counter->address = ip4;
2607 counter->address_length = v->address_length;
2608 counter->packets = clib_net_to_host_u64 (v->packets);
2609 counter->bytes = clib_net_to_host_u64 (v->bytes);
2614 static void vl_api_vnet_ip4_nbr_counters_t_handler
2615 (vl_api_vnet_ip4_nbr_counters_t * mp)
2620 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2621 (vl_api_vnet_ip4_nbr_counters_t * mp)
2623 vat_main_t *vam = &vat_main;
2624 vl_api_ip4_nbr_counter_t *v;
2625 ip4_nbr_counter_t *counter;
2630 sw_if_index = ntohl (mp->sw_if_index);
2631 count = ntohl (mp->count);
2632 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2635 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2637 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2638 for (i = 0; i < count; i++)
2640 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2641 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2642 counter->address.s_addr = v->address;
2643 counter->packets = clib_net_to_host_u64 (v->packets);
2644 counter->bytes = clib_net_to_host_u64 (v->bytes);
2645 counter->linkt = v->link_type;
2650 static void vl_api_vnet_ip6_fib_counters_t_handler
2651 (vl_api_vnet_ip6_fib_counters_t * mp)
2656 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2657 (vl_api_vnet_ip6_fib_counters_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vl_api_ip6_fib_counter_t *v;
2661 ip6_fib_counter_t *counter;
2662 struct in6_addr ip6;
2668 vrf_id = ntohl (mp->vrf_id);
2669 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2670 if (~0 == vrf_index)
2672 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2673 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2674 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2675 vec_validate (vam->ip6_fib_counters, vrf_index);
2676 vam->ip6_fib_counters[vrf_index] = NULL;
2679 vec_free (vam->ip6_fib_counters[vrf_index]);
2680 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2681 count = ntohl (mp->count);
2682 for (i = 0; i < count; i++)
2684 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2685 counter = &vam->ip6_fib_counters[vrf_index][i];
2686 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2687 counter->address = ip6;
2688 counter->address_length = v->address_length;
2689 counter->packets = clib_net_to_host_u64 (v->packets);
2690 counter->bytes = clib_net_to_host_u64 (v->bytes);
2695 static void vl_api_vnet_ip6_nbr_counters_t_handler
2696 (vl_api_vnet_ip6_nbr_counters_t * mp)
2701 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2702 (vl_api_vnet_ip6_nbr_counters_t * mp)
2704 vat_main_t *vam = &vat_main;
2705 vl_api_ip6_nbr_counter_t *v;
2706 ip6_nbr_counter_t *counter;
2707 struct in6_addr ip6;
2712 sw_if_index = ntohl (mp->sw_if_index);
2713 count = ntohl (mp->count);
2714 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2717 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2719 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2720 for (i = 0; i < count; i++)
2722 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2723 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2724 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2725 counter->address = ip6;
2726 counter->packets = clib_net_to_host_u64 (v->packets);
2727 counter->bytes = clib_net_to_host_u64 (v->bytes);
2732 static void vl_api_get_first_msg_id_reply_t_handler
2733 (vl_api_get_first_msg_id_reply_t * mp)
2735 vat_main_t *vam = &vat_main;
2736 i32 retval = ntohl (mp->retval);
2738 if (vam->async_mode)
2740 vam->async_errors += (retval < 0);
2744 vam->retval = retval;
2745 vam->result_ready = 1;
2749 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2753 static void vl_api_get_first_msg_id_reply_t_handler_json
2754 (vl_api_get_first_msg_id_reply_t * mp)
2756 vat_main_t *vam = &vat_main;
2757 vat_json_node_t node;
2759 vat_json_init_object (&node);
2760 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2761 vat_json_object_add_uint (&node, "first_msg_id",
2762 (uint) ntohs (mp->first_msg_id));
2764 vat_json_print (vam->ofp, &node);
2765 vat_json_free (&node);
2767 vam->retval = ntohl (mp->retval);
2768 vam->result_ready = 1;
2771 static void vl_api_get_node_graph_reply_t_handler
2772 (vl_api_get_node_graph_reply_t * mp)
2774 vat_main_t *vam = &vat_main;
2775 api_main_t *am = &api_main;
2776 i32 retval = ntohl (mp->retval);
2777 u8 *pvt_copy, *reply;
2782 if (vam->async_mode)
2784 vam->async_errors += (retval < 0);
2788 vam->retval = retval;
2789 vam->result_ready = 1;
2792 /* "Should never happen..." */
2796 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2797 pvt_copy = vec_dup (reply);
2799 /* Toss the shared-memory original... */
2800 pthread_mutex_lock (&am->vlib_rp->mutex);
2801 oldheap = svm_push_data_heap (am->vlib_rp);
2805 svm_pop_heap (oldheap);
2806 pthread_mutex_unlock (&am->vlib_rp->mutex);
2808 if (vam->graph_nodes)
2810 hash_free (vam->graph_node_index_by_name);
2812 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2814 node = vam->graph_nodes[i];
2815 vec_free (node->name);
2816 vec_free (node->next_nodes);
2819 vec_free (vam->graph_nodes);
2822 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2823 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2824 vec_free (pvt_copy);
2826 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2828 node = vam->graph_nodes[i];
2829 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2833 static void vl_api_get_node_graph_reply_t_handler_json
2834 (vl_api_get_node_graph_reply_t * mp)
2836 vat_main_t *vam = &vat_main;
2837 api_main_t *am = &api_main;
2839 vat_json_node_t node;
2842 /* $$$$ make this real? */
2843 vat_json_init_object (&node);
2844 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2845 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2847 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2849 /* Toss the shared-memory original... */
2850 pthread_mutex_lock (&am->vlib_rp->mutex);
2851 oldheap = svm_push_data_heap (am->vlib_rp);
2855 svm_pop_heap (oldheap);
2856 pthread_mutex_unlock (&am->vlib_rp->mutex);
2858 vat_json_print (vam->ofp, &node);
2859 vat_json_free (&node);
2861 vam->retval = ntohl (mp->retval);
2862 vam->result_ready = 1;
2866 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2868 vat_main_t *vam = &vat_main;
2873 s = format (s, "%=16d%=16d%=16d",
2874 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2878 s = format (s, "%=16U%=16d%=16d",
2879 mp->is_ipv6 ? format_ip6_address :
2881 mp->ip_address, mp->priority, mp->weight);
2884 print (vam->ofp, "%v", s);
2889 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2891 vat_main_t *vam = &vat_main;
2892 vat_json_node_t *node = NULL;
2893 struct in6_addr ip6;
2896 if (VAT_JSON_ARRAY != vam->json_tree.type)
2898 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2899 vat_json_init_array (&vam->json_tree);
2901 node = vat_json_array_add (&vam->json_tree);
2902 vat_json_init_object (node);
2904 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2905 vat_json_object_add_uint (node, "priority", mp->priority);
2906 vat_json_object_add_uint (node, "weight", mp->weight);
2909 vat_json_object_add_uint (node, "sw_if_index",
2910 clib_net_to_host_u32 (mp->sw_if_index));
2915 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2916 vat_json_object_add_ip6 (node, "address", ip6);
2920 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2921 vat_json_object_add_ip4 (node, "address", ip4);
2927 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2930 vat_main_t *vam = &vat_main;
2933 ls_name = format (0, "%s", mp->ls_name);
2935 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2941 vl_api_one_locator_set_details_t_handler_json
2942 (vl_api_one_locator_set_details_t * mp)
2944 vat_main_t *vam = &vat_main;
2945 vat_json_node_t *node = 0;
2948 ls_name = format (0, "%s", mp->ls_name);
2949 vec_add1 (ls_name, 0);
2951 if (VAT_JSON_ARRAY != vam->json_tree.type)
2953 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2954 vat_json_init_array (&vam->json_tree);
2956 node = vat_json_array_add (&vam->json_tree);
2958 vat_json_init_object (node);
2959 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2960 vat_json_object_add_uint (node, "ls_index",
2961 clib_net_to_host_u32 (mp->ls_index));
2969 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2972 unformat_nsh_address (unformat_input_t * input, va_list * args)
2974 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2975 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2979 format_nsh_address_vat (u8 * s, va_list * args)
2981 nsh_t *a = va_arg (*args, nsh_t *);
2982 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2986 format_lisp_flat_eid (u8 * s, va_list * args)
2988 u32 type = va_arg (*args, u32);
2989 u8 *eid = va_arg (*args, u8 *);
2990 u32 eid_len = va_arg (*args, u32);
2995 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2997 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2999 return format (s, "%U", format_ethernet_address, eid);
3001 return format (s, "%U", format_nsh_address_vat, eid);
3007 format_lisp_eid_vat (u8 * s, va_list * args)
3009 u32 type = va_arg (*args, u32);
3010 u8 *eid = va_arg (*args, u8 *);
3011 u32 eid_len = va_arg (*args, u32);
3012 u8 *seid = va_arg (*args, u8 *);
3013 u32 seid_len = va_arg (*args, u32);
3014 u32 is_src_dst = va_arg (*args, u32);
3017 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3019 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3025 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3027 vat_main_t *vam = &vat_main;
3028 u8 *s = 0, *eid = 0;
3030 if (~0 == mp->locator_set_index)
3031 s = format (0, "action: %d", mp->action);
3033 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3035 eid = format (0, "%U", format_lisp_eid_vat,
3039 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3042 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3043 clib_net_to_host_u32 (mp->vni),
3045 mp->is_local ? "local" : "remote",
3046 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3047 clib_net_to_host_u16 (mp->key_id), mp->key);
3054 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3057 vat_main_t *vam = &vat_main;
3058 vat_json_node_t *node = 0;
3061 if (VAT_JSON_ARRAY != vam->json_tree.type)
3063 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3064 vat_json_init_array (&vam->json_tree);
3066 node = vat_json_array_add (&vam->json_tree);
3068 vat_json_init_object (node);
3069 if (~0 == mp->locator_set_index)
3070 vat_json_object_add_uint (node, "action", mp->action);
3072 vat_json_object_add_uint (node, "locator_set_index",
3073 clib_net_to_host_u32 (mp->locator_set_index));
3075 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3076 if (mp->eid_type == 3)
3078 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3079 vat_json_init_object (nsh_json);
3080 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3081 vat_json_object_add_uint (nsh_json, "spi",
3082 clib_net_to_host_u32 (nsh->spi));
3083 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3087 eid = format (0, "%U", format_lisp_eid_vat,
3091 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3093 vat_json_object_add_string_copy (node, "eid", eid);
3096 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3097 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3098 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3102 vat_json_object_add_uint (node, "key_id",
3103 clib_net_to_host_u16 (mp->key_id));
3104 vat_json_object_add_string_copy (node, "key", mp->key);
3109 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3111 vat_main_t *vam = &vat_main;
3112 u8 *seid = 0, *deid = 0;
3113 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3115 deid = format (0, "%U", format_lisp_eid_vat,
3116 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3118 seid = format (0, "%U", format_lisp_eid_vat,
3119 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3125 format_ip_address_fcn = format_ip4_address;
3127 format_ip_address_fcn = format_ip6_address;
3130 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3131 clib_net_to_host_u32 (mp->vni),
3133 format_ip_address_fcn, mp->lloc,
3134 format_ip_address_fcn, mp->rloc,
3135 clib_net_to_host_u32 (mp->pkt_count),
3136 clib_net_to_host_u32 (mp->bytes));
3143 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3145 struct in6_addr ip6;
3147 vat_main_t *vam = &vat_main;
3148 vat_json_node_t *node = 0;
3149 u8 *deid = 0, *seid = 0;
3151 if (VAT_JSON_ARRAY != vam->json_tree.type)
3153 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3154 vat_json_init_array (&vam->json_tree);
3156 node = vat_json_array_add (&vam->json_tree);
3158 vat_json_init_object (node);
3159 deid = format (0, "%U", format_lisp_eid_vat,
3160 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3162 seid = format (0, "%U", format_lisp_eid_vat,
3163 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3168 vat_json_object_add_string_copy (node, "seid", seid);
3169 vat_json_object_add_string_copy (node, "deid", deid);
3170 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3174 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3175 vat_json_object_add_ip4 (node, "lloc", ip4);
3176 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3177 vat_json_object_add_ip4 (node, "rloc", ip4);
3181 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3182 vat_json_object_add_ip6 (node, "lloc", ip6);
3183 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3184 vat_json_object_add_ip6 (node, "rloc", ip6);
3186 vat_json_object_add_uint (node, "pkt_count",
3187 clib_net_to_host_u32 (mp->pkt_count));
3188 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3195 vl_api_one_eid_table_map_details_t_handler
3196 (vl_api_one_eid_table_map_details_t * mp)
3198 vat_main_t *vam = &vat_main;
3200 u8 *line = format (0, "%=10d%=10d",
3201 clib_net_to_host_u32 (mp->vni),
3202 clib_net_to_host_u32 (mp->dp_table));
3203 print (vam->ofp, "%v", line);
3208 vl_api_one_eid_table_map_details_t_handler_json
3209 (vl_api_one_eid_table_map_details_t * mp)
3211 vat_main_t *vam = &vat_main;
3212 vat_json_node_t *node = NULL;
3214 if (VAT_JSON_ARRAY != vam->json_tree.type)
3216 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3217 vat_json_init_array (&vam->json_tree);
3219 node = vat_json_array_add (&vam->json_tree);
3220 vat_json_init_object (node);
3221 vat_json_object_add_uint (node, "dp_table",
3222 clib_net_to_host_u32 (mp->dp_table));
3223 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3227 vl_api_one_eid_table_vni_details_t_handler
3228 (vl_api_one_eid_table_vni_details_t * mp)
3230 vat_main_t *vam = &vat_main;
3232 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3233 print (vam->ofp, "%v", line);
3238 vl_api_one_eid_table_vni_details_t_handler_json
3239 (vl_api_one_eid_table_vni_details_t * mp)
3241 vat_main_t *vam = &vat_main;
3242 vat_json_node_t *node = NULL;
3244 if (VAT_JSON_ARRAY != vam->json_tree.type)
3246 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3247 vat_json_init_array (&vam->json_tree);
3249 node = vat_json_array_add (&vam->json_tree);
3250 vat_json_init_object (node);
3251 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3255 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3256 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3258 vat_main_t *vam = &vat_main;
3259 int retval = clib_net_to_host_u32 (mp->retval);
3261 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3262 print (vam->ofp, "fallback threshold value: %d", mp->value);
3264 vam->retval = retval;
3265 vam->result_ready = 1;
3269 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3270 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3272 vat_main_t *vam = &vat_main;
3273 vat_json_node_t _node, *node = &_node;
3274 int retval = clib_net_to_host_u32 (mp->retval);
3276 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3277 vat_json_init_object (node);
3278 vat_json_object_add_uint (node, "value", mp->value);
3280 vat_json_print (vam->ofp, node);
3281 vat_json_free (node);
3283 vam->retval = retval;
3284 vam->result_ready = 1;
3288 vl_api_show_one_map_register_state_reply_t_handler
3289 (vl_api_show_one_map_register_state_reply_t * mp)
3291 vat_main_t *vam = &vat_main;
3292 int retval = clib_net_to_host_u32 (mp->retval);
3294 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3296 vam->retval = retval;
3297 vam->result_ready = 1;
3301 vl_api_show_one_map_register_state_reply_t_handler_json
3302 (vl_api_show_one_map_register_state_reply_t * mp)
3304 vat_main_t *vam = &vat_main;
3305 vat_json_node_t _node, *node = &_node;
3306 int retval = clib_net_to_host_u32 (mp->retval);
3308 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3310 vat_json_init_object (node);
3311 vat_json_object_add_string_copy (node, "state", s);
3313 vat_json_print (vam->ofp, node);
3314 vat_json_free (node);
3316 vam->retval = retval;
3317 vam->result_ready = 1;
3322 vl_api_show_one_rloc_probe_state_reply_t_handler
3323 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3325 vat_main_t *vam = &vat_main;
3326 int retval = clib_net_to_host_u32 (mp->retval);
3331 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3333 vam->retval = retval;
3334 vam->result_ready = 1;
3338 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3339 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3341 vat_main_t *vam = &vat_main;
3342 vat_json_node_t _node, *node = &_node;
3343 int retval = clib_net_to_host_u32 (mp->retval);
3345 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3346 vat_json_init_object (node);
3347 vat_json_object_add_string_copy (node, "state", s);
3349 vat_json_print (vam->ofp, node);
3350 vat_json_free (node);
3352 vam->retval = retval;
3353 vam->result_ready = 1;
3358 vl_api_show_one_stats_enable_disable_reply_t_handler
3359 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3361 vat_main_t *vam = &vat_main;
3362 int retval = clib_net_to_host_u32 (mp->retval);
3367 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3369 vam->retval = retval;
3370 vam->result_ready = 1;
3374 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3375 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3377 vat_main_t *vam = &vat_main;
3378 vat_json_node_t _node, *node = &_node;
3379 int retval = clib_net_to_host_u32 (mp->retval);
3381 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3382 vat_json_init_object (node);
3383 vat_json_object_add_string_copy (node, "state", s);
3385 vat_json_print (vam->ofp, node);
3386 vat_json_free (node);
3388 vam->retval = retval;
3389 vam->result_ready = 1;
3394 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3396 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3397 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3398 e->vni = clib_net_to_host_u32 (e->vni);
3402 gpe_fwd_entries_get_reply_t_net_to_host
3403 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3407 mp->count = clib_net_to_host_u32 (mp->count);
3408 for (i = 0; i < mp->count; i++)
3410 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3415 format_gpe_encap_mode (u8 * s, va_list * args)
3417 u32 mode = va_arg (*args, u32);
3422 return format (s, "lisp");
3424 return format (s, "vxlan");
3430 vl_api_gpe_get_encap_mode_reply_t_handler
3431 (vl_api_gpe_get_encap_mode_reply_t * mp)
3433 vat_main_t *vam = &vat_main;
3435 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3436 vam->retval = ntohl (mp->retval);
3437 vam->result_ready = 1;
3441 vl_api_gpe_get_encap_mode_reply_t_handler_json
3442 (vl_api_gpe_get_encap_mode_reply_t * mp)
3444 vat_main_t *vam = &vat_main;
3445 vat_json_node_t node;
3447 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3448 vec_add1 (encap_mode, 0);
3450 vat_json_init_object (&node);
3451 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3453 vec_free (encap_mode);
3454 vat_json_print (vam->ofp, &node);
3455 vat_json_free (&node);
3457 vam->retval = ntohl (mp->retval);
3458 vam->result_ready = 1;
3462 vl_api_gpe_fwd_entry_path_details_t_handler
3463 (vl_api_gpe_fwd_entry_path_details_t * mp)
3465 vat_main_t *vam = &vat_main;
3466 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3468 if (mp->lcl_loc.is_ip4)
3469 format_ip_address_fcn = format_ip4_address;
3471 format_ip_address_fcn = format_ip6_address;
3473 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3474 format_ip_address_fcn, &mp->lcl_loc,
3475 format_ip_address_fcn, &mp->rmt_loc);
3479 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3481 struct in6_addr ip6;
3486 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3487 vat_json_object_add_ip4 (n, "address", ip4);
3491 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3492 vat_json_object_add_ip6 (n, "address", ip6);
3494 vat_json_object_add_uint (n, "weight", loc->weight);
3498 vl_api_gpe_fwd_entry_path_details_t_handler_json
3499 (vl_api_gpe_fwd_entry_path_details_t * mp)
3501 vat_main_t *vam = &vat_main;
3502 vat_json_node_t *node = NULL;
3503 vat_json_node_t *loc_node;
3505 if (VAT_JSON_ARRAY != vam->json_tree.type)
3507 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3508 vat_json_init_array (&vam->json_tree);
3510 node = vat_json_array_add (&vam->json_tree);
3511 vat_json_init_object (node);
3513 loc_node = vat_json_object_add (node, "local_locator");
3514 vat_json_init_object (loc_node);
3515 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3517 loc_node = vat_json_object_add (node, "remote_locator");
3518 vat_json_init_object (loc_node);
3519 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3523 vl_api_gpe_fwd_entries_get_reply_t_handler
3524 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3526 vat_main_t *vam = &vat_main;
3528 int retval = clib_net_to_host_u32 (mp->retval);
3529 vl_api_gpe_fwd_entry_t *e;
3534 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3536 for (i = 0; i < mp->count; i++)
3538 e = &mp->entries[i];
3539 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3540 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3541 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3545 vam->retval = retval;
3546 vam->result_ready = 1;
3550 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3551 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3554 vat_main_t *vam = &vat_main;
3555 vat_json_node_t *e = 0, root;
3557 int retval = clib_net_to_host_u32 (mp->retval);
3558 vl_api_gpe_fwd_entry_t *fwd;
3563 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3564 vat_json_init_array (&root);
3566 for (i = 0; i < mp->count; i++)
3568 e = vat_json_array_add (&root);
3569 fwd = &mp->entries[i];
3571 vat_json_init_object (e);
3572 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3573 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3574 vat_json_object_add_int (e, "vni", fwd->vni);
3575 vat_json_object_add_int (e, "action", fwd->action);
3577 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3578 fwd->leid_prefix_len);
3580 vat_json_object_add_string_copy (e, "leid", s);
3583 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3584 fwd->reid_prefix_len);
3586 vat_json_object_add_string_copy (e, "reid", s);
3590 vat_json_print (vam->ofp, &root);
3591 vat_json_free (&root);
3594 vam->retval = retval;
3595 vam->result_ready = 1;
3599 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3600 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3602 vat_main_t *vam = &vat_main;
3604 int retval = clib_net_to_host_u32 (mp->retval);
3605 vl_api_gpe_native_fwd_rpath_t *r;
3610 n = clib_net_to_host_u32 (mp->count);
3612 for (i = 0; i < n; i++)
3614 r = &mp->entries[i];
3615 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3616 clib_net_to_host_u32 (r->fib_index),
3617 clib_net_to_host_u32 (r->nh_sw_if_index),
3618 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3622 vam->retval = retval;
3623 vam->result_ready = 1;
3627 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3628 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3630 vat_main_t *vam = &vat_main;
3631 vat_json_node_t root, *e;
3633 int retval = clib_net_to_host_u32 (mp->retval);
3634 vl_api_gpe_native_fwd_rpath_t *r;
3640 n = clib_net_to_host_u32 (mp->count);
3641 vat_json_init_array (&root);
3643 for (i = 0; i < n; i++)
3645 e = vat_json_array_add (&root);
3646 vat_json_init_object (e);
3647 r = &mp->entries[i];
3649 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3652 vat_json_object_add_string_copy (e, "ip4", s);
3655 vat_json_object_add_uint (e, "fib_index",
3656 clib_net_to_host_u32 (r->fib_index));
3657 vat_json_object_add_uint (e, "nh_sw_if_index",
3658 clib_net_to_host_u32 (r->nh_sw_if_index));
3661 vat_json_print (vam->ofp, &root);
3662 vat_json_free (&root);
3665 vam->retval = retval;
3666 vam->result_ready = 1;
3670 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3671 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3673 vat_main_t *vam = &vat_main;
3675 int retval = clib_net_to_host_u32 (mp->retval);
3680 n = clib_net_to_host_u32 (mp->count);
3682 for (i = 0; i < n; i++)
3683 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3686 vam->retval = retval;
3687 vam->result_ready = 1;
3691 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3692 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3694 vat_main_t *vam = &vat_main;
3695 vat_json_node_t root;
3697 int retval = clib_net_to_host_u32 (mp->retval);
3702 n = clib_net_to_host_u32 (mp->count);
3703 vat_json_init_array (&root);
3705 for (i = 0; i < n; i++)
3706 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3708 vat_json_print (vam->ofp, &root);
3709 vat_json_free (&root);
3712 vam->retval = retval;
3713 vam->result_ready = 1;
3717 vl_api_one_ndp_entries_get_reply_t_handler
3718 (vl_api_one_ndp_entries_get_reply_t * mp)
3720 vat_main_t *vam = &vat_main;
3722 int retval = clib_net_to_host_u32 (mp->retval);
3727 n = clib_net_to_host_u32 (mp->count);
3729 for (i = 0; i < n; i++)
3730 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3731 format_ethernet_address, mp->entries[i].mac);
3734 vam->retval = retval;
3735 vam->result_ready = 1;
3739 vl_api_one_ndp_entries_get_reply_t_handler_json
3740 (vl_api_one_ndp_entries_get_reply_t * mp)
3743 vat_main_t *vam = &vat_main;
3744 vat_json_node_t *e = 0, root;
3746 int retval = clib_net_to_host_u32 (mp->retval);
3747 vl_api_one_ndp_entry_t *arp_entry;
3752 n = clib_net_to_host_u32 (mp->count);
3753 vat_json_init_array (&root);
3755 for (i = 0; i < n; i++)
3757 e = vat_json_array_add (&root);
3758 arp_entry = &mp->entries[i];
3760 vat_json_init_object (e);
3761 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3764 vat_json_object_add_string_copy (e, "mac", s);
3767 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3769 vat_json_object_add_string_copy (e, "ip6", s);
3773 vat_json_print (vam->ofp, &root);
3774 vat_json_free (&root);
3777 vam->retval = retval;
3778 vam->result_ready = 1;
3782 vl_api_one_l2_arp_entries_get_reply_t_handler
3783 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3785 vat_main_t *vam = &vat_main;
3787 int retval = clib_net_to_host_u32 (mp->retval);
3792 n = clib_net_to_host_u32 (mp->count);
3794 for (i = 0; i < n; i++)
3795 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3796 format_ethernet_address, mp->entries[i].mac);
3799 vam->retval = retval;
3800 vam->result_ready = 1;
3804 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3805 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3808 vat_main_t *vam = &vat_main;
3809 vat_json_node_t *e = 0, root;
3811 int retval = clib_net_to_host_u32 (mp->retval);
3812 vl_api_one_l2_arp_entry_t *arp_entry;
3817 n = clib_net_to_host_u32 (mp->count);
3818 vat_json_init_array (&root);
3820 for (i = 0; i < n; i++)
3822 e = vat_json_array_add (&root);
3823 arp_entry = &mp->entries[i];
3825 vat_json_init_object (e);
3826 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3829 vat_json_object_add_string_copy (e, "mac", s);
3832 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3834 vat_json_object_add_string_copy (e, "ip4", s);
3838 vat_json_print (vam->ofp, &root);
3839 vat_json_free (&root);
3842 vam->retval = retval;
3843 vam->result_ready = 1;
3847 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3849 vat_main_t *vam = &vat_main;
3851 int retval = clib_net_to_host_u32 (mp->retval);
3856 n = clib_net_to_host_u32 (mp->count);
3858 for (i = 0; i < n; i++)
3860 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3864 vam->retval = retval;
3865 vam->result_ready = 1;
3869 vl_api_one_ndp_bd_get_reply_t_handler_json
3870 (vl_api_one_ndp_bd_get_reply_t * mp)
3872 vat_main_t *vam = &vat_main;
3873 vat_json_node_t root;
3875 int retval = clib_net_to_host_u32 (mp->retval);
3880 n = clib_net_to_host_u32 (mp->count);
3881 vat_json_init_array (&root);
3883 for (i = 0; i < n; i++)
3885 vat_json_array_add_uint (&root,
3886 clib_net_to_host_u32 (mp->bridge_domains[i]));
3889 vat_json_print (vam->ofp, &root);
3890 vat_json_free (&root);
3893 vam->retval = retval;
3894 vam->result_ready = 1;
3898 vl_api_one_l2_arp_bd_get_reply_t_handler
3899 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3901 vat_main_t *vam = &vat_main;
3903 int retval = clib_net_to_host_u32 (mp->retval);
3908 n = clib_net_to_host_u32 (mp->count);
3910 for (i = 0; i < n; i++)
3912 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3916 vam->retval = retval;
3917 vam->result_ready = 1;
3921 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3922 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3924 vat_main_t *vam = &vat_main;
3925 vat_json_node_t root;
3927 int retval = clib_net_to_host_u32 (mp->retval);
3932 n = clib_net_to_host_u32 (mp->count);
3933 vat_json_init_array (&root);
3935 for (i = 0; i < n; i++)
3937 vat_json_array_add_uint (&root,
3938 clib_net_to_host_u32 (mp->bridge_domains[i]));
3941 vat_json_print (vam->ofp, &root);
3942 vat_json_free (&root);
3945 vam->retval = retval;
3946 vam->result_ready = 1;
3950 vl_api_one_adjacencies_get_reply_t_handler
3951 (vl_api_one_adjacencies_get_reply_t * mp)
3953 vat_main_t *vam = &vat_main;
3955 int retval = clib_net_to_host_u32 (mp->retval);
3956 vl_api_one_adjacency_t *a;
3961 n = clib_net_to_host_u32 (mp->count);
3963 for (i = 0; i < n; i++)
3965 a = &mp->adjacencies[i];
3966 print (vam->ofp, "%U %40U",
3967 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3968 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3972 vam->retval = retval;
3973 vam->result_ready = 1;
3977 vl_api_one_adjacencies_get_reply_t_handler_json
3978 (vl_api_one_adjacencies_get_reply_t * mp)
3981 vat_main_t *vam = &vat_main;
3982 vat_json_node_t *e = 0, root;
3984 int retval = clib_net_to_host_u32 (mp->retval);
3985 vl_api_one_adjacency_t *a;
3990 n = clib_net_to_host_u32 (mp->count);
3991 vat_json_init_array (&root);
3993 for (i = 0; i < n; i++)
3995 e = vat_json_array_add (&root);
3996 a = &mp->adjacencies[i];
3998 vat_json_init_object (e);
3999 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4000 a->leid_prefix_len);
4002 vat_json_object_add_string_copy (e, "leid", s);
4005 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4006 a->reid_prefix_len);
4008 vat_json_object_add_string_copy (e, "reid", s);
4012 vat_json_print (vam->ofp, &root);
4013 vat_json_free (&root);
4016 vam->retval = retval;
4017 vam->result_ready = 1;
4021 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4023 vat_main_t *vam = &vat_main;
4025 print (vam->ofp, "%=20U",
4026 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4031 vl_api_one_map_server_details_t_handler_json
4032 (vl_api_one_map_server_details_t * mp)
4034 vat_main_t *vam = &vat_main;
4035 vat_json_node_t *node = NULL;
4036 struct in6_addr ip6;
4039 if (VAT_JSON_ARRAY != vam->json_tree.type)
4041 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4042 vat_json_init_array (&vam->json_tree);
4044 node = vat_json_array_add (&vam->json_tree);
4046 vat_json_init_object (node);
4049 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4050 vat_json_object_add_ip6 (node, "map-server", ip6);
4054 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4055 vat_json_object_add_ip4 (node, "map-server", ip4);
4060 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4063 vat_main_t *vam = &vat_main;
4065 print (vam->ofp, "%=20U",
4066 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4071 vl_api_one_map_resolver_details_t_handler_json
4072 (vl_api_one_map_resolver_details_t * mp)
4074 vat_main_t *vam = &vat_main;
4075 vat_json_node_t *node = NULL;
4076 struct in6_addr ip6;
4079 if (VAT_JSON_ARRAY != vam->json_tree.type)
4081 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4082 vat_json_init_array (&vam->json_tree);
4084 node = vat_json_array_add (&vam->json_tree);
4086 vat_json_init_object (node);
4089 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4090 vat_json_object_add_ip6 (node, "map resolver", ip6);
4094 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4095 vat_json_object_add_ip4 (node, "map resolver", ip4);
4100 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4102 vat_main_t *vam = &vat_main;
4103 i32 retval = ntohl (mp->retval);
4107 print (vam->ofp, "feature: %s\ngpe: %s",
4108 mp->feature_status ? "enabled" : "disabled",
4109 mp->gpe_status ? "enabled" : "disabled");
4112 vam->retval = retval;
4113 vam->result_ready = 1;
4117 vl_api_show_one_status_reply_t_handler_json
4118 (vl_api_show_one_status_reply_t * mp)
4120 vat_main_t *vam = &vat_main;
4121 vat_json_node_t node;
4122 u8 *gpe_status = NULL;
4123 u8 *feature_status = NULL;
4125 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4126 feature_status = format (0, "%s",
4127 mp->feature_status ? "enabled" : "disabled");
4128 vec_add1 (gpe_status, 0);
4129 vec_add1 (feature_status, 0);
4131 vat_json_init_object (&node);
4132 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4133 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4135 vec_free (gpe_status);
4136 vec_free (feature_status);
4138 vat_json_print (vam->ofp, &node);
4139 vat_json_free (&node);
4141 vam->retval = ntohl (mp->retval);
4142 vam->result_ready = 1;
4146 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4147 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4149 vat_main_t *vam = &vat_main;
4150 i32 retval = ntohl (mp->retval);
4154 print (vam->ofp, "%=20s", mp->locator_set_name);
4157 vam->retval = retval;
4158 vam->result_ready = 1;
4162 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4163 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4165 vat_main_t *vam = &vat_main;
4166 vat_json_node_t *node = NULL;
4168 if (VAT_JSON_ARRAY != vam->json_tree.type)
4170 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4171 vat_json_init_array (&vam->json_tree);
4173 node = vat_json_array_add (&vam->json_tree);
4175 vat_json_init_object (node);
4176 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4178 vat_json_print (vam->ofp, node);
4179 vat_json_free (node);
4181 vam->retval = ntohl (mp->retval);
4182 vam->result_ready = 1;
4186 format_lisp_map_request_mode (u8 * s, va_list * args)
4188 u32 mode = va_arg (*args, u32);
4193 return format (0, "dst-only");
4195 return format (0, "src-dst");
4201 vl_api_show_one_map_request_mode_reply_t_handler
4202 (vl_api_show_one_map_request_mode_reply_t * mp)
4204 vat_main_t *vam = &vat_main;
4205 i32 retval = ntohl (mp->retval);
4209 u32 mode = mp->mode;
4210 print (vam->ofp, "map_request_mode: %U",
4211 format_lisp_map_request_mode, mode);
4214 vam->retval = retval;
4215 vam->result_ready = 1;
4219 vl_api_show_one_map_request_mode_reply_t_handler_json
4220 (vl_api_show_one_map_request_mode_reply_t * mp)
4222 vat_main_t *vam = &vat_main;
4223 vat_json_node_t node;
4228 s = format (0, "%U", format_lisp_map_request_mode, mode);
4231 vat_json_init_object (&node);
4232 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4233 vat_json_print (vam->ofp, &node);
4234 vat_json_free (&node);
4237 vam->retval = ntohl (mp->retval);
4238 vam->result_ready = 1;
4242 vl_api_one_show_xtr_mode_reply_t_handler
4243 (vl_api_one_show_xtr_mode_reply_t * mp)
4245 vat_main_t *vam = &vat_main;
4246 i32 retval = ntohl (mp->retval);
4250 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4253 vam->retval = retval;
4254 vam->result_ready = 1;
4258 vl_api_one_show_xtr_mode_reply_t_handler_json
4259 (vl_api_one_show_xtr_mode_reply_t * mp)
4261 vat_main_t *vam = &vat_main;
4262 vat_json_node_t node;
4265 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4266 vec_add1 (status, 0);
4268 vat_json_init_object (&node);
4269 vat_json_object_add_string_copy (&node, "status", status);
4273 vat_json_print (vam->ofp, &node);
4274 vat_json_free (&node);
4276 vam->retval = ntohl (mp->retval);
4277 vam->result_ready = 1;
4281 vl_api_one_show_pitr_mode_reply_t_handler
4282 (vl_api_one_show_pitr_mode_reply_t * mp)
4284 vat_main_t *vam = &vat_main;
4285 i32 retval = ntohl (mp->retval);
4289 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4292 vam->retval = retval;
4293 vam->result_ready = 1;
4297 vl_api_one_show_pitr_mode_reply_t_handler_json
4298 (vl_api_one_show_pitr_mode_reply_t * mp)
4300 vat_main_t *vam = &vat_main;
4301 vat_json_node_t node;
4304 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4305 vec_add1 (status, 0);
4307 vat_json_init_object (&node);
4308 vat_json_object_add_string_copy (&node, "status", status);
4312 vat_json_print (vam->ofp, &node);
4313 vat_json_free (&node);
4315 vam->retval = ntohl (mp->retval);
4316 vam->result_ready = 1;
4320 vl_api_one_show_petr_mode_reply_t_handler
4321 (vl_api_one_show_petr_mode_reply_t * mp)
4323 vat_main_t *vam = &vat_main;
4324 i32 retval = ntohl (mp->retval);
4328 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4331 vam->retval = retval;
4332 vam->result_ready = 1;
4336 vl_api_one_show_petr_mode_reply_t_handler_json
4337 (vl_api_one_show_petr_mode_reply_t * mp)
4339 vat_main_t *vam = &vat_main;
4340 vat_json_node_t node;
4343 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4344 vec_add1 (status, 0);
4346 vat_json_init_object (&node);
4347 vat_json_object_add_string_copy (&node, "status", status);
4351 vat_json_print (vam->ofp, &node);
4352 vat_json_free (&node);
4354 vam->retval = ntohl (mp->retval);
4355 vam->result_ready = 1;
4359 vl_api_show_one_use_petr_reply_t_handler
4360 (vl_api_show_one_use_petr_reply_t * mp)
4362 vat_main_t *vam = &vat_main;
4363 i32 retval = ntohl (mp->retval);
4367 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4370 print (vam->ofp, "Proxy-ETR address; %U",
4371 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4376 vam->retval = retval;
4377 vam->result_ready = 1;
4381 vl_api_show_one_use_petr_reply_t_handler_json
4382 (vl_api_show_one_use_petr_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 vat_json_node_t node;
4388 struct in6_addr ip6;
4390 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4391 vec_add1 (status, 0);
4393 vat_json_init_object (&node);
4394 vat_json_object_add_string_copy (&node, "status", status);
4399 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4400 vat_json_object_add_ip6 (&node, "address", ip6);
4404 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4405 vat_json_object_add_ip4 (&node, "address", ip4);
4411 vat_json_print (vam->ofp, &node);
4412 vat_json_free (&node);
4414 vam->retval = ntohl (mp->retval);
4415 vam->result_ready = 1;
4419 vl_api_show_one_nsh_mapping_reply_t_handler
4420 (vl_api_show_one_nsh_mapping_reply_t * mp)
4422 vat_main_t *vam = &vat_main;
4423 i32 retval = ntohl (mp->retval);
4427 print (vam->ofp, "%-20s%-16s",
4428 mp->is_set ? "set" : "not-set",
4429 mp->is_set ? (char *) mp->locator_set_name : "");
4432 vam->retval = retval;
4433 vam->result_ready = 1;
4437 vl_api_show_one_nsh_mapping_reply_t_handler_json
4438 (vl_api_show_one_nsh_mapping_reply_t * mp)
4440 vat_main_t *vam = &vat_main;
4441 vat_json_node_t node;
4444 status = format (0, "%s", mp->is_set ? "yes" : "no");
4445 vec_add1 (status, 0);
4447 vat_json_init_object (&node);
4448 vat_json_object_add_string_copy (&node, "is_set", status);
4451 vat_json_object_add_string_copy (&node, "locator_set",
4452 mp->locator_set_name);
4457 vat_json_print (vam->ofp, &node);
4458 vat_json_free (&node);
4460 vam->retval = ntohl (mp->retval);
4461 vam->result_ready = 1;
4465 vl_api_show_one_map_register_ttl_reply_t_handler
4466 (vl_api_show_one_map_register_ttl_reply_t * mp)
4468 vat_main_t *vam = &vat_main;
4469 i32 retval = ntohl (mp->retval);
4471 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4475 print (vam->ofp, "ttl: %u", mp->ttl);
4478 vam->retval = retval;
4479 vam->result_ready = 1;
4483 vl_api_show_one_map_register_ttl_reply_t_handler_json
4484 (vl_api_show_one_map_register_ttl_reply_t * mp)
4486 vat_main_t *vam = &vat_main;
4487 vat_json_node_t node;
4489 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4490 vat_json_init_object (&node);
4491 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4493 vat_json_print (vam->ofp, &node);
4494 vat_json_free (&node);
4496 vam->retval = ntohl (mp->retval);
4497 vam->result_ready = 1;
4501 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4503 vat_main_t *vam = &vat_main;
4504 i32 retval = ntohl (mp->retval);
4508 print (vam->ofp, "%-20s%-16s",
4509 mp->status ? "enabled" : "disabled",
4510 mp->status ? (char *) mp->locator_set_name : "");
4513 vam->retval = retval;
4514 vam->result_ready = 1;
4518 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4520 vat_main_t *vam = &vat_main;
4521 vat_json_node_t node;
4524 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4525 vec_add1 (status, 0);
4527 vat_json_init_object (&node);
4528 vat_json_object_add_string_copy (&node, "status", status);
4531 vat_json_object_add_string_copy (&node, "locator_set",
4532 mp->locator_set_name);
4537 vat_json_print (vam->ofp, &node);
4538 vat_json_free (&node);
4540 vam->retval = ntohl (mp->retval);
4541 vam->result_ready = 1;
4545 format_policer_type (u8 * s, va_list * va)
4547 u32 i = va_arg (*va, u32);
4549 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4550 s = format (s, "1r2c");
4551 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4552 s = format (s, "1r3c");
4553 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4554 s = format (s, "2r3c-2698");
4555 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4556 s = format (s, "2r3c-4115");
4557 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4558 s = format (s, "2r3c-mef5cf1");
4560 s = format (s, "ILLEGAL");
4565 format_policer_rate_type (u8 * s, va_list * va)
4567 u32 i = va_arg (*va, u32);
4569 if (i == SSE2_QOS_RATE_KBPS)
4570 s = format (s, "kbps");
4571 else if (i == SSE2_QOS_RATE_PPS)
4572 s = format (s, "pps");
4574 s = format (s, "ILLEGAL");
4579 format_policer_round_type (u8 * s, va_list * va)
4581 u32 i = va_arg (*va, u32);
4583 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4584 s = format (s, "closest");
4585 else if (i == SSE2_QOS_ROUND_TO_UP)
4586 s = format (s, "up");
4587 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4588 s = format (s, "down");
4590 s = format (s, "ILLEGAL");
4595 format_policer_action_type (u8 * s, va_list * va)
4597 u32 i = va_arg (*va, u32);
4599 if (i == SSE2_QOS_ACTION_DROP)
4600 s = format (s, "drop");
4601 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4602 s = format (s, "transmit");
4603 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4604 s = format (s, "mark-and-transmit");
4606 s = format (s, "ILLEGAL");
4611 format_dscp (u8 * s, va_list * va)
4613 u32 i = va_arg (*va, u32);
4618 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4622 return format (s, "ILLEGAL");
4624 s = format (s, "%s", t);
4629 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4631 vat_main_t *vam = &vat_main;
4632 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4634 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4635 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4637 conform_dscp_str = format (0, "");
4639 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4640 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4642 exceed_dscp_str = format (0, "");
4644 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4645 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4647 violate_dscp_str = format (0, "");
4649 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4650 "rate type %U, round type %U, %s rate, %s color-aware, "
4651 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4652 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4653 "conform action %U%s, exceed action %U%s, violate action %U%s",
4655 format_policer_type, mp->type,
4658 clib_net_to_host_u64 (mp->cb),
4659 clib_net_to_host_u64 (mp->eb),
4660 format_policer_rate_type, mp->rate_type,
4661 format_policer_round_type, mp->round_type,
4662 mp->single_rate ? "single" : "dual",
4663 mp->color_aware ? "is" : "not",
4664 ntohl (mp->cir_tokens_per_period),
4665 ntohl (mp->pir_tokens_per_period),
4667 ntohl (mp->current_limit),
4668 ntohl (mp->current_bucket),
4669 ntohl (mp->extended_limit),
4670 ntohl (mp->extended_bucket),
4671 clib_net_to_host_u64 (mp->last_update_time),
4672 format_policer_action_type, mp->conform_action_type,
4674 format_policer_action_type, mp->exceed_action_type,
4676 format_policer_action_type, mp->violate_action_type,
4679 vec_free (conform_dscp_str);
4680 vec_free (exceed_dscp_str);
4681 vec_free (violate_dscp_str);
4684 static void vl_api_policer_details_t_handler_json
4685 (vl_api_policer_details_t * mp)
4687 vat_main_t *vam = &vat_main;
4688 vat_json_node_t *node;
4689 u8 *rate_type_str, *round_type_str, *type_str;
4690 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4692 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4694 format (0, "%U", format_policer_round_type, mp->round_type);
4695 type_str = format (0, "%U", format_policer_type, mp->type);
4696 conform_action_str = format (0, "%U", format_policer_action_type,
4697 mp->conform_action_type);
4698 exceed_action_str = format (0, "%U", format_policer_action_type,
4699 mp->exceed_action_type);
4700 violate_action_str = format (0, "%U", format_policer_action_type,
4701 mp->violate_action_type);
4703 if (VAT_JSON_ARRAY != vam->json_tree.type)
4705 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4706 vat_json_init_array (&vam->json_tree);
4708 node = vat_json_array_add (&vam->json_tree);
4710 vat_json_init_object (node);
4711 vat_json_object_add_string_copy (node, "name", mp->name);
4712 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4713 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4714 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4715 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4716 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4717 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4718 vat_json_object_add_string_copy (node, "type", type_str);
4719 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4720 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4721 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4722 vat_json_object_add_uint (node, "cir_tokens_per_period",
4723 ntohl (mp->cir_tokens_per_period));
4724 vat_json_object_add_uint (node, "eir_tokens_per_period",
4725 ntohl (mp->pir_tokens_per_period));
4726 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4727 vat_json_object_add_uint (node, "current_bucket",
4728 ntohl (mp->current_bucket));
4729 vat_json_object_add_uint (node, "extended_limit",
4730 ntohl (mp->extended_limit));
4731 vat_json_object_add_uint (node, "extended_bucket",
4732 ntohl (mp->extended_bucket));
4733 vat_json_object_add_uint (node, "last_update_time",
4734 ntohl (mp->last_update_time));
4735 vat_json_object_add_string_copy (node, "conform_action",
4736 conform_action_str);
4737 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4739 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4740 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4741 vec_free (dscp_str);
4743 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4744 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4746 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4747 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4748 vec_free (dscp_str);
4750 vat_json_object_add_string_copy (node, "violate_action",
4751 violate_action_str);
4752 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4754 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4755 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4756 vec_free (dscp_str);
4759 vec_free (rate_type_str);
4760 vec_free (round_type_str);
4761 vec_free (type_str);
4762 vec_free (conform_action_str);
4763 vec_free (exceed_action_str);
4764 vec_free (violate_action_str);
4768 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4771 vat_main_t *vam = &vat_main;
4772 int i, count = ntohl (mp->count);
4775 print (vam->ofp, "classify table ids (%d) : ", count);
4776 for (i = 0; i < count; i++)
4778 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4779 print (vam->ofp, (i < count - 1) ? "," : "");
4781 vam->retval = ntohl (mp->retval);
4782 vam->result_ready = 1;
4786 vl_api_classify_table_ids_reply_t_handler_json
4787 (vl_api_classify_table_ids_reply_t * mp)
4789 vat_main_t *vam = &vat_main;
4790 int i, count = ntohl (mp->count);
4794 vat_json_node_t node;
4796 vat_json_init_object (&node);
4797 for (i = 0; i < count; i++)
4799 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4801 vat_json_print (vam->ofp, &node);
4802 vat_json_free (&node);
4804 vam->retval = ntohl (mp->retval);
4805 vam->result_ready = 1;
4809 vl_api_classify_table_by_interface_reply_t_handler
4810 (vl_api_classify_table_by_interface_reply_t * mp)
4812 vat_main_t *vam = &vat_main;
4815 table_id = ntohl (mp->l2_table_id);
4817 print (vam->ofp, "l2 table id : %d", table_id);
4819 print (vam->ofp, "l2 table id : No input ACL tables configured");
4820 table_id = ntohl (mp->ip4_table_id);
4822 print (vam->ofp, "ip4 table id : %d", table_id);
4824 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4825 table_id = ntohl (mp->ip6_table_id);
4827 print (vam->ofp, "ip6 table id : %d", table_id);
4829 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4830 vam->retval = ntohl (mp->retval);
4831 vam->result_ready = 1;
4835 vl_api_classify_table_by_interface_reply_t_handler_json
4836 (vl_api_classify_table_by_interface_reply_t * mp)
4838 vat_main_t *vam = &vat_main;
4839 vat_json_node_t node;
4841 vat_json_init_object (&node);
4843 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4844 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4845 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4847 vat_json_print (vam->ofp, &node);
4848 vat_json_free (&node);
4850 vam->retval = ntohl (mp->retval);
4851 vam->result_ready = 1;
4854 static void vl_api_policer_add_del_reply_t_handler
4855 (vl_api_policer_add_del_reply_t * mp)
4857 vat_main_t *vam = &vat_main;
4858 i32 retval = ntohl (mp->retval);
4859 if (vam->async_mode)
4861 vam->async_errors += (retval < 0);
4865 vam->retval = retval;
4866 vam->result_ready = 1;
4867 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4869 * Note: this is just barely thread-safe, depends on
4870 * the main thread spinning waiting for an answer...
4872 errmsg ("policer index %d", ntohl (mp->policer_index));
4876 static void vl_api_policer_add_del_reply_t_handler_json
4877 (vl_api_policer_add_del_reply_t * mp)
4879 vat_main_t *vam = &vat_main;
4880 vat_json_node_t node;
4882 vat_json_init_object (&node);
4883 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4884 vat_json_object_add_uint (&node, "policer_index",
4885 ntohl (mp->policer_index));
4887 vat_json_print (vam->ofp, &node);
4888 vat_json_free (&node);
4890 vam->retval = ntohl (mp->retval);
4891 vam->result_ready = 1;
4894 /* Format hex dump. */
4896 format_hex_bytes (u8 * s, va_list * va)
4898 u8 *bytes = va_arg (*va, u8 *);
4899 int n_bytes = va_arg (*va, int);
4902 /* Print short or long form depending on byte count. */
4903 uword short_form = n_bytes <= 32;
4904 u32 indent = format_get_indent (s);
4909 for (i = 0; i < n_bytes; i++)
4911 if (!short_form && (i % 32) == 0)
4912 s = format (s, "%08x: ", i);
4913 s = format (s, "%02x", bytes[i]);
4914 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4915 s = format (s, "\n%U", format_white_space, indent);
4922 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4925 vat_main_t *vam = &vat_main;
4926 i32 retval = ntohl (mp->retval);
4929 print (vam->ofp, "classify table info :");
4930 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4931 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4932 ntohl (mp->miss_next_index));
4933 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4934 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4935 ntohl (mp->match_n_vectors));
4936 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4937 ntohl (mp->mask_length));
4939 vam->retval = retval;
4940 vam->result_ready = 1;
4944 vl_api_classify_table_info_reply_t_handler_json
4945 (vl_api_classify_table_info_reply_t * mp)
4947 vat_main_t *vam = &vat_main;
4948 vat_json_node_t node;
4950 i32 retval = ntohl (mp->retval);
4953 vat_json_init_object (&node);
4955 vat_json_object_add_int (&node, "sessions",
4956 ntohl (mp->active_sessions));
4957 vat_json_object_add_int (&node, "nexttbl",
4958 ntohl (mp->next_table_index));
4959 vat_json_object_add_int (&node, "nextnode",
4960 ntohl (mp->miss_next_index));
4961 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4962 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4963 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4964 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4965 ntohl (mp->mask_length), 0);
4966 vat_json_object_add_string_copy (&node, "mask", s);
4968 vat_json_print (vam->ofp, &node);
4969 vat_json_free (&node);
4971 vam->retval = ntohl (mp->retval);
4972 vam->result_ready = 1;
4976 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4979 vat_main_t *vam = &vat_main;
4981 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4982 ntohl (mp->hit_next_index), ntohl (mp->advance),
4983 ntohl (mp->opaque_index));
4984 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4985 ntohl (mp->match_length));
4989 vl_api_classify_session_details_t_handler_json
4990 (vl_api_classify_session_details_t * mp)
4992 vat_main_t *vam = &vat_main;
4993 vat_json_node_t *node = NULL;
4995 if (VAT_JSON_ARRAY != vam->json_tree.type)
4997 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4998 vat_json_init_array (&vam->json_tree);
5000 node = vat_json_array_add (&vam->json_tree);
5002 vat_json_init_object (node);
5003 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5004 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5005 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5007 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5009 vat_json_object_add_string_copy (node, "match", s);
5012 static void vl_api_pg_create_interface_reply_t_handler
5013 (vl_api_pg_create_interface_reply_t * mp)
5015 vat_main_t *vam = &vat_main;
5017 vam->retval = ntohl (mp->retval);
5018 vam->result_ready = 1;
5021 static void vl_api_pg_create_interface_reply_t_handler_json
5022 (vl_api_pg_create_interface_reply_t * mp)
5024 vat_main_t *vam = &vat_main;
5025 vat_json_node_t node;
5027 i32 retval = ntohl (mp->retval);
5030 vat_json_init_object (&node);
5032 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5034 vat_json_print (vam->ofp, &node);
5035 vat_json_free (&node);
5037 vam->retval = ntohl (mp->retval);
5038 vam->result_ready = 1;
5041 static void vl_api_policer_classify_details_t_handler
5042 (vl_api_policer_classify_details_t * mp)
5044 vat_main_t *vam = &vat_main;
5046 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5047 ntohl (mp->table_index));
5050 static void vl_api_policer_classify_details_t_handler_json
5051 (vl_api_policer_classify_details_t * mp)
5053 vat_main_t *vam = &vat_main;
5054 vat_json_node_t *node;
5056 if (VAT_JSON_ARRAY != vam->json_tree.type)
5058 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5059 vat_json_init_array (&vam->json_tree);
5061 node = vat_json_array_add (&vam->json_tree);
5063 vat_json_init_object (node);
5064 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5065 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5068 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5069 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5071 vat_main_t *vam = &vat_main;
5072 i32 retval = ntohl (mp->retval);
5073 if (vam->async_mode)
5075 vam->async_errors += (retval < 0);
5079 vam->retval = retval;
5080 vam->sw_if_index = ntohl (mp->sw_if_index);
5081 vam->result_ready = 1;
5085 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5086 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5088 vat_main_t *vam = &vat_main;
5089 vat_json_node_t node;
5091 vat_json_init_object (&node);
5092 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5093 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5095 vat_json_print (vam->ofp, &node);
5096 vat_json_free (&node);
5098 vam->retval = ntohl (mp->retval);
5099 vam->result_ready = 1;
5102 static void vl_api_flow_classify_details_t_handler
5103 (vl_api_flow_classify_details_t * mp)
5105 vat_main_t *vam = &vat_main;
5107 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5108 ntohl (mp->table_index));
5111 static void vl_api_flow_classify_details_t_handler_json
5112 (vl_api_flow_classify_details_t * mp)
5114 vat_main_t *vam = &vat_main;
5115 vat_json_node_t *node;
5117 if (VAT_JSON_ARRAY != vam->json_tree.type)
5119 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5120 vat_json_init_array (&vam->json_tree);
5122 node = vat_json_array_add (&vam->json_tree);
5124 vat_json_init_object (node);
5125 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5126 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5129 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5130 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5131 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5132 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5133 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5134 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5135 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5136 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5137 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5138 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5139 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5140 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5141 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5142 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5143 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5144 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5145 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5146 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5147 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5148 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5149 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5150 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5153 * Generate boilerplate reply handlers, which
5154 * dig the return value out of the xxx_reply_t API message,
5155 * stick it into vam->retval, and set vam->result_ready
5157 * Could also do this by pointing N message decode slots at
5158 * a single function, but that could break in subtle ways.
5161 #define foreach_standard_reply_retval_handler \
5162 _(sw_interface_set_flags_reply) \
5163 _(sw_interface_add_del_address_reply) \
5164 _(sw_interface_set_rx_mode_reply) \
5165 _(sw_interface_set_table_reply) \
5166 _(sw_interface_set_mpls_enable_reply) \
5167 _(sw_interface_set_vpath_reply) \
5168 _(sw_interface_set_vxlan_bypass_reply) \
5169 _(sw_interface_set_geneve_bypass_reply) \
5170 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5171 _(sw_interface_set_l2_bridge_reply) \
5172 _(bridge_domain_add_del_reply) \
5173 _(sw_interface_set_l2_xconnect_reply) \
5174 _(l2fib_add_del_reply) \
5175 _(l2fib_flush_int_reply) \
5176 _(l2fib_flush_bd_reply) \
5177 _(ip_add_del_route_reply) \
5178 _(ip_table_add_del_reply) \
5179 _(ip_mroute_add_del_reply) \
5180 _(mpls_route_add_del_reply) \
5181 _(mpls_table_add_del_reply) \
5182 _(mpls_ip_bind_unbind_reply) \
5183 _(proxy_arp_add_del_reply) \
5184 _(proxy_arp_intfc_enable_disable_reply) \
5185 _(sw_interface_set_unnumbered_reply) \
5186 _(ip_neighbor_add_del_reply) \
5187 _(reset_vrf_reply) \
5188 _(oam_add_del_reply) \
5189 _(reset_fib_reply) \
5190 _(dhcp_proxy_config_reply) \
5191 _(dhcp_proxy_set_vss_reply) \
5192 _(dhcp_client_config_reply) \
5193 _(set_ip_flow_hash_reply) \
5194 _(sw_interface_ip6_enable_disable_reply) \
5195 _(sw_interface_ip6_set_link_local_address_reply) \
5196 _(ip6nd_proxy_add_del_reply) \
5197 _(sw_interface_ip6nd_ra_prefix_reply) \
5198 _(sw_interface_ip6nd_ra_config_reply) \
5199 _(set_arp_neighbor_limit_reply) \
5200 _(l2_patch_add_del_reply) \
5201 _(sr_policy_add_reply) \
5202 _(sr_policy_mod_reply) \
5203 _(sr_policy_del_reply) \
5204 _(sr_localsid_add_del_reply) \
5205 _(sr_steering_add_del_reply) \
5206 _(classify_add_del_session_reply) \
5207 _(classify_set_interface_ip_table_reply) \
5208 _(classify_set_interface_l2_tables_reply) \
5209 _(l2tpv3_set_tunnel_cookies_reply) \
5210 _(l2tpv3_interface_enable_disable_reply) \
5211 _(l2tpv3_set_lookup_key_reply) \
5212 _(l2_fib_clear_table_reply) \
5213 _(l2_interface_efp_filter_reply) \
5214 _(l2_interface_vlan_tag_rewrite_reply) \
5215 _(modify_vhost_user_if_reply) \
5216 _(delete_vhost_user_if_reply) \
5217 _(want_ip4_arp_events_reply) \
5218 _(want_ip6_nd_events_reply) \
5219 _(want_l2_macs_events_reply) \
5220 _(input_acl_set_interface_reply) \
5221 _(ipsec_spd_add_del_reply) \
5222 _(ipsec_interface_add_del_spd_reply) \
5223 _(ipsec_spd_add_del_entry_reply) \
5224 _(ipsec_sad_add_del_entry_reply) \
5225 _(ipsec_sa_set_key_reply) \
5226 _(ipsec_tunnel_if_add_del_reply) \
5227 _(ipsec_tunnel_if_set_key_reply) \
5228 _(ipsec_tunnel_if_set_sa_reply) \
5229 _(ikev2_profile_add_del_reply) \
5230 _(ikev2_profile_set_auth_reply) \
5231 _(ikev2_profile_set_id_reply) \
5232 _(ikev2_profile_set_ts_reply) \
5233 _(ikev2_set_local_key_reply) \
5234 _(ikev2_set_responder_reply) \
5235 _(ikev2_set_ike_transforms_reply) \
5236 _(ikev2_set_esp_transforms_reply) \
5237 _(ikev2_set_sa_lifetime_reply) \
5238 _(ikev2_initiate_sa_init_reply) \
5239 _(ikev2_initiate_del_ike_sa_reply) \
5240 _(ikev2_initiate_del_child_sa_reply) \
5241 _(ikev2_initiate_rekey_child_sa_reply) \
5242 _(delete_loopback_reply) \
5243 _(bd_ip_mac_add_del_reply) \
5244 _(map_del_domain_reply) \
5245 _(map_add_del_rule_reply) \
5246 _(want_interface_events_reply) \
5247 _(want_stats_reply) \
5248 _(cop_interface_enable_disable_reply) \
5249 _(cop_whitelist_enable_disable_reply) \
5250 _(sw_interface_clear_stats_reply) \
5251 _(ioam_enable_reply) \
5252 _(ioam_disable_reply) \
5253 _(one_add_del_locator_reply) \
5254 _(one_add_del_local_eid_reply) \
5255 _(one_add_del_remote_mapping_reply) \
5256 _(one_add_del_adjacency_reply) \
5257 _(one_add_del_map_resolver_reply) \
5258 _(one_add_del_map_server_reply) \
5259 _(one_enable_disable_reply) \
5260 _(one_rloc_probe_enable_disable_reply) \
5261 _(one_map_register_enable_disable_reply) \
5262 _(one_map_register_set_ttl_reply) \
5263 _(one_set_transport_protocol_reply) \
5264 _(one_map_register_fallback_threshold_reply) \
5265 _(one_pitr_set_locator_set_reply) \
5266 _(one_map_request_mode_reply) \
5267 _(one_add_del_map_request_itr_rlocs_reply) \
5268 _(one_eid_table_add_del_map_reply) \
5269 _(one_use_petr_reply) \
5270 _(one_stats_enable_disable_reply) \
5271 _(one_add_del_l2_arp_entry_reply) \
5272 _(one_add_del_ndp_entry_reply) \
5273 _(one_stats_flush_reply) \
5274 _(one_enable_disable_xtr_mode_reply) \
5275 _(one_enable_disable_pitr_mode_reply) \
5276 _(one_enable_disable_petr_mode_reply) \
5277 _(gpe_enable_disable_reply) \
5278 _(gpe_set_encap_mode_reply) \
5279 _(gpe_add_del_iface_reply) \
5280 _(gpe_add_del_native_fwd_rpath_reply) \
5281 _(af_packet_delete_reply) \
5282 _(policer_classify_set_interface_reply) \
5283 _(netmap_create_reply) \
5284 _(netmap_delete_reply) \
5285 _(set_ipfix_exporter_reply) \
5286 _(set_ipfix_classify_stream_reply) \
5287 _(ipfix_classify_table_add_del_reply) \
5288 _(flow_classify_set_interface_reply) \
5289 _(sw_interface_span_enable_disable_reply) \
5290 _(pg_capture_reply) \
5291 _(pg_enable_disable_reply) \
5292 _(ip_source_and_port_range_check_add_del_reply) \
5293 _(ip_source_and_port_range_check_interface_add_del_reply)\
5294 _(delete_subif_reply) \
5295 _(l2_interface_pbb_tag_rewrite_reply) \
5297 _(feature_enable_disable_reply) \
5298 _(sw_interface_tag_add_del_reply) \
5299 _(sw_interface_set_mtu_reply) \
5300 _(p2p_ethernet_add_reply) \
5301 _(p2p_ethernet_del_reply) \
5302 _(lldp_config_reply) \
5303 _(sw_interface_set_lldp_reply) \
5304 _(tcp_configure_src_addresses_reply) \
5305 _(app_namespace_add_del_reply) \
5306 _(dns_enable_disable_reply) \
5307 _(dns_name_server_add_del_reply) \
5308 _(session_rule_add_del_reply)
5311 static void vl_api_##n##_t_handler \
5312 (vl_api_##n##_t * mp) \
5314 vat_main_t * vam = &vat_main; \
5315 i32 retval = ntohl(mp->retval); \
5316 if (vam->async_mode) { \
5317 vam->async_errors += (retval < 0); \
5319 vam->retval = retval; \
5320 vam->result_ready = 1; \
5323 foreach_standard_reply_retval_handler;
5327 static void vl_api_##n##_t_handler_json \
5328 (vl_api_##n##_t * mp) \
5330 vat_main_t * vam = &vat_main; \
5331 vat_json_node_t node; \
5332 vat_json_init_object(&node); \
5333 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5334 vat_json_print(vam->ofp, &node); \
5335 vam->retval = ntohl(mp->retval); \
5336 vam->result_ready = 1; \
5338 foreach_standard_reply_retval_handler;
5342 * Table of message reply handlers, must include boilerplate handlers
5346 #define foreach_vpe_api_reply_msg \
5347 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5348 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5349 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5350 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5351 _(CONTROL_PING_REPLY, control_ping_reply) \
5352 _(CLI_REPLY, cli_reply) \
5353 _(CLI_INBAND_REPLY, cli_inband_reply) \
5354 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5355 sw_interface_add_del_address_reply) \
5356 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5357 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5358 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5359 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5360 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5361 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5362 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5363 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5364 sw_interface_set_l2_xconnect_reply) \
5365 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5366 sw_interface_set_l2_bridge_reply) \
5367 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5368 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5369 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5370 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5371 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5372 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5373 _(L2_FLAGS_REPLY, l2_flags_reply) \
5374 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5375 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5376 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5377 _(TAP_DELETE_REPLY, tap_delete_reply) \
5378 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5379 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5380 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5381 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5382 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5383 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5384 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5385 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5386 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5387 proxy_arp_intfc_enable_disable_reply) \
5388 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5389 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5390 sw_interface_set_unnumbered_reply) \
5391 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5392 _(RESET_VRF_REPLY, reset_vrf_reply) \
5393 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5394 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5395 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5396 _(RESET_FIB_REPLY, reset_fib_reply) \
5397 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5398 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5399 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5400 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5401 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5402 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5403 sw_interface_ip6_enable_disable_reply) \
5404 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5405 sw_interface_ip6_set_link_local_address_reply) \
5406 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5407 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5408 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5409 sw_interface_ip6nd_ra_prefix_reply) \
5410 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5411 sw_interface_ip6nd_ra_config_reply) \
5412 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5413 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5414 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5415 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5416 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5417 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5418 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5419 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5420 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5421 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5422 classify_set_interface_ip_table_reply) \
5423 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5424 classify_set_interface_l2_tables_reply) \
5425 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5426 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5427 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5428 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5429 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5430 l2tpv3_interface_enable_disable_reply) \
5431 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5432 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5433 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5434 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5435 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5436 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5437 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5438 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5439 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5440 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5441 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5442 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5443 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5444 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5445 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5446 _(SHOW_VERSION_REPLY, show_version_reply) \
5447 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5448 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5449 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5450 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5451 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5452 _(IP4_ARP_EVENT, ip4_arp_event) \
5453 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5454 _(IP6_ND_EVENT, ip6_nd_event) \
5455 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5456 _(L2_MACS_EVENT, l2_macs_event) \
5457 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5458 _(IP_ADDRESS_DETAILS, ip_address_details) \
5459 _(IP_DETAILS, ip_details) \
5460 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5461 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5462 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5463 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5464 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5465 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5466 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5467 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5468 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5469 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5470 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5471 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5472 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5473 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5474 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5475 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5476 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5477 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5478 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5479 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5480 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5481 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5482 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5483 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5484 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5485 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5486 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5487 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5488 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5489 _(MAP_RULE_DETAILS, map_rule_details) \
5490 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5491 _(WANT_STATS_REPLY, want_stats_reply) \
5492 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5493 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5494 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5495 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5496 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5497 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5498 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5499 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5500 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5501 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5502 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5503 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5504 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5505 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5506 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5507 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5508 one_map_register_enable_disable_reply) \
5509 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5510 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5511 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5512 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5513 one_map_register_fallback_threshold_reply) \
5514 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5515 one_rloc_probe_enable_disable_reply) \
5516 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5517 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5518 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5519 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5520 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5521 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5522 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5523 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5524 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5525 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5526 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5527 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5528 _(ONE_STATS_DETAILS, one_stats_details) \
5529 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5530 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5531 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5532 show_one_stats_enable_disable_reply) \
5533 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5534 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5535 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5536 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5537 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5538 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5539 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5540 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5541 one_enable_disable_pitr_mode_reply) \
5542 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5543 one_enable_disable_petr_mode_reply) \
5544 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5545 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5546 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5547 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5548 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5549 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5550 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5551 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5552 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5553 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5554 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5555 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5556 gpe_add_del_native_fwd_rpath_reply) \
5557 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5558 gpe_fwd_entry_path_details) \
5559 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5560 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5561 one_add_del_map_request_itr_rlocs_reply) \
5562 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5563 one_get_map_request_itr_rlocs_reply) \
5564 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5565 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5566 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5567 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5568 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5569 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5570 show_one_map_register_state_reply) \
5571 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5572 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5573 show_one_map_register_fallback_threshold_reply) \
5574 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5575 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5576 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5577 _(POLICER_DETAILS, policer_details) \
5578 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5579 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5580 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5581 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5582 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5583 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5584 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5585 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5586 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5587 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5588 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5589 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5590 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5591 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5592 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5593 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5594 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5595 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5596 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5597 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5598 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5599 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5600 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5601 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5602 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5603 ip_source_and_port_range_check_add_del_reply) \
5604 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5605 ip_source_and_port_range_check_interface_add_del_reply) \
5606 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5607 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5608 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5609 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5610 _(PUNT_REPLY, punt_reply) \
5611 _(IP_FIB_DETAILS, ip_fib_details) \
5612 _(IP6_FIB_DETAILS, ip6_fib_details) \
5613 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5614 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5615 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5616 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5617 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5618 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5619 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5620 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5621 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5622 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5623 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5624 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5625 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5626 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5627 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5628 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5629 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply)
5631 #define foreach_standalone_reply_msg \
5632 _(SW_INTERFACE_EVENT, sw_interface_event) \
5633 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5634 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5635 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5636 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5637 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5638 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
5639 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
5648 #define STR_VTR_OP_CASE(op) \
5649 case L2_VTR_ ## op: \
5653 str_vtr_op (u32 vtr_op)
5657 STR_VTR_OP_CASE (DISABLED);
5658 STR_VTR_OP_CASE (PUSH_1);
5659 STR_VTR_OP_CASE (PUSH_2);
5660 STR_VTR_OP_CASE (POP_1);
5661 STR_VTR_OP_CASE (POP_2);
5662 STR_VTR_OP_CASE (TRANSLATE_1_1);
5663 STR_VTR_OP_CASE (TRANSLATE_1_2);
5664 STR_VTR_OP_CASE (TRANSLATE_2_1);
5665 STR_VTR_OP_CASE (TRANSLATE_2_2);
5672 dump_sub_interface_table (vat_main_t * vam)
5674 const sw_interface_subif_t *sub = NULL;
5676 if (vam->json_output)
5679 ("JSON output supported only for VPE API calls and dump_stats_table");
5684 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5685 "Interface", "sw_if_index",
5686 "sub id", "dot1ad", "tags", "outer id",
5687 "inner id", "exact", "default", "outer any", "inner any");
5689 vec_foreach (sub, vam->sw_if_subif_table)
5692 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5693 sub->interface_name,
5695 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5696 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5697 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5698 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5699 if (sub->vtr_op != L2_VTR_DISABLED)
5702 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5703 "tag1: %d tag2: %d ]",
5704 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5705 sub->vtr_tag1, sub->vtr_tag2);
5713 name_sort_cmp (void *a1, void *a2)
5715 name_sort_t *n1 = a1;
5716 name_sort_t *n2 = a2;
5718 return strcmp ((char *) n1->name, (char *) n2->name);
5722 dump_interface_table (vat_main_t * vam)
5725 name_sort_t *nses = 0, *ns;
5727 if (vam->json_output)
5730 ("JSON output supported only for VPE API calls and dump_stats_table");
5735 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5737 vec_add2 (nses, ns, 1);
5738 ns->name = (u8 *)(p->key);
5739 ns->value = (u32) p->value[0];
5743 vec_sort_with_function (nses, name_sort_cmp);
5745 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5746 vec_foreach (ns, nses)
5748 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5755 dump_ip_table (vat_main_t * vam, int is_ipv6)
5757 const ip_details_t *det = NULL;
5758 const ip_address_details_t *address = NULL;
5761 print (vam->ofp, "%-12s", "sw_if_index");
5763 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5770 print (vam->ofp, "%-12d", i);
5771 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5776 vec_foreach (address, det->addr)
5780 is_ipv6 ? format_ip6_address : format_ip4_address,
5781 address->ip, address->prefix_length);
5789 dump_ipv4_table (vat_main_t * vam)
5791 if (vam->json_output)
5794 ("JSON output supported only for VPE API calls and dump_stats_table");
5798 return dump_ip_table (vam, 0);
5802 dump_ipv6_table (vat_main_t * vam)
5804 if (vam->json_output)
5807 ("JSON output supported only for VPE API calls and dump_stats_table");
5811 return dump_ip_table (vam, 1);
5815 counter_type_to_str (u8 counter_type, u8 is_combined)
5819 switch (counter_type)
5821 case VNET_INTERFACE_COUNTER_DROP:
5823 case VNET_INTERFACE_COUNTER_PUNT:
5825 case VNET_INTERFACE_COUNTER_IP4:
5827 case VNET_INTERFACE_COUNTER_IP6:
5829 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5831 case VNET_INTERFACE_COUNTER_RX_MISS:
5833 case VNET_INTERFACE_COUNTER_RX_ERROR:
5835 case VNET_INTERFACE_COUNTER_TX_ERROR:
5838 return "INVALID-COUNTER-TYPE";
5843 switch (counter_type)
5845 case VNET_INTERFACE_COUNTER_RX:
5847 case VNET_INTERFACE_COUNTER_TX:
5850 return "INVALID-COUNTER-TYPE";
5856 dump_stats_table (vat_main_t * vam)
5858 vat_json_node_t node;
5859 vat_json_node_t *msg_array;
5860 vat_json_node_t *msg;
5861 vat_json_node_t *counter_array;
5862 vat_json_node_t *counter;
5863 interface_counter_t c;
5865 ip4_fib_counter_t *c4;
5866 ip6_fib_counter_t *c6;
5867 ip4_nbr_counter_t *n4;
5868 ip6_nbr_counter_t *n6;
5871 if (!vam->json_output)
5873 clib_warning ("dump_stats_table supported only in JSON format");
5877 vat_json_init_object (&node);
5879 /* interface counters */
5880 msg_array = vat_json_object_add (&node, "interface_counters");
5881 vat_json_init_array (msg_array);
5882 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5884 msg = vat_json_array_add (msg_array);
5885 vat_json_init_object (msg);
5886 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5887 (u8 *) counter_type_to_str (i, 0));
5888 vat_json_object_add_int (msg, "is_combined", 0);
5889 counter_array = vat_json_object_add (msg, "data");
5890 vat_json_init_array (counter_array);
5891 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5893 packets = vam->simple_interface_counters[i][j];
5894 vat_json_array_add_uint (counter_array, packets);
5897 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5899 msg = vat_json_array_add (msg_array);
5900 vat_json_init_object (msg);
5901 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5902 (u8 *) counter_type_to_str (i, 1));
5903 vat_json_object_add_int (msg, "is_combined", 1);
5904 counter_array = vat_json_object_add (msg, "data");
5905 vat_json_init_array (counter_array);
5906 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5908 c = vam->combined_interface_counters[i][j];
5909 counter = vat_json_array_add (counter_array);
5910 vat_json_init_object (counter);
5911 vat_json_object_add_uint (counter, "packets", c.packets);
5912 vat_json_object_add_uint (counter, "bytes", c.bytes);
5916 /* ip4 fib counters */
5917 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5918 vat_json_init_array (msg_array);
5919 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5921 msg = vat_json_array_add (msg_array);
5922 vat_json_init_object (msg);
5923 vat_json_object_add_uint (msg, "vrf_id",
5924 vam->ip4_fib_counters_vrf_id_by_index[i]);
5925 counter_array = vat_json_object_add (msg, "c");
5926 vat_json_init_array (counter_array);
5927 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
5929 counter = vat_json_array_add (counter_array);
5930 vat_json_init_object (counter);
5931 c4 = &vam->ip4_fib_counters[i][j];
5932 vat_json_object_add_ip4 (counter, "address", c4->address);
5933 vat_json_object_add_uint (counter, "address_length",
5934 c4->address_length);
5935 vat_json_object_add_uint (counter, "packets", c4->packets);
5936 vat_json_object_add_uint (counter, "bytes", c4->bytes);
5940 /* ip6 fib counters */
5941 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
5942 vat_json_init_array (msg_array);
5943 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
5945 msg = vat_json_array_add (msg_array);
5946 vat_json_init_object (msg);
5947 vat_json_object_add_uint (msg, "vrf_id",
5948 vam->ip6_fib_counters_vrf_id_by_index[i]);
5949 counter_array = vat_json_object_add (msg, "c");
5950 vat_json_init_array (counter_array);
5951 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
5953 counter = vat_json_array_add (counter_array);
5954 vat_json_init_object (counter);
5955 c6 = &vam->ip6_fib_counters[i][j];
5956 vat_json_object_add_ip6 (counter, "address", c6->address);
5957 vat_json_object_add_uint (counter, "address_length",
5958 c6->address_length);
5959 vat_json_object_add_uint (counter, "packets", c6->packets);
5960 vat_json_object_add_uint (counter, "bytes", c6->bytes);
5964 /* ip4 nbr counters */
5965 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
5966 vat_json_init_array (msg_array);
5967 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
5969 msg = vat_json_array_add (msg_array);
5970 vat_json_init_object (msg);
5971 vat_json_object_add_uint (msg, "sw_if_index", i);
5972 counter_array = vat_json_object_add (msg, "c");
5973 vat_json_init_array (counter_array);
5974 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
5976 counter = vat_json_array_add (counter_array);
5977 vat_json_init_object (counter);
5978 n4 = &vam->ip4_nbr_counters[i][j];
5979 vat_json_object_add_ip4 (counter, "address", n4->address);
5980 vat_json_object_add_uint (counter, "link-type", n4->linkt);
5981 vat_json_object_add_uint (counter, "packets", n4->packets);
5982 vat_json_object_add_uint (counter, "bytes", n4->bytes);
5986 /* ip6 nbr counters */
5987 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
5988 vat_json_init_array (msg_array);
5989 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
5991 msg = vat_json_array_add (msg_array);
5992 vat_json_init_object (msg);
5993 vat_json_object_add_uint (msg, "sw_if_index", i);
5994 counter_array = vat_json_object_add (msg, "c");
5995 vat_json_init_array (counter_array);
5996 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
5998 counter = vat_json_array_add (counter_array);
5999 vat_json_init_object (counter);
6000 n6 = &vam->ip6_nbr_counters[i][j];
6001 vat_json_object_add_ip6 (counter, "address", n6->address);
6002 vat_json_object_add_uint (counter, "packets", n6->packets);
6003 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6007 vat_json_print (vam->ofp, &node);
6008 vat_json_free (&node);
6014 * Pass CLI buffers directly in the CLI_INBAND API message,
6015 * instead of an additional shared memory area.
6018 exec_inband (vat_main_t * vam)
6020 vl_api_cli_inband_t *mp;
6021 unformat_input_t *i = vam->input;
6024 if (vec_len (i->buffer) == 0)
6027 if (vam->exec_mode == 0 && unformat (i, "mode"))
6032 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6039 * In order for the CLI command to work, it
6040 * must be a vector ending in \n, not a C-string ending
6043 u32 len = vec_len (vam->input->buffer);
6044 M2 (CLI_INBAND, mp, len);
6045 clib_memcpy (mp->cmd, vam->input->buffer, len);
6046 mp->length = htonl (len);
6050 /* json responses may or may not include a useful reply... */
6051 if (vec_len (vam->cmd_reply))
6052 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6057 exec (vat_main_t * vam)
6059 return exec_inband (vam);
6063 api_create_loopback (vat_main_t * vam)
6065 unformat_input_t *i = vam->input;
6066 vl_api_create_loopback_t *mp;
6067 vl_api_create_loopback_instance_t *mp_lbi;
6070 u8 is_specified = 0;
6071 u32 user_instance = 0;
6074 memset (mac_address, 0, sizeof (mac_address));
6076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6078 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6080 if (unformat (i, "instance %d", &user_instance))
6088 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6089 mp_lbi->is_specified = is_specified;
6091 mp_lbi->user_instance = htonl (user_instance);
6093 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6098 /* Construct the API message */
6099 M (CREATE_LOOPBACK, mp);
6101 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6110 api_delete_loopback (vat_main_t * vam)
6112 unformat_input_t *i = vam->input;
6113 vl_api_delete_loopback_t *mp;
6114 u32 sw_if_index = ~0;
6117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6119 if (unformat (i, "sw_if_index %d", &sw_if_index))
6125 if (sw_if_index == ~0)
6127 errmsg ("missing sw_if_index");
6131 /* Construct the API message */
6132 M (DELETE_LOOPBACK, mp);
6133 mp->sw_if_index = ntohl (sw_if_index);
6141 api_want_stats (vat_main_t * vam)
6143 unformat_input_t *i = vam->input;
6144 vl_api_want_stats_t *mp;
6148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6150 if (unformat (i, "enable"))
6152 else if (unformat (i, "disable"))
6160 errmsg ("missing enable|disable");
6165 mp->enable_disable = enable;
6173 api_want_interface_events (vat_main_t * vam)
6175 unformat_input_t *i = vam->input;
6176 vl_api_want_interface_events_t *mp;
6180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6182 if (unformat (i, "enable"))
6184 else if (unformat (i, "disable"))
6192 errmsg ("missing enable|disable");
6196 M (WANT_INTERFACE_EVENTS, mp);
6197 mp->enable_disable = enable;
6199 vam->interface_event_display = enable;
6207 /* Note: non-static, called once to set up the initial intfc table */
6209 api_sw_interface_dump (vat_main_t * vam)
6211 vl_api_sw_interface_dump_t *mp;
6212 vl_api_control_ping_t *mp_ping;
6214 name_sort_t *nses = 0, *ns;
6215 sw_interface_subif_t *sub = NULL;
6218 /* Toss the old name table */
6220 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6222 vec_add2 (nses, ns, 1);
6223 ns->name = (u8 *)(p->key);
6224 ns->value = (u32) p->value[0];
6228 hash_free (vam->sw_if_index_by_interface_name);
6230 vec_foreach (ns, nses) vec_free (ns->name);
6234 vec_foreach (sub, vam->sw_if_subif_table)
6236 vec_free (sub->interface_name);
6238 vec_free (vam->sw_if_subif_table);
6240 /* recreate the interface name hash table */
6241 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6243 /* Get list of ethernets */
6244 M (SW_INTERFACE_DUMP, mp);
6245 mp->name_filter_valid = 1;
6246 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
6249 /* and local / loopback interfaces */
6250 M (SW_INTERFACE_DUMP, mp);
6251 mp->name_filter_valid = 1;
6252 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
6255 /* and packet-generator interfaces */
6256 M (SW_INTERFACE_DUMP, mp);
6257 mp->name_filter_valid = 1;
6258 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
6261 /* and vxlan-gpe tunnel interfaces */
6262 M (SW_INTERFACE_DUMP, mp);
6263 mp->name_filter_valid = 1;
6264 strncpy ((char *) mp->name_filter, "vxlan_gpe",
6265 sizeof (mp->name_filter) - 1);
6268 /* and vxlan tunnel interfaces */
6269 M (SW_INTERFACE_DUMP, mp);
6270 mp->name_filter_valid = 1;
6271 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
6274 /* and geneve tunnel interfaces */
6275 M (SW_INTERFACE_DUMP, mp);
6276 mp->name_filter_valid = 1;
6277 strncpy ((char *) mp->name_filter, "geneve", sizeof (mp->name_filter) - 1);
6280 /* and host (af_packet) interfaces */
6281 M (SW_INTERFACE_DUMP, mp);
6282 mp->name_filter_valid = 1;
6283 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
6286 /* and l2tpv3 tunnel interfaces */
6287 M (SW_INTERFACE_DUMP, mp);
6288 mp->name_filter_valid = 1;
6289 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
6290 sizeof (mp->name_filter) - 1);
6293 /* and GRE tunnel interfaces */
6294 M (SW_INTERFACE_DUMP, mp);
6295 mp->name_filter_valid = 1;
6296 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
6299 /* and LISP-GPE interfaces */
6300 M (SW_INTERFACE_DUMP, mp);
6301 mp->name_filter_valid = 1;
6302 strncpy ((char *) mp->name_filter, "lisp_gpe",
6303 sizeof (mp->name_filter) - 1);
6306 /* and IPSEC tunnel interfaces */
6307 M (SW_INTERFACE_DUMP, mp);
6308 mp->name_filter_valid = 1;
6309 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
6312 /* Use a control ping for synchronization */
6313 MPING (CONTROL_PING, mp_ping);
6321 api_sw_interface_set_flags (vat_main_t * vam)
6323 unformat_input_t *i = vam->input;
6324 vl_api_sw_interface_set_flags_t *mp;
6326 u8 sw_if_index_set = 0;
6330 /* Parse args required to build the message */
6331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6333 if (unformat (i, "admin-up"))
6335 else if (unformat (i, "admin-down"))
6338 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6339 sw_if_index_set = 1;
6340 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6341 sw_if_index_set = 1;
6346 if (sw_if_index_set == 0)
6348 errmsg ("missing interface name or sw_if_index");
6352 /* Construct the API message */
6353 M (SW_INTERFACE_SET_FLAGS, mp);
6354 mp->sw_if_index = ntohl (sw_if_index);
6355 mp->admin_up_down = admin_up;
6360 /* Wait for a reply, return the good/bad news... */
6366 api_sw_interface_set_rx_mode (vat_main_t * vam)
6368 unformat_input_t *i = vam->input;
6369 vl_api_sw_interface_set_rx_mode_t *mp;
6371 u8 sw_if_index_set = 0;
6373 u8 queue_id_valid = 0;
6375 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6377 /* Parse args required to build the message */
6378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6380 if (unformat (i, "queue %d", &queue_id))
6382 else if (unformat (i, "polling"))
6383 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6384 else if (unformat (i, "interrupt"))
6385 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6386 else if (unformat (i, "adaptive"))
6387 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6390 sw_if_index_set = 1;
6391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6392 sw_if_index_set = 1;
6397 if (sw_if_index_set == 0)
6399 errmsg ("missing interface name or sw_if_index");
6402 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6404 errmsg ("missing rx-mode");
6408 /* Construct the API message */
6409 M (SW_INTERFACE_SET_RX_MODE, mp);
6410 mp->sw_if_index = ntohl (sw_if_index);
6412 mp->queue_id_valid = queue_id_valid;
6413 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6418 /* Wait for a reply, return the good/bad news... */
6424 api_sw_interface_clear_stats (vat_main_t * vam)
6426 unformat_input_t *i = vam->input;
6427 vl_api_sw_interface_clear_stats_t *mp;
6429 u8 sw_if_index_set = 0;
6432 /* Parse args required to build the message */
6433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6435 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6436 sw_if_index_set = 1;
6437 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6438 sw_if_index_set = 1;
6443 /* Construct the API message */
6444 M (SW_INTERFACE_CLEAR_STATS, mp);
6446 if (sw_if_index_set == 1)
6447 mp->sw_if_index = ntohl (sw_if_index);
6449 mp->sw_if_index = ~0;
6454 /* Wait for a reply, return the good/bad news... */
6460 api_sw_interface_add_del_address (vat_main_t * vam)
6462 unformat_input_t *i = vam->input;
6463 vl_api_sw_interface_add_del_address_t *mp;
6465 u8 sw_if_index_set = 0;
6466 u8 is_add = 1, del_all = 0;
6467 u32 address_length = 0;
6468 u8 v4_address_set = 0;
6469 u8 v6_address_set = 0;
6470 ip4_address_t v4address;
6471 ip6_address_t v6address;
6474 /* Parse args required to build the message */
6475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6477 if (unformat (i, "del-all"))
6479 else if (unformat (i, "del"))
6482 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6483 sw_if_index_set = 1;
6484 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6485 sw_if_index_set = 1;
6486 else if (unformat (i, "%U/%d",
6487 unformat_ip4_address, &v4address, &address_length))
6489 else if (unformat (i, "%U/%d",
6490 unformat_ip6_address, &v6address, &address_length))
6496 if (sw_if_index_set == 0)
6498 errmsg ("missing interface name or sw_if_index");
6501 if (v4_address_set && v6_address_set)
6503 errmsg ("both v4 and v6 addresses set");
6506 if (!v4_address_set && !v6_address_set && !del_all)
6508 errmsg ("no addresses set");
6512 /* Construct the API message */
6513 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6515 mp->sw_if_index = ntohl (sw_if_index);
6516 mp->is_add = is_add;
6517 mp->del_all = del_all;
6521 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6525 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6527 mp->address_length = address_length;
6532 /* Wait for a reply, return good/bad news */
6538 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6540 unformat_input_t *i = vam->input;
6541 vl_api_sw_interface_set_mpls_enable_t *mp;
6543 u8 sw_if_index_set = 0;
6547 /* Parse args required to build the message */
6548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6550 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6551 sw_if_index_set = 1;
6552 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6553 sw_if_index_set = 1;
6554 else if (unformat (i, "disable"))
6556 else if (unformat (i, "dis"))
6562 if (sw_if_index_set == 0)
6564 errmsg ("missing interface name or sw_if_index");
6568 /* Construct the API message */
6569 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6571 mp->sw_if_index = ntohl (sw_if_index);
6572 mp->enable = enable;
6577 /* Wait for a reply... */
6583 api_sw_interface_set_table (vat_main_t * vam)
6585 unformat_input_t *i = vam->input;
6586 vl_api_sw_interface_set_table_t *mp;
6587 u32 sw_if_index, vrf_id = 0;
6588 u8 sw_if_index_set = 0;
6592 /* Parse args required to build the message */
6593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6595 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6596 sw_if_index_set = 1;
6597 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6598 sw_if_index_set = 1;
6599 else if (unformat (i, "vrf %d", &vrf_id))
6601 else if (unformat (i, "ipv6"))
6607 if (sw_if_index_set == 0)
6609 errmsg ("missing interface name or sw_if_index");
6613 /* Construct the API message */
6614 M (SW_INTERFACE_SET_TABLE, mp);
6616 mp->sw_if_index = ntohl (sw_if_index);
6617 mp->is_ipv6 = is_ipv6;
6618 mp->vrf_id = ntohl (vrf_id);
6623 /* Wait for a reply... */
6628 static void vl_api_sw_interface_get_table_reply_t_handler
6629 (vl_api_sw_interface_get_table_reply_t * mp)
6631 vat_main_t *vam = &vat_main;
6633 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6635 vam->retval = ntohl (mp->retval);
6636 vam->result_ready = 1;
6640 static void vl_api_sw_interface_get_table_reply_t_handler_json
6641 (vl_api_sw_interface_get_table_reply_t * mp)
6643 vat_main_t *vam = &vat_main;
6644 vat_json_node_t node;
6646 vat_json_init_object (&node);
6647 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6648 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6650 vat_json_print (vam->ofp, &node);
6651 vat_json_free (&node);
6653 vam->retval = ntohl (mp->retval);
6654 vam->result_ready = 1;
6658 api_sw_interface_get_table (vat_main_t * vam)
6660 unformat_input_t *i = vam->input;
6661 vl_api_sw_interface_get_table_t *mp;
6663 u8 sw_if_index_set = 0;
6667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6669 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6670 sw_if_index_set = 1;
6671 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6672 sw_if_index_set = 1;
6673 else if (unformat (i, "ipv6"))
6679 if (sw_if_index_set == 0)
6681 errmsg ("missing interface name or sw_if_index");
6685 M (SW_INTERFACE_GET_TABLE, mp);
6686 mp->sw_if_index = htonl (sw_if_index);
6687 mp->is_ipv6 = is_ipv6;
6695 api_sw_interface_set_vpath (vat_main_t * vam)
6697 unformat_input_t *i = vam->input;
6698 vl_api_sw_interface_set_vpath_t *mp;
6699 u32 sw_if_index = 0;
6700 u8 sw_if_index_set = 0;
6704 /* Parse args required to build the message */
6705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6707 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6708 sw_if_index_set = 1;
6709 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6710 sw_if_index_set = 1;
6711 else if (unformat (i, "enable"))
6713 else if (unformat (i, "disable"))
6719 if (sw_if_index_set == 0)
6721 errmsg ("missing interface name or sw_if_index");
6725 /* Construct the API message */
6726 M (SW_INTERFACE_SET_VPATH, mp);
6728 mp->sw_if_index = ntohl (sw_if_index);
6729 mp->enable = is_enable;
6734 /* Wait for a reply... */
6740 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6742 unformat_input_t *i = vam->input;
6743 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6744 u32 sw_if_index = 0;
6745 u8 sw_if_index_set = 0;
6750 /* Parse args required to build the message */
6751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6753 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6754 sw_if_index_set = 1;
6755 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6756 sw_if_index_set = 1;
6757 else if (unformat (i, "enable"))
6759 else if (unformat (i, "disable"))
6761 else if (unformat (i, "ip4"))
6763 else if (unformat (i, "ip6"))
6769 if (sw_if_index_set == 0)
6771 errmsg ("missing interface name or sw_if_index");
6775 /* Construct the API message */
6776 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6778 mp->sw_if_index = ntohl (sw_if_index);
6779 mp->enable = is_enable;
6780 mp->is_ipv6 = is_ipv6;
6785 /* Wait for a reply... */
6791 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6793 unformat_input_t *i = vam->input;
6794 vl_api_sw_interface_set_geneve_bypass_t *mp;
6795 u32 sw_if_index = 0;
6796 u8 sw_if_index_set = 0;
6801 /* Parse args required to build the message */
6802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6804 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6805 sw_if_index_set = 1;
6806 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6807 sw_if_index_set = 1;
6808 else if (unformat (i, "enable"))
6810 else if (unformat (i, "disable"))
6812 else if (unformat (i, "ip4"))
6814 else if (unformat (i, "ip6"))
6820 if (sw_if_index_set == 0)
6822 errmsg ("missing interface name or sw_if_index");
6826 /* Construct the API message */
6827 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6829 mp->sw_if_index = ntohl (sw_if_index);
6830 mp->enable = is_enable;
6831 mp->is_ipv6 = is_ipv6;
6836 /* Wait for a reply... */
6842 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6844 unformat_input_t *i = vam->input;
6845 vl_api_sw_interface_set_l2_xconnect_t *mp;
6847 u8 rx_sw_if_index_set = 0;
6849 u8 tx_sw_if_index_set = 0;
6853 /* Parse args required to build the message */
6854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6856 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6857 rx_sw_if_index_set = 1;
6858 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6859 tx_sw_if_index_set = 1;
6860 else if (unformat (i, "rx"))
6862 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6864 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6866 rx_sw_if_index_set = 1;
6871 else if (unformat (i, "tx"))
6873 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6875 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6877 tx_sw_if_index_set = 1;
6882 else if (unformat (i, "enable"))
6884 else if (unformat (i, "disable"))
6890 if (rx_sw_if_index_set == 0)
6892 errmsg ("missing rx interface name or rx_sw_if_index");
6896 if (enable && (tx_sw_if_index_set == 0))
6898 errmsg ("missing tx interface name or tx_sw_if_index");
6902 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6904 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6905 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6906 mp->enable = enable;
6914 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6916 unformat_input_t *i = vam->input;
6917 vl_api_sw_interface_set_l2_bridge_t *mp;
6919 u8 rx_sw_if_index_set = 0;
6927 /* Parse args required to build the message */
6928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6930 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6931 rx_sw_if_index_set = 1;
6932 else if (unformat (i, "bd_id %d", &bd_id))
6936 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6937 rx_sw_if_index_set = 1;
6938 else if (unformat (i, "shg %d", &shg))
6940 else if (unformat (i, "bvi"))
6942 else if (unformat (i, "enable"))
6944 else if (unformat (i, "disable"))
6950 if (rx_sw_if_index_set == 0)
6952 errmsg ("missing rx interface name or sw_if_index");
6956 if (enable && (bd_id_set == 0))
6958 errmsg ("missing bridge domain");
6962 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6964 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6965 mp->bd_id = ntohl (bd_id);
6968 mp->enable = enable;
6976 api_bridge_domain_dump (vat_main_t * vam)
6978 unformat_input_t *i = vam->input;
6979 vl_api_bridge_domain_dump_t *mp;
6980 vl_api_control_ping_t *mp_ping;
6984 /* Parse args required to build the message */
6985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6987 if (unformat (i, "bd_id %d", &bd_id))
6993 M (BRIDGE_DOMAIN_DUMP, mp);
6994 mp->bd_id = ntohl (bd_id);
6997 /* Use a control ping for synchronization */
6998 MPING (CONTROL_PING, mp_ping);
7006 api_bridge_domain_add_del (vat_main_t * vam)
7008 unformat_input_t *i = vam->input;
7009 vl_api_bridge_domain_add_del_t *mp;
7012 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7017 /* Parse args required to build the message */
7018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7020 if (unformat (i, "bd_id %d", &bd_id))
7022 else if (unformat (i, "flood %d", &flood))
7024 else if (unformat (i, "uu-flood %d", &uu_flood))
7026 else if (unformat (i, "forward %d", &forward))
7028 else if (unformat (i, "learn %d", &learn))
7030 else if (unformat (i, "arp-term %d", &arp_term))
7032 else if (unformat (i, "mac-age %d", &mac_age))
7034 else if (unformat (i, "bd-tag %s", &bd_tag))
7036 else if (unformat (i, "del"))
7039 flood = uu_flood = forward = learn = 0;
7047 errmsg ("missing bridge domain");
7054 errmsg ("mac age must be less than 256 ");
7059 if ((bd_tag) && (strlen ((char *) bd_tag) > 63))
7061 errmsg ("bd-tag cannot be longer than 63");
7066 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7068 mp->bd_id = ntohl (bd_id);
7070 mp->uu_flood = uu_flood;
7071 mp->forward = forward;
7073 mp->arp_term = arp_term;
7074 mp->is_add = is_add;
7075 mp->mac_age = (u8) mac_age;
7077 strcpy ((char *) mp->bd_tag, (char *) bd_tag);
7088 api_l2fib_flush_bd (vat_main_t * vam)
7090 unformat_input_t *i = vam->input;
7091 vl_api_l2fib_flush_bd_t *mp;
7095 /* Parse args required to build the message */
7096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7098 if (unformat (i, "bd_id %d", &bd_id));
7105 errmsg ("missing bridge domain");
7109 M (L2FIB_FLUSH_BD, mp);
7111 mp->bd_id = htonl (bd_id);
7119 api_l2fib_flush_int (vat_main_t * vam)
7121 unformat_input_t *i = vam->input;
7122 vl_api_l2fib_flush_int_t *mp;
7123 u32 sw_if_index = ~0;
7126 /* Parse args required to build the message */
7127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7129 if (unformat (i, "sw_if_index %d", &sw_if_index));
7131 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7136 if (sw_if_index == ~0)
7138 errmsg ("missing interface name or sw_if_index");
7142 M (L2FIB_FLUSH_INT, mp);
7144 mp->sw_if_index = ntohl (sw_if_index);
7152 api_l2fib_add_del (vat_main_t * vam)
7154 unformat_input_t *i = vam->input;
7155 vl_api_l2fib_add_del_t *mp;
7161 u32 sw_if_index = ~0;
7162 u8 sw_if_index_set = 0;
7171 /* Parse args required to build the message */
7172 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7174 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7176 else if (unformat (i, "bd_id %d", &bd_id))
7178 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7179 sw_if_index_set = 1;
7180 else if (unformat (i, "sw_if"))
7182 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7185 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7186 sw_if_index_set = 1;
7191 else if (unformat (i, "static"))
7193 else if (unformat (i, "filter"))
7198 else if (unformat (i, "bvi"))
7203 else if (unformat (i, "del"))
7205 else if (unformat (i, "count %d", &count))
7213 errmsg ("missing mac address");
7219 errmsg ("missing bridge domain");
7223 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7225 errmsg ("missing interface name or sw_if_index");
7231 /* Turn on async mode */
7232 vam->async_mode = 1;
7233 vam->async_errors = 0;
7234 before = vat_time_now (vam);
7237 for (j = 0; j < count; j++)
7239 M (L2FIB_ADD_DEL, mp);
7241 clib_memcpy (mp->mac, mac, 6);
7242 mp->bd_id = ntohl (bd_id);
7243 mp->is_add = is_add;
7247 mp->sw_if_index = ntohl (sw_if_index);
7248 mp->static_mac = static_mac;
7249 mp->filter_mac = filter_mac;
7250 mp->bvi_mac = bvi_mac;
7252 increment_mac_address (mac);
7259 vl_api_control_ping_t *mp_ping;
7262 /* Shut off async mode */
7263 vam->async_mode = 0;
7265 MPING (CONTROL_PING, mp_ping);
7268 timeout = vat_time_now (vam) + 1.0;
7269 while (vat_time_now (vam) < timeout)
7270 if (vam->result_ready == 1)
7275 if (vam->retval == -99)
7278 if (vam->async_errors > 0)
7280 errmsg ("%d asynchronous errors", vam->async_errors);
7283 vam->async_errors = 0;
7284 after = vat_time_now (vam);
7286 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7287 count, after - before, count / (after - before));
7293 /* Wait for a reply... */
7297 /* Return the good/bad news */
7298 return (vam->retval);
7302 api_bridge_domain_set_mac_age (vat_main_t * vam)
7304 unformat_input_t *i = vam->input;
7305 vl_api_bridge_domain_set_mac_age_t *mp;
7310 /* Parse args required to build the message */
7311 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7313 if (unformat (i, "bd_id %d", &bd_id));
7314 else if (unformat (i, "mac-age %d", &mac_age));
7321 errmsg ("missing bridge domain");
7327 errmsg ("mac age must be less than 256 ");
7331 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7333 mp->bd_id = htonl (bd_id);
7334 mp->mac_age = (u8) mac_age;
7342 api_l2_flags (vat_main_t * vam)
7344 unformat_input_t *i = vam->input;
7345 vl_api_l2_flags_t *mp;
7348 u8 sw_if_index_set = 0;
7352 /* Parse args required to build the message */
7353 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7355 if (unformat (i, "sw_if_index %d", &sw_if_index))
7356 sw_if_index_set = 1;
7357 else if (unformat (i, "sw_if"))
7359 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7362 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7363 sw_if_index_set = 1;
7368 else if (unformat (i, "learn"))
7370 else if (unformat (i, "forward"))
7372 else if (unformat (i, "flood"))
7374 else if (unformat (i, "uu-flood"))
7375 flags |= L2_UU_FLOOD;
7376 else if (unformat (i, "arp-term"))
7377 flags |= L2_ARP_TERM;
7378 else if (unformat (i, "off"))
7380 else if (unformat (i, "disable"))
7386 if (sw_if_index_set == 0)
7388 errmsg ("missing interface name or sw_if_index");
7394 mp->sw_if_index = ntohl (sw_if_index);
7395 mp->feature_bitmap = ntohl (flags);
7396 mp->is_set = is_set;
7404 api_bridge_flags (vat_main_t * vam)
7406 unformat_input_t *i = vam->input;
7407 vl_api_bridge_flags_t *mp;
7414 /* Parse args required to build the message */
7415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7417 if (unformat (i, "bd_id %d", &bd_id))
7419 else if (unformat (i, "learn"))
7421 else if (unformat (i, "forward"))
7423 else if (unformat (i, "flood"))
7425 else if (unformat (i, "uu-flood"))
7426 flags |= L2_UU_FLOOD;
7427 else if (unformat (i, "arp-term"))
7428 flags |= L2_ARP_TERM;
7429 else if (unformat (i, "off"))
7431 else if (unformat (i, "disable"))
7439 errmsg ("missing bridge domain");
7443 M (BRIDGE_FLAGS, mp);
7445 mp->bd_id = ntohl (bd_id);
7446 mp->feature_bitmap = ntohl (flags);
7447 mp->is_set = is_set;
7455 api_bd_ip_mac_add_del (vat_main_t * vam)
7457 unformat_input_t *i = vam->input;
7458 vl_api_bd_ip_mac_add_del_t *mp;
7465 ip4_address_t v4addr;
7466 ip6_address_t v6addr;
7471 /* Parse args required to build the message */
7472 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7474 if (unformat (i, "bd_id %d", &bd_id))
7478 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7482 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7487 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7491 else if (unformat (i, "del"))
7499 errmsg ("missing bridge domain");
7502 else if (ip_set == 0)
7504 errmsg ("missing IP address");
7507 else if (mac_set == 0)
7509 errmsg ("missing MAC address");
7513 M (BD_IP_MAC_ADD_DEL, mp);
7515 mp->bd_id = ntohl (bd_id);
7516 mp->is_ipv6 = is_ipv6;
7517 mp->is_add = is_add;
7519 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7521 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7522 clib_memcpy (mp->mac_address, macaddr, 6);
7529 api_tap_connect (vat_main_t * vam)
7531 unformat_input_t *i = vam->input;
7532 vl_api_tap_connect_t *mp;
7538 ip4_address_t ip4_address;
7540 int ip4_address_set = 0;
7541 ip6_address_t ip6_address;
7543 int ip6_address_set = 0;
7546 memset (mac_address, 0, sizeof (mac_address));
7548 /* Parse args required to build the message */
7549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7551 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7555 else if (unformat (i, "random-mac"))
7557 else if (unformat (i, "tapname %s", &tap_name))
7559 else if (unformat (i, "tag %s", &tag))
7561 else if (unformat (i, "address %U/%d",
7562 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7563 ip4_address_set = 1;
7564 else if (unformat (i, "address %U/%d",
7565 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7566 ip6_address_set = 1;
7573 errmsg ("missing tap name");
7576 if (vec_len (tap_name) > 63)
7578 errmsg ("tap name too long");
7581 vec_add1 (tap_name, 0);
7583 if (vec_len (tag) > 63)
7585 errmsg ("tag too long");
7589 /* Construct the API message */
7590 M (TAP_CONNECT, mp);
7592 mp->use_random_mac = random_mac;
7593 clib_memcpy (mp->mac_address, mac_address, 6);
7594 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7596 clib_memcpy (mp->tag, tag, vec_len (tag));
7598 if (ip4_address_set)
7600 mp->ip4_address_set = 1;
7601 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7602 mp->ip4_mask_width = ip4_mask_width;
7604 if (ip6_address_set)
7606 mp->ip6_address_set = 1;
7607 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7608 mp->ip6_mask_width = ip6_mask_width;
7611 vec_free (tap_name);
7617 /* Wait for a reply... */
7623 api_tap_modify (vat_main_t * vam)
7625 unformat_input_t *i = vam->input;
7626 vl_api_tap_modify_t *mp;
7631 u32 sw_if_index = ~0;
7632 u8 sw_if_index_set = 0;
7635 memset (mac_address, 0, sizeof (mac_address));
7637 /* Parse args required to build the message */
7638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7640 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7641 sw_if_index_set = 1;
7642 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7643 sw_if_index_set = 1;
7644 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7648 else if (unformat (i, "random-mac"))
7650 else if (unformat (i, "tapname %s", &tap_name))
7656 if (sw_if_index_set == 0)
7658 errmsg ("missing vpp interface name");
7663 errmsg ("missing tap name");
7666 if (vec_len (tap_name) > 63)
7668 errmsg ("tap name too long");
7670 vec_add1 (tap_name, 0);
7672 /* Construct the API message */
7675 mp->use_random_mac = random_mac;
7676 mp->sw_if_index = ntohl (sw_if_index);
7677 clib_memcpy (mp->mac_address, mac_address, 6);
7678 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7679 vec_free (tap_name);
7684 /* Wait for a reply... */
7690 api_tap_delete (vat_main_t * vam)
7692 unformat_input_t *i = vam->input;
7693 vl_api_tap_delete_t *mp;
7694 u32 sw_if_index = ~0;
7695 u8 sw_if_index_set = 0;
7698 /* Parse args required to build the message */
7699 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7701 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7702 sw_if_index_set = 1;
7703 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7704 sw_if_index_set = 1;
7709 if (sw_if_index_set == 0)
7711 errmsg ("missing vpp interface name");
7715 /* Construct the API message */
7718 mp->sw_if_index = ntohl (sw_if_index);
7723 /* Wait for a reply... */
7729 api_ip_table_add_del (vat_main_t * vam)
7731 unformat_input_t *i = vam->input;
7732 vl_api_ip_table_add_del_t *mp;
7738 /* Parse args required to build the message */
7739 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7741 if (unformat (i, "ipv6"))
7743 else if (unformat (i, "del"))
7745 else if (unformat (i, "add"))
7747 else if (unformat (i, "table %d", &table_id))
7751 clib_warning ("parse error '%U'", format_unformat_error, i);
7758 errmsg ("missing table-ID");
7762 /* Construct the API message */
7763 M (IP_TABLE_ADD_DEL, mp);
7765 mp->table_id = ntohl (table_id);
7766 mp->is_ipv6 = is_ipv6;
7767 mp->is_add = is_add;
7772 /* Wait for a reply... */
7779 api_ip_add_del_route (vat_main_t * vam)
7781 unformat_input_t *i = vam->input;
7782 vl_api_ip_add_del_route_t *mp;
7783 u32 sw_if_index = ~0, vrf_id = 0;
7785 u8 is_local = 0, is_drop = 0;
7786 u8 is_unreach = 0, is_prohibit = 0;
7787 u8 create_vrf_if_needed = 0;
7789 u32 next_hop_weight = 1;
7790 u8 is_multipath = 0;
7792 u8 address_length_set = 0;
7793 u32 next_hop_table_id = 0;
7794 u32 resolve_attempts = 0;
7795 u32 dst_address_length = 0;
7796 u8 next_hop_set = 0;
7797 ip4_address_t v4_dst_address, v4_next_hop_address;
7798 ip6_address_t v6_dst_address, v6_next_hop_address;
7802 u32 random_add_del = 0;
7803 u32 *random_vector = 0;
7805 u32 random_seed = 0xdeaddabe;
7806 u32 classify_table_index = ~0;
7808 u8 resolve_host = 0, resolve_attached = 0;
7809 mpls_label_t *next_hop_out_label_stack = NULL;
7810 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7811 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7813 /* Parse args required to build the message */
7814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7816 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7818 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7820 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
7825 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
7830 else if (unformat (i, "/%d", &dst_address_length))
7832 address_length_set = 1;
7835 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
7836 &v4_next_hop_address))
7840 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
7841 &v6_next_hop_address))
7845 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
7847 else if (unformat (i, "weight %d", &next_hop_weight))
7849 else if (unformat (i, "drop"))
7853 else if (unformat (i, "null-send-unreach"))
7857 else if (unformat (i, "null-send-prohibit"))
7861 else if (unformat (i, "local"))
7865 else if (unformat (i, "classify %d", &classify_table_index))
7869 else if (unformat (i, "del"))
7871 else if (unformat (i, "add"))
7873 else if (unformat (i, "resolve-via-host"))
7875 else if (unformat (i, "resolve-via-attached"))
7876 resolve_attached = 1;
7877 else if (unformat (i, "multipath"))
7879 else if (unformat (i, "vrf %d", &vrf_id))
7881 else if (unformat (i, "create-vrf"))
7882 create_vrf_if_needed = 1;
7883 else if (unformat (i, "count %d", &count))
7885 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
7887 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7889 else if (unformat (i, "out-label %d", &next_hop_out_label))
7890 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7891 else if (unformat (i, "via-label %d", &next_hop_via_label))
7893 else if (unformat (i, "random"))
7895 else if (unformat (i, "seed %d", &random_seed))
7899 clib_warning ("parse error '%U'", format_unformat_error, i);
7904 if (!next_hop_set && !is_drop && !is_local &&
7905 !is_classify && !is_unreach && !is_prohibit &&
7906 MPLS_LABEL_INVALID == next_hop_via_label)
7909 ("next hop / local / drop / unreach / prohibit / classify not set");
7913 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
7915 errmsg ("next hop and next-hop via label set");
7918 if (address_set == 0)
7920 errmsg ("missing addresses");
7924 if (address_length_set == 0)
7926 errmsg ("missing address length");
7930 /* Generate a pile of unique, random routes */
7933 u32 this_random_address;
7934 random_hash = hash_create (count, sizeof (uword));
7936 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
7937 for (j = 0; j <= count; j++)
7941 this_random_address = random_u32 (&random_seed);
7942 this_random_address =
7943 clib_host_to_net_u32 (this_random_address);
7945 while (hash_get (random_hash, this_random_address));
7946 vec_add1 (random_vector, this_random_address);
7947 hash_set (random_hash, this_random_address, 1);
7949 hash_free (random_hash);
7950 v4_dst_address.as_u32 = random_vector[0];
7955 /* Turn on async mode */
7956 vam->async_mode = 1;
7957 vam->async_errors = 0;
7958 before = vat_time_now (vam);
7961 for (j = 0; j < count; j++)
7963 /* Construct the API message */
7964 M2 (IP_ADD_DEL_ROUTE, mp,
7965 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7967 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7968 mp->table_id = ntohl (vrf_id);
7969 mp->create_vrf_if_needed = create_vrf_if_needed;
7971 mp->is_add = is_add;
7972 mp->is_drop = is_drop;
7973 mp->is_unreach = is_unreach;
7974 mp->is_prohibit = is_prohibit;
7975 mp->is_ipv6 = is_ipv6;
7976 mp->is_local = is_local;
7977 mp->is_classify = is_classify;
7978 mp->is_multipath = is_multipath;
7979 mp->is_resolve_host = resolve_host;
7980 mp->is_resolve_attached = resolve_attached;
7981 mp->next_hop_weight = next_hop_weight;
7982 mp->dst_address_length = dst_address_length;
7983 mp->next_hop_table_id = ntohl (next_hop_table_id);
7984 mp->classify_table_index = ntohl (classify_table_index);
7985 mp->next_hop_via_label = ntohl (next_hop_via_label);
7986 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7987 if (0 != mp->next_hop_n_out_labels)
7989 memcpy (mp->next_hop_out_label_stack,
7990 next_hop_out_label_stack,
7991 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7992 vec_free (next_hop_out_label_stack);
7997 clib_memcpy (mp->dst_address, &v6_dst_address,
7998 sizeof (v6_dst_address));
8000 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8001 sizeof (v6_next_hop_address));
8002 increment_v6_address (&v6_dst_address);
8006 clib_memcpy (mp->dst_address, &v4_dst_address,
8007 sizeof (v4_dst_address));
8009 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8010 sizeof (v4_next_hop_address));
8012 v4_dst_address.as_u32 = random_vector[j + 1];
8014 increment_v4_address (&v4_dst_address);
8018 /* If we receive SIGTERM, stop now... */
8023 /* When testing multiple add/del ops, use a control-ping to sync */
8026 vl_api_control_ping_t *mp_ping;
8030 /* Shut off async mode */
8031 vam->async_mode = 0;
8033 MPING (CONTROL_PING, mp_ping);
8036 timeout = vat_time_now (vam) + 1.0;
8037 while (vat_time_now (vam) < timeout)
8038 if (vam->result_ready == 1)
8043 if (vam->retval == -99)
8046 if (vam->async_errors > 0)
8048 errmsg ("%d asynchronous errors", vam->async_errors);
8051 vam->async_errors = 0;
8052 after = vat_time_now (vam);
8054 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8058 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8059 count, after - before, count / (after - before));
8065 /* Wait for a reply... */
8070 /* Return the good/bad news */
8071 return (vam->retval);
8075 api_ip_mroute_add_del (vat_main_t * vam)
8077 unformat_input_t *i = vam->input;
8078 vl_api_ip_mroute_add_del_t *mp;
8079 u32 sw_if_index = ~0, vrf_id = 0;
8082 u8 create_vrf_if_needed = 0;
8085 u32 grp_address_length = 0;
8086 ip4_address_t v4_grp_address, v4_src_address;
8087 ip6_address_t v6_grp_address, v6_src_address;
8088 mfib_itf_flags_t iflags = 0;
8089 mfib_entry_flags_t eflags = 0;
8092 /* Parse args required to build the message */
8093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8095 if (unformat (i, "sw_if_index %d", &sw_if_index))
8097 else if (unformat (i, "%U %U",
8098 unformat_ip4_address, &v4_src_address,
8099 unformat_ip4_address, &v4_grp_address))
8101 grp_address_length = 64;
8105 else if (unformat (i, "%U %U",
8106 unformat_ip6_address, &v6_src_address,
8107 unformat_ip6_address, &v6_grp_address))
8109 grp_address_length = 256;
8113 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8115 memset (&v4_src_address, 0, sizeof (v4_src_address));
8116 grp_address_length = 32;
8120 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8122 memset (&v6_src_address, 0, sizeof (v6_src_address));
8123 grp_address_length = 128;
8127 else if (unformat (i, "/%d", &grp_address_length))
8129 else if (unformat (i, "local"))
8133 else if (unformat (i, "del"))
8135 else if (unformat (i, "add"))
8137 else if (unformat (i, "vrf %d", &vrf_id))
8139 else if (unformat (i, "create-vrf"))
8140 create_vrf_if_needed = 1;
8141 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8143 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8147 clib_warning ("parse error '%U'", format_unformat_error, i);
8152 if (address_set == 0)
8154 errmsg ("missing addresses\n");
8158 /* Construct the API message */
8159 M (IP_MROUTE_ADD_DEL, mp);
8161 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8162 mp->table_id = ntohl (vrf_id);
8163 mp->create_vrf_if_needed = create_vrf_if_needed;
8165 mp->is_add = is_add;
8166 mp->is_ipv6 = is_ipv6;
8167 mp->is_local = is_local;
8168 mp->itf_flags = ntohl (iflags);
8169 mp->entry_flags = ntohl (eflags);
8170 mp->grp_address_length = grp_address_length;
8171 mp->grp_address_length = ntohs (mp->grp_address_length);
8175 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8176 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8180 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8181 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8187 /* Wait for a reply... */
8193 api_mpls_table_add_del (vat_main_t * vam)
8195 unformat_input_t *i = vam->input;
8196 vl_api_mpls_table_add_del_t *mp;
8201 /* Parse args required to build the message */
8202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8204 if (unformat (i, "table %d", &table_id))
8206 else if (unformat (i, "del"))
8208 else if (unformat (i, "add"))
8212 clib_warning ("parse error '%U'", format_unformat_error, i);
8219 errmsg ("missing table-ID");
8223 /* Construct the API message */
8224 M (MPLS_TABLE_ADD_DEL, mp);
8226 mp->mt_table_id = ntohl (table_id);
8227 mp->mt_is_add = is_add;
8232 /* Wait for a reply... */
8239 api_mpls_route_add_del (vat_main_t * vam)
8241 unformat_input_t *i = vam->input;
8242 vl_api_mpls_route_add_del_t *mp;
8243 u32 sw_if_index = ~0, table_id = 0;
8244 u8 create_table_if_needed = 0;
8246 u32 next_hop_weight = 1;
8247 u8 is_multipath = 0;
8248 u32 next_hop_table_id = 0;
8249 u8 next_hop_set = 0;
8250 ip4_address_t v4_next_hop_address = {
8253 ip6_address_t v6_next_hop_address = { {0} };
8257 u32 classify_table_index = ~0;
8259 u8 resolve_host = 0, resolve_attached = 0;
8260 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8261 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8262 mpls_label_t *next_hop_out_label_stack = NULL;
8263 mpls_label_t local_label = MPLS_LABEL_INVALID;
8265 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8267 /* Parse args required to build the message */
8268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8270 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8272 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8274 else if (unformat (i, "%d", &local_label))
8276 else if (unformat (i, "eos"))
8278 else if (unformat (i, "non-eos"))
8280 else if (unformat (i, "via %U", unformat_ip4_address,
8281 &v4_next_hop_address))
8284 next_hop_proto = DPO_PROTO_IP4;
8286 else if (unformat (i, "via %U", unformat_ip6_address,
8287 &v6_next_hop_address))
8290 next_hop_proto = DPO_PROTO_IP6;
8292 else if (unformat (i, "weight %d", &next_hop_weight))
8294 else if (unformat (i, "create-table"))
8295 create_table_if_needed = 1;
8296 else if (unformat (i, "classify %d", &classify_table_index))
8300 else if (unformat (i, "del"))
8302 else if (unformat (i, "add"))
8304 else if (unformat (i, "resolve-via-host"))
8306 else if (unformat (i, "resolve-via-attached"))
8307 resolve_attached = 1;
8308 else if (unformat (i, "multipath"))
8310 else if (unformat (i, "count %d", &count))
8312 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8315 next_hop_proto = DPO_PROTO_IP4;
8317 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8320 next_hop_proto = DPO_PROTO_IP6;
8322 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8324 else if (unformat (i, "via-label %d", &next_hop_via_label))
8326 else if (unformat (i, "out-label %d", &next_hop_out_label))
8327 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8330 clib_warning ("parse error '%U'", format_unformat_error, i);
8335 if (!next_hop_set && !is_classify)
8337 errmsg ("next hop / classify not set");
8341 if (MPLS_LABEL_INVALID == local_label)
8343 errmsg ("missing label");
8349 /* Turn on async mode */
8350 vam->async_mode = 1;
8351 vam->async_errors = 0;
8352 before = vat_time_now (vam);
8355 for (j = 0; j < count; j++)
8357 /* Construct the API message */
8358 M2 (MPLS_ROUTE_ADD_DEL, mp,
8359 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8361 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8362 mp->mr_table_id = ntohl (table_id);
8363 mp->mr_create_table_if_needed = create_table_if_needed;
8365 mp->mr_is_add = is_add;
8366 mp->mr_next_hop_proto = next_hop_proto;
8367 mp->mr_is_classify = is_classify;
8368 mp->mr_is_multipath = is_multipath;
8369 mp->mr_is_resolve_host = resolve_host;
8370 mp->mr_is_resolve_attached = resolve_attached;
8371 mp->mr_next_hop_weight = next_hop_weight;
8372 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8373 mp->mr_classify_table_index = ntohl (classify_table_index);
8374 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8375 mp->mr_label = ntohl (local_label);
8376 mp->mr_eos = is_eos;
8378 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8379 if (0 != mp->mr_next_hop_n_out_labels)
8381 memcpy (mp->mr_next_hop_out_label_stack,
8382 next_hop_out_label_stack,
8383 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8384 vec_free (next_hop_out_label_stack);
8389 if (DPO_PROTO_IP4 == next_hop_proto)
8391 clib_memcpy (mp->mr_next_hop,
8392 &v4_next_hop_address,
8393 sizeof (v4_next_hop_address));
8395 else if (DPO_PROTO_IP6 == next_hop_proto)
8398 clib_memcpy (mp->mr_next_hop,
8399 &v6_next_hop_address,
8400 sizeof (v6_next_hop_address));
8407 /* If we receive SIGTERM, stop now... */
8412 /* When testing multiple add/del ops, use a control-ping to sync */
8415 vl_api_control_ping_t *mp_ping;
8419 /* Shut off async mode */
8420 vam->async_mode = 0;
8422 MPING (CONTROL_PING, mp_ping);
8425 timeout = vat_time_now (vam) + 1.0;
8426 while (vat_time_now (vam) < timeout)
8427 if (vam->result_ready == 1)
8432 if (vam->retval == -99)
8435 if (vam->async_errors > 0)
8437 errmsg ("%d asynchronous errors", vam->async_errors);
8440 vam->async_errors = 0;
8441 after = vat_time_now (vam);
8443 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8447 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8448 count, after - before, count / (after - before));
8454 /* Wait for a reply... */
8459 /* Return the good/bad news */
8460 return (vam->retval);
8464 api_mpls_ip_bind_unbind (vat_main_t * vam)
8466 unformat_input_t *i = vam->input;
8467 vl_api_mpls_ip_bind_unbind_t *mp;
8468 u32 ip_table_id = 0;
8469 u8 create_table_if_needed = 0;
8472 ip4_address_t v4_address;
8473 ip6_address_t v6_address;
8476 mpls_label_t local_label = MPLS_LABEL_INVALID;
8479 /* Parse args required to build the message */
8480 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8482 if (unformat (i, "%U/%d", unformat_ip4_address,
8483 &v4_address, &address_length))
8488 else if (unformat (i, "%U/%d", unformat_ip6_address,
8489 &v6_address, &address_length))
8494 else if (unformat (i, "%d", &local_label))
8496 else if (unformat (i, "create-table"))
8497 create_table_if_needed = 1;
8498 else if (unformat (i, "table-id %d", &ip_table_id))
8500 else if (unformat (i, "unbind"))
8502 else if (unformat (i, "bind"))
8506 clib_warning ("parse error '%U'", format_unformat_error, i);
8513 errmsg ("IP addres not set");
8517 if (MPLS_LABEL_INVALID == local_label)
8519 errmsg ("missing label");
8523 /* Construct the API message */
8524 M (MPLS_IP_BIND_UNBIND, mp);
8526 mp->mb_create_table_if_needed = create_table_if_needed;
8527 mp->mb_is_bind = is_bind;
8528 mp->mb_is_ip4 = is_ip4;
8529 mp->mb_ip_table_id = ntohl (ip_table_id);
8530 mp->mb_mpls_table_id = 0;
8531 mp->mb_label = ntohl (local_label);
8532 mp->mb_address_length = address_length;
8535 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8537 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8542 /* Wait for a reply... */
8548 api_proxy_arp_add_del (vat_main_t * vam)
8550 unformat_input_t *i = vam->input;
8551 vl_api_proxy_arp_add_del_t *mp;
8554 ip4_address_t lo, hi;
8558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8560 if (unformat (i, "vrf %d", &vrf_id))
8562 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8563 unformat_ip4_address, &hi))
8565 else if (unformat (i, "del"))
8569 clib_warning ("parse error '%U'", format_unformat_error, i);
8576 errmsg ("address range not set");
8580 M (PROXY_ARP_ADD_DEL, mp);
8582 mp->vrf_id = ntohl (vrf_id);
8583 mp->is_add = is_add;
8584 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8585 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8593 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8595 unformat_input_t *i = vam->input;
8596 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8599 u8 sw_if_index_set = 0;
8602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8604 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8605 sw_if_index_set = 1;
8606 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8607 sw_if_index_set = 1;
8608 else if (unformat (i, "enable"))
8610 else if (unformat (i, "disable"))
8614 clib_warning ("parse error '%U'", format_unformat_error, i);
8619 if (sw_if_index_set == 0)
8621 errmsg ("missing interface name or sw_if_index");
8625 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8627 mp->sw_if_index = ntohl (sw_if_index);
8628 mp->enable_disable = enable;
8636 api_mpls_tunnel_add_del (vat_main_t * vam)
8638 unformat_input_t *i = vam->input;
8639 vl_api_mpls_tunnel_add_del_t *mp;
8643 u32 sw_if_index = ~0;
8644 u32 next_hop_sw_if_index = ~0;
8645 u32 next_hop_proto_is_ip4 = 1;
8647 u32 next_hop_table_id = 0;
8648 ip4_address_t v4_next_hop_address = {
8651 ip6_address_t v6_next_hop_address = { {0} };
8652 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
8655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8657 if (unformat (i, "add"))
8659 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8661 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
8663 else if (unformat (i, "via %U",
8664 unformat_ip4_address, &v4_next_hop_address))
8666 next_hop_proto_is_ip4 = 1;
8668 else if (unformat (i, "via %U",
8669 unformat_ip6_address, &v6_next_hop_address))
8671 next_hop_proto_is_ip4 = 0;
8673 else if (unformat (i, "l2-only"))
8675 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8677 else if (unformat (i, "out-label %d", &next_hop_out_label))
8678 vec_add1 (labels, ntohl (next_hop_out_label));
8681 clib_warning ("parse error '%U'", format_unformat_error, i);
8686 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
8688 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
8689 mp->mt_sw_if_index = ntohl (sw_if_index);
8690 mp->mt_is_add = is_add;
8691 mp->mt_l2_only = l2_only;
8692 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
8693 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
8695 mp->mt_next_hop_n_out_labels = vec_len (labels);
8697 if (0 != mp->mt_next_hop_n_out_labels)
8699 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
8700 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
8704 if (next_hop_proto_is_ip4)
8706 clib_memcpy (mp->mt_next_hop,
8707 &v4_next_hop_address, sizeof (v4_next_hop_address));
8711 clib_memcpy (mp->mt_next_hop,
8712 &v6_next_hop_address, sizeof (v6_next_hop_address));
8721 api_sw_interface_set_unnumbered (vat_main_t * vam)
8723 unformat_input_t *i = vam->input;
8724 vl_api_sw_interface_set_unnumbered_t *mp;
8726 u32 unnum_sw_index = ~0;
8728 u8 sw_if_index_set = 0;
8731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8733 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8734 sw_if_index_set = 1;
8735 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8736 sw_if_index_set = 1;
8737 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8739 else if (unformat (i, "del"))
8743 clib_warning ("parse error '%U'", format_unformat_error, i);
8748 if (sw_if_index_set == 0)
8750 errmsg ("missing interface name or sw_if_index");
8754 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8756 mp->sw_if_index = ntohl (sw_if_index);
8757 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8758 mp->is_add = is_add;
8766 api_ip_neighbor_add_del (vat_main_t * vam)
8768 unformat_input_t *i = vam->input;
8769 vl_api_ip_neighbor_add_del_t *mp;
8771 u8 sw_if_index_set = 0;
8774 u8 is_no_fib_entry = 0;
8777 u8 v4_address_set = 0;
8778 u8 v6_address_set = 0;
8779 ip4_address_t v4address;
8780 ip6_address_t v6address;
8783 memset (mac_address, 0, sizeof (mac_address));
8785 /* Parse args required to build the message */
8786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8788 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8792 else if (unformat (i, "del"))
8795 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8796 sw_if_index_set = 1;
8797 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8798 sw_if_index_set = 1;
8799 else if (unformat (i, "is_static"))
8801 else if (unformat (i, "no-fib-entry"))
8802 is_no_fib_entry = 1;
8803 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
8805 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
8809 clib_warning ("parse error '%U'", format_unformat_error, i);
8814 if (sw_if_index_set == 0)
8816 errmsg ("missing interface name or sw_if_index");
8819 if (v4_address_set && v6_address_set)
8821 errmsg ("both v4 and v6 addresses set");
8824 if (!v4_address_set && !v6_address_set)
8826 errmsg ("no address set");
8830 /* Construct the API message */
8831 M (IP_NEIGHBOR_ADD_DEL, mp);
8833 mp->sw_if_index = ntohl (sw_if_index);
8834 mp->is_add = is_add;
8835 mp->is_static = is_static;
8836 mp->is_no_adj_fib = is_no_fib_entry;
8838 clib_memcpy (mp->mac_address, mac_address, 6);
8842 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
8846 /* mp->is_ipv6 = 0; via memset in M macro above */
8847 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
8853 /* Wait for a reply, return good/bad news */
8859 api_reset_vrf (vat_main_t * vam)
8861 unformat_input_t *i = vam->input;
8862 vl_api_reset_vrf_t *mp;
8868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8870 if (unformat (i, "vrf %d", &vrf_id))
8872 else if (unformat (i, "ipv6"))
8876 clib_warning ("parse error '%U'", format_unformat_error, i);
8881 if (vrf_id_set == 0)
8883 errmsg ("missing vrf id");
8889 mp->vrf_id = ntohl (vrf_id);
8890 mp->is_ipv6 = is_ipv6;
8898 api_create_vlan_subif (vat_main_t * vam)
8900 unformat_input_t *i = vam->input;
8901 vl_api_create_vlan_subif_t *mp;
8903 u8 sw_if_index_set = 0;
8908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8910 if (unformat (i, "sw_if_index %d", &sw_if_index))
8911 sw_if_index_set = 1;
8913 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8914 sw_if_index_set = 1;
8915 else if (unformat (i, "vlan %d", &vlan_id))
8919 clib_warning ("parse error '%U'", format_unformat_error, i);
8924 if (sw_if_index_set == 0)
8926 errmsg ("missing interface name or sw_if_index");
8930 if (vlan_id_set == 0)
8932 errmsg ("missing vlan_id");
8935 M (CREATE_VLAN_SUBIF, mp);
8937 mp->sw_if_index = ntohl (sw_if_index);
8938 mp->vlan_id = ntohl (vlan_id);
8945 #define foreach_create_subif_bit \
8952 _(outer_vlan_id_any) \
8953 _(inner_vlan_id_any)
8956 api_create_subif (vat_main_t * vam)
8958 unformat_input_t *i = vam->input;
8959 vl_api_create_subif_t *mp;
8961 u8 sw_if_index_set = 0;
8968 u32 exact_match = 0;
8969 u32 default_sub = 0;
8970 u32 outer_vlan_id_any = 0;
8971 u32 inner_vlan_id_any = 0;
8973 u16 outer_vlan_id = 0;
8974 u16 inner_vlan_id = 0;
8977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8979 if (unformat (i, "sw_if_index %d", &sw_if_index))
8980 sw_if_index_set = 1;
8982 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8983 sw_if_index_set = 1;
8984 else if (unformat (i, "sub_id %d", &sub_id))
8986 else if (unformat (i, "outer_vlan_id %d", &tmp))
8987 outer_vlan_id = tmp;
8988 else if (unformat (i, "inner_vlan_id %d", &tmp))
8989 inner_vlan_id = tmp;
8991 #define _(a) else if (unformat (i, #a)) a = 1 ;
8992 foreach_create_subif_bit
8996 clib_warning ("parse error '%U'", format_unformat_error, i);
9001 if (sw_if_index_set == 0)
9003 errmsg ("missing interface name or sw_if_index");
9007 if (sub_id_set == 0)
9009 errmsg ("missing sub_id");
9012 M (CREATE_SUBIF, mp);
9014 mp->sw_if_index = ntohl (sw_if_index);
9015 mp->sub_id = ntohl (sub_id);
9017 #define _(a) mp->a = a;
9018 foreach_create_subif_bit;
9021 mp->outer_vlan_id = ntohs (outer_vlan_id);
9022 mp->inner_vlan_id = ntohs (inner_vlan_id);
9030 api_oam_add_del (vat_main_t * vam)
9032 unformat_input_t *i = vam->input;
9033 vl_api_oam_add_del_t *mp;
9036 ip4_address_t src, dst;
9041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9043 if (unformat (i, "vrf %d", &vrf_id))
9045 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9047 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9049 else if (unformat (i, "del"))
9053 clib_warning ("parse error '%U'", format_unformat_error, i);
9060 errmsg ("missing src addr");
9066 errmsg ("missing dst addr");
9070 M (OAM_ADD_DEL, mp);
9072 mp->vrf_id = ntohl (vrf_id);
9073 mp->is_add = is_add;
9074 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9075 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9083 api_reset_fib (vat_main_t * vam)
9085 unformat_input_t *i = vam->input;
9086 vl_api_reset_fib_t *mp;
9092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9094 if (unformat (i, "vrf %d", &vrf_id))
9096 else if (unformat (i, "ipv6"))
9100 clib_warning ("parse error '%U'", format_unformat_error, i);
9105 if (vrf_id_set == 0)
9107 errmsg ("missing vrf id");
9113 mp->vrf_id = ntohl (vrf_id);
9114 mp->is_ipv6 = is_ipv6;
9122 api_dhcp_proxy_config (vat_main_t * vam)
9124 unformat_input_t *i = vam->input;
9125 vl_api_dhcp_proxy_config_t *mp;
9127 u32 server_vrf_id = 0;
9129 u8 v4_address_set = 0;
9130 u8 v6_address_set = 0;
9131 ip4_address_t v4address;
9132 ip6_address_t v6address;
9133 u8 v4_src_address_set = 0;
9134 u8 v6_src_address_set = 0;
9135 ip4_address_t v4srcaddress;
9136 ip6_address_t v6srcaddress;
9139 /* Parse args required to build the message */
9140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9142 if (unformat (i, "del"))
9144 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9146 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9148 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9150 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9152 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9153 v4_src_address_set = 1;
9154 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9155 v6_src_address_set = 1;
9160 if (v4_address_set && v6_address_set)
9162 errmsg ("both v4 and v6 server addresses set");
9165 if (!v4_address_set && !v6_address_set)
9167 errmsg ("no server addresses set");
9171 if (v4_src_address_set && v6_src_address_set)
9173 errmsg ("both v4 and v6 src addresses set");
9176 if (!v4_src_address_set && !v6_src_address_set)
9178 errmsg ("no src addresses set");
9182 if (!(v4_src_address_set && v4_address_set) &&
9183 !(v6_src_address_set && v6_address_set))
9185 errmsg ("no matching server and src addresses set");
9189 /* Construct the API message */
9190 M (DHCP_PROXY_CONFIG, mp);
9192 mp->is_add = is_add;
9193 mp->rx_vrf_id = ntohl (rx_vrf_id);
9194 mp->server_vrf_id = ntohl (server_vrf_id);
9198 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9199 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9203 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9204 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9210 /* Wait for a reply, return good/bad news */
9215 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9216 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9219 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9221 vat_main_t *vam = &vat_main;
9222 u32 i, count = mp->count;
9223 vl_api_dhcp_server_t *s;
9227 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9228 ntohl (mp->rx_vrf_id),
9229 format_ip6_address, mp->dhcp_src_address,
9230 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9233 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9234 ntohl (mp->rx_vrf_id),
9235 format_ip4_address, mp->dhcp_src_address,
9236 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9238 for (i = 0; i < count; i++)
9240 s = &mp->servers[i];
9244 " Server Table-ID %d, Server Address %U",
9245 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9248 " Server Table-ID %d, Server Address %U",
9249 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9253 static void vl_api_dhcp_proxy_details_t_handler_json
9254 (vl_api_dhcp_proxy_details_t * mp)
9256 vat_main_t *vam = &vat_main;
9257 vat_json_node_t *node = NULL;
9258 u32 i, count = mp->count;
9260 struct in6_addr ip6;
9261 vl_api_dhcp_server_t *s;
9263 if (VAT_JSON_ARRAY != vam->json_tree.type)
9265 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9266 vat_json_init_array (&vam->json_tree);
9268 node = vat_json_array_add (&vam->json_tree);
9270 vat_json_init_object (node);
9271 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9272 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9273 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9277 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9278 vat_json_object_add_ip6 (node, "src_address", ip6);
9282 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9283 vat_json_object_add_ip4 (node, "src_address", ip4);
9286 for (i = 0; i < count; i++)
9288 s = &mp->servers[i];
9290 vat_json_object_add_uint (node, "server-table-id",
9291 ntohl (s->server_vrf_id));
9295 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9296 vat_json_object_add_ip4 (node, "src_address", ip4);
9300 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9301 vat_json_object_add_ip6 (node, "server_address", ip6);
9307 api_dhcp_proxy_dump (vat_main_t * vam)
9309 unformat_input_t *i = vam->input;
9310 vl_api_control_ping_t *mp_ping;
9311 vl_api_dhcp_proxy_dump_t *mp;
9315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9317 if (unformat (i, "ipv6"))
9321 clib_warning ("parse error '%U'", format_unformat_error, i);
9326 M (DHCP_PROXY_DUMP, mp);
9328 mp->is_ip6 = is_ipv6;
9331 /* Use a control ping for synchronization */
9332 MPING (CONTROL_PING, mp_ping);
9340 api_dhcp_proxy_set_vss (vat_main_t * vam)
9342 unformat_input_t *i = vam->input;
9343 vl_api_dhcp_proxy_set_vss_t *mp;
9354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9356 if (unformat (i, "tbl_id %d", &tbl_id))
9358 if (unformat (i, "fib_id %d", &fib_id))
9360 if (unformat (i, "oui %d", &oui))
9362 else if (unformat (i, "ipv6"))
9364 else if (unformat (i, "del"))
9368 clib_warning ("parse error '%U'", format_unformat_error, i);
9373 if (tbl_id_set == 0)
9375 errmsg ("missing tbl id");
9379 if (fib_id_set == 0)
9381 errmsg ("missing fib id");
9386 errmsg ("missing oui");
9390 M (DHCP_PROXY_SET_VSS, mp);
9391 mp->tbl_id = ntohl (tbl_id);
9392 mp->fib_id = ntohl (fib_id);
9393 mp->oui = ntohl (oui);
9394 mp->is_ipv6 = is_ipv6;
9395 mp->is_add = is_add;
9403 api_dhcp_client_config (vat_main_t * vam)
9405 unformat_input_t *i = vam->input;
9406 vl_api_dhcp_client_config_t *mp;
9408 u8 sw_if_index_set = 0;
9411 u8 disable_event = 0;
9414 /* Parse args required to build the message */
9415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9417 if (unformat (i, "del"))
9420 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9421 sw_if_index_set = 1;
9422 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9423 sw_if_index_set = 1;
9424 else if (unformat (i, "hostname %s", &hostname))
9426 else if (unformat (i, "disable_event"))
9432 if (sw_if_index_set == 0)
9434 errmsg ("missing interface name or sw_if_index");
9438 if (vec_len (hostname) > 63)
9440 errmsg ("hostname too long");
9442 vec_add1 (hostname, 0);
9444 /* Construct the API message */
9445 M (DHCP_CLIENT_CONFIG, mp);
9447 mp->sw_if_index = htonl (sw_if_index);
9448 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9449 vec_free (hostname);
9450 mp->is_add = is_add;
9451 mp->want_dhcp_event = disable_event ? 0 : 1;
9452 mp->pid = htonl (getpid ());
9457 /* Wait for a reply, return good/bad news */
9463 api_set_ip_flow_hash (vat_main_t * vam)
9465 unformat_input_t *i = vam->input;
9466 vl_api_set_ip_flow_hash_t *mp;
9478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9480 if (unformat (i, "vrf %d", &vrf_id))
9482 else if (unformat (i, "ipv6"))
9484 else if (unformat (i, "src"))
9486 else if (unformat (i, "dst"))
9488 else if (unformat (i, "sport"))
9490 else if (unformat (i, "dport"))
9492 else if (unformat (i, "proto"))
9494 else if (unformat (i, "reverse"))
9499 clib_warning ("parse error '%U'", format_unformat_error, i);
9504 if (vrf_id_set == 0)
9506 errmsg ("missing vrf id");
9510 M (SET_IP_FLOW_HASH, mp);
9516 mp->reverse = reverse;
9517 mp->vrf_id = ntohl (vrf_id);
9518 mp->is_ipv6 = is_ipv6;
9526 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9528 unformat_input_t *i = vam->input;
9529 vl_api_sw_interface_ip6_enable_disable_t *mp;
9531 u8 sw_if_index_set = 0;
9535 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9537 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9538 sw_if_index_set = 1;
9539 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9540 sw_if_index_set = 1;
9541 else if (unformat (i, "enable"))
9543 else if (unformat (i, "disable"))
9547 clib_warning ("parse error '%U'", format_unformat_error, i);
9552 if (sw_if_index_set == 0)
9554 errmsg ("missing interface name or sw_if_index");
9558 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9560 mp->sw_if_index = ntohl (sw_if_index);
9561 mp->enable = enable;
9569 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9571 unformat_input_t *i = vam->input;
9572 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9574 u8 sw_if_index_set = 0;
9575 u8 v6_address_set = 0;
9576 ip6_address_t v6address;
9579 /* Parse args required to build the message */
9580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9582 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9583 sw_if_index_set = 1;
9584 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9585 sw_if_index_set = 1;
9586 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9592 if (sw_if_index_set == 0)
9594 errmsg ("missing interface name or sw_if_index");
9597 if (!v6_address_set)
9599 errmsg ("no address set");
9603 /* Construct the API message */
9604 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9606 mp->sw_if_index = ntohl (sw_if_index);
9607 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9612 /* Wait for a reply, return good/bad news */
9618 api_ip6nd_proxy_add_del (vat_main_t * vam)
9620 unformat_input_t *i = vam->input;
9621 vl_api_ip6nd_proxy_add_del_t *mp;
9622 u32 sw_if_index = ~0;
9623 u8 v6_address_set = 0;
9624 ip6_address_t v6address;
9628 /* Parse args required to build the message */
9629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9631 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9633 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9635 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9637 if (unformat (i, "del"))
9641 clib_warning ("parse error '%U'", format_unformat_error, i);
9646 if (sw_if_index == ~0)
9648 errmsg ("missing interface name or sw_if_index");
9651 if (!v6_address_set)
9653 errmsg ("no address set");
9657 /* Construct the API message */
9658 M (IP6ND_PROXY_ADD_DEL, mp);
9660 mp->is_del = is_del;
9661 mp->sw_if_index = ntohl (sw_if_index);
9662 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9667 /* Wait for a reply, return good/bad news */
9673 api_ip6nd_proxy_dump (vat_main_t * vam)
9675 vl_api_ip6nd_proxy_dump_t *mp;
9676 vl_api_control_ping_t *mp_ping;
9679 M (IP6ND_PROXY_DUMP, mp);
9683 /* Use a control ping for synchronization */
9684 MPING (CONTROL_PING, mp_ping);
9691 static void vl_api_ip6nd_proxy_details_t_handler
9692 (vl_api_ip6nd_proxy_details_t * mp)
9694 vat_main_t *vam = &vat_main;
9696 print (vam->ofp, "host %U sw_if_index %d",
9697 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
9700 static void vl_api_ip6nd_proxy_details_t_handler_json
9701 (vl_api_ip6nd_proxy_details_t * mp)
9703 vat_main_t *vam = &vat_main;
9704 struct in6_addr ip6;
9705 vat_json_node_t *node = NULL;
9707 if (VAT_JSON_ARRAY != vam->json_tree.type)
9709 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9710 vat_json_init_array (&vam->json_tree);
9712 node = vat_json_array_add (&vam->json_tree);
9714 vat_json_init_object (node);
9715 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9717 clib_memcpy (&ip6, mp->address, sizeof (ip6));
9718 vat_json_object_add_ip6 (node, "host", ip6);
9722 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9724 unformat_input_t *i = vam->input;
9725 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9727 u8 sw_if_index_set = 0;
9728 u32 address_length = 0;
9729 u8 v6_address_set = 0;
9730 ip6_address_t v6address;
9732 u8 no_advertise = 0;
9734 u8 no_autoconfig = 0;
9737 u32 val_lifetime = 0;
9738 u32 pref_lifetime = 0;
9741 /* Parse args required to build the message */
9742 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9744 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9745 sw_if_index_set = 1;
9746 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9747 sw_if_index_set = 1;
9748 else if (unformat (i, "%U/%d",
9749 unformat_ip6_address, &v6address, &address_length))
9751 else if (unformat (i, "val_life %d", &val_lifetime))
9753 else if (unformat (i, "pref_life %d", &pref_lifetime))
9755 else if (unformat (i, "def"))
9757 else if (unformat (i, "noadv"))
9759 else if (unformat (i, "offl"))
9761 else if (unformat (i, "noauto"))
9763 else if (unformat (i, "nolink"))
9765 else if (unformat (i, "isno"))
9769 clib_warning ("parse error '%U'", format_unformat_error, i);
9774 if (sw_if_index_set == 0)
9776 errmsg ("missing interface name or sw_if_index");
9779 if (!v6_address_set)
9781 errmsg ("no address set");
9785 /* Construct the API message */
9786 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9788 mp->sw_if_index = ntohl (sw_if_index);
9789 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9790 mp->address_length = address_length;
9791 mp->use_default = use_default;
9792 mp->no_advertise = no_advertise;
9793 mp->off_link = off_link;
9794 mp->no_autoconfig = no_autoconfig;
9795 mp->no_onlink = no_onlink;
9797 mp->val_lifetime = ntohl (val_lifetime);
9798 mp->pref_lifetime = ntohl (pref_lifetime);
9803 /* Wait for a reply, return good/bad news */
9809 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9811 unformat_input_t *i = vam->input;
9812 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9814 u8 sw_if_index_set = 0;
9819 u8 send_unicast = 0;
9822 u8 default_router = 0;
9823 u32 max_interval = 0;
9824 u32 min_interval = 0;
9826 u32 initial_count = 0;
9827 u32 initial_interval = 0;
9831 /* Parse args required to build the message */
9832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9834 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9835 sw_if_index_set = 1;
9836 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9837 sw_if_index_set = 1;
9838 else if (unformat (i, "maxint %d", &max_interval))
9840 else if (unformat (i, "minint %d", &min_interval))
9842 else if (unformat (i, "life %d", &lifetime))
9844 else if (unformat (i, "count %d", &initial_count))
9846 else if (unformat (i, "interval %d", &initial_interval))
9848 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9850 else if (unformat (i, "managed"))
9852 else if (unformat (i, "other"))
9854 else if (unformat (i, "ll"))
9856 else if (unformat (i, "send"))
9858 else if (unformat (i, "cease"))
9860 else if (unformat (i, "isno"))
9862 else if (unformat (i, "def"))
9866 clib_warning ("parse error '%U'", format_unformat_error, i);
9871 if (sw_if_index_set == 0)
9873 errmsg ("missing interface name or sw_if_index");
9877 /* Construct the API message */
9878 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9880 mp->sw_if_index = ntohl (sw_if_index);
9881 mp->max_interval = ntohl (max_interval);
9882 mp->min_interval = ntohl (min_interval);
9883 mp->lifetime = ntohl (lifetime);
9884 mp->initial_count = ntohl (initial_count);
9885 mp->initial_interval = ntohl (initial_interval);
9886 mp->suppress = suppress;
9887 mp->managed = managed;
9889 mp->ll_option = ll_option;
9890 mp->send_unicast = send_unicast;
9893 mp->default_router = default_router;
9898 /* Wait for a reply, return good/bad news */
9904 api_set_arp_neighbor_limit (vat_main_t * vam)
9906 unformat_input_t *i = vam->input;
9907 vl_api_set_arp_neighbor_limit_t *mp;
9913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9915 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9917 else if (unformat (i, "ipv6"))
9921 clib_warning ("parse error '%U'", format_unformat_error, i);
9928 errmsg ("missing limit value");
9932 M (SET_ARP_NEIGHBOR_LIMIT, mp);
9934 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
9935 mp->is_ipv6 = is_ipv6;
9943 api_l2_patch_add_del (vat_main_t * vam)
9945 unformat_input_t *i = vam->input;
9946 vl_api_l2_patch_add_del_t *mp;
9948 u8 rx_sw_if_index_set = 0;
9950 u8 tx_sw_if_index_set = 0;
9954 /* Parse args required to build the message */
9955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9957 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9958 rx_sw_if_index_set = 1;
9959 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9960 tx_sw_if_index_set = 1;
9961 else if (unformat (i, "rx"))
9963 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9965 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9967 rx_sw_if_index_set = 1;
9972 else if (unformat (i, "tx"))
9974 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9976 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9978 tx_sw_if_index_set = 1;
9983 else if (unformat (i, "del"))
9989 if (rx_sw_if_index_set == 0)
9991 errmsg ("missing rx interface name or rx_sw_if_index");
9995 if (tx_sw_if_index_set == 0)
9997 errmsg ("missing tx interface name or tx_sw_if_index");
10001 M (L2_PATCH_ADD_DEL, mp);
10003 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10004 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10005 mp->is_add = is_add;
10013 u8 localsid_addr[16];
10022 api_sr_localsid_add_del (vat_main_t * vam)
10024 unformat_input_t *i = vam->input;
10025 vl_api_sr_localsid_add_del_t *mp;
10028 ip6_address_t localsid;
10032 u32 fib_table = ~(u32) 0;
10033 ip6_address_t next_hop;
10035 bool nexthop_set = 0;
10039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10041 if (unformat (i, "del"))
10043 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10044 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10046 else if (unformat (i, "behavior %u", &behavior));
10047 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10048 else if (unformat (i, "fib-table %u", &fib_table));
10049 else if (unformat (i, "end.psp %u", &behavior));
10054 M (SR_LOCALSID_ADD_DEL, mp);
10056 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10058 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10059 mp->behavior = behavior;
10060 mp->sw_if_index = ntohl (sw_if_index);
10061 mp->fib_table = ntohl (fib_table);
10062 mp->end_psp = end_psp;
10063 mp->is_del = is_del;
10071 api_ioam_enable (vat_main_t * vam)
10073 unformat_input_t *input = vam->input;
10074 vl_api_ioam_enable_t *mp;
10076 int has_trace_option = 0;
10077 int has_pot_option = 0;
10078 int has_seqno_option = 0;
10079 int has_analyse_option = 0;
10082 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10084 if (unformat (input, "trace"))
10085 has_trace_option = 1;
10086 else if (unformat (input, "pot"))
10087 has_pot_option = 1;
10088 else if (unformat (input, "seqno"))
10089 has_seqno_option = 1;
10090 else if (unformat (input, "analyse"))
10091 has_analyse_option = 1;
10095 M (IOAM_ENABLE, mp);
10096 mp->id = htons (id);
10097 mp->seqno = has_seqno_option;
10098 mp->analyse = has_analyse_option;
10099 mp->pot_enable = has_pot_option;
10100 mp->trace_enable = has_trace_option;
10109 api_ioam_disable (vat_main_t * vam)
10111 vl_api_ioam_disable_t *mp;
10114 M (IOAM_DISABLE, mp);
10120 #define foreach_tcp_proto_field \
10124 #define foreach_udp_proto_field \
10128 #define foreach_ip4_proto_field \
10140 u16 src_port, dst_port;
10143 #if VPP_API_TEST_BUILTIN == 0
10145 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10147 u8 **maskp = va_arg (*args, u8 **);
10149 u8 found_something = 0;
10152 #define _(a) u8 a=0;
10153 foreach_tcp_proto_field;
10156 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10159 #define _(a) else if (unformat (input, #a)) a=1;
10160 foreach_tcp_proto_field
10166 #define _(a) found_something += a;
10167 foreach_tcp_proto_field;
10170 if (found_something == 0)
10173 vec_validate (mask, sizeof (*tcp) - 1);
10175 tcp = (tcp_header_t *) mask;
10177 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10178 foreach_tcp_proto_field;
10186 unformat_udp_mask (unformat_input_t * input, va_list * args)
10188 u8 **maskp = va_arg (*args, u8 **);
10190 u8 found_something = 0;
10193 #define _(a) u8 a=0;
10194 foreach_udp_proto_field;
10197 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10200 #define _(a) else if (unformat (input, #a)) a=1;
10201 foreach_udp_proto_field
10207 #define _(a) found_something += a;
10208 foreach_udp_proto_field;
10211 if (found_something == 0)
10214 vec_validate (mask, sizeof (*udp) - 1);
10216 udp = (udp_header_t *) mask;
10218 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10219 foreach_udp_proto_field;
10227 unformat_l4_mask (unformat_input_t * input, va_list * args)
10229 u8 **maskp = va_arg (*args, u8 **);
10230 u16 src_port = 0, dst_port = 0;
10231 tcpudp_header_t *tcpudp;
10233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10235 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10237 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10239 else if (unformat (input, "src_port"))
10241 else if (unformat (input, "dst_port"))
10247 if (!src_port && !dst_port)
10251 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10253 tcpudp = (tcpudp_header_t *) mask;
10254 tcpudp->src_port = src_port;
10255 tcpudp->dst_port = dst_port;
10263 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10265 u8 **maskp = va_arg (*args, u8 **);
10267 u8 found_something = 0;
10270 #define _(a) u8 a=0;
10271 foreach_ip4_proto_field;
10277 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10279 if (unformat (input, "version"))
10281 else if (unformat (input, "hdr_length"))
10283 else if (unformat (input, "src"))
10285 else if (unformat (input, "dst"))
10287 else if (unformat (input, "proto"))
10290 #define _(a) else if (unformat (input, #a)) a=1;
10291 foreach_ip4_proto_field
10297 #define _(a) found_something += a;
10298 foreach_ip4_proto_field;
10301 if (found_something == 0)
10304 vec_validate (mask, sizeof (*ip) - 1);
10306 ip = (ip4_header_t *) mask;
10308 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10309 foreach_ip4_proto_field;
10312 ip->ip_version_and_header_length = 0;
10315 ip->ip_version_and_header_length |= 0xF0;
10318 ip->ip_version_and_header_length |= 0x0F;
10324 #define foreach_ip6_proto_field \
10327 _(payload_length) \
10332 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10334 u8 **maskp = va_arg (*args, u8 **);
10336 u8 found_something = 0;
10338 u32 ip_version_traffic_class_and_flow_label;
10340 #define _(a) u8 a=0;
10341 foreach_ip6_proto_field;
10344 u8 traffic_class = 0;
10347 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10349 if (unformat (input, "version"))
10351 else if (unformat (input, "traffic-class"))
10353 else if (unformat (input, "flow-label"))
10355 else if (unformat (input, "src"))
10357 else if (unformat (input, "dst"))
10359 else if (unformat (input, "proto"))
10362 #define _(a) else if (unformat (input, #a)) a=1;
10363 foreach_ip6_proto_field
10369 #define _(a) found_something += a;
10370 foreach_ip6_proto_field;
10373 if (found_something == 0)
10376 vec_validate (mask, sizeof (*ip) - 1);
10378 ip = (ip6_header_t *) mask;
10380 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10381 foreach_ip6_proto_field;
10384 ip_version_traffic_class_and_flow_label = 0;
10387 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10390 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10393 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10395 ip->ip_version_traffic_class_and_flow_label =
10396 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10403 unformat_l3_mask (unformat_input_t * input, va_list * args)
10405 u8 **maskp = va_arg (*args, u8 **);
10407 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10409 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10411 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10420 unformat_l2_mask (unformat_input_t * input, va_list * args)
10422 u8 **maskp = va_arg (*args, u8 **);
10429 u8 ignore_tag1 = 0;
10430 u8 ignore_tag2 = 0;
10437 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10439 if (unformat (input, "src"))
10441 else if (unformat (input, "dst"))
10443 else if (unformat (input, "proto"))
10445 else if (unformat (input, "tag1"))
10447 else if (unformat (input, "tag2"))
10449 else if (unformat (input, "ignore-tag1"))
10451 else if (unformat (input, "ignore-tag2"))
10453 else if (unformat (input, "cos1"))
10455 else if (unformat (input, "cos2"))
10457 else if (unformat (input, "dot1q"))
10459 else if (unformat (input, "dot1ad"))
10464 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10465 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10468 if (tag1 || ignore_tag1 || cos1 || dot1q)
10470 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10473 vec_validate (mask, len - 1);
10476 memset (mask, 0xff, 6);
10479 memset (mask + 6, 0xff, 6);
10481 if (tag2 || dot1ad)
10483 /* inner vlan tag */
10492 mask[21] = mask[20] = 0xff;
10513 mask[16] = mask[17] = 0xff;
10523 mask[12] = mask[13] = 0xff;
10530 unformat_classify_mask (unformat_input_t * input, va_list * args)
10532 u8 **maskp = va_arg (*args, u8 **);
10533 u32 *skipp = va_arg (*args, u32 *);
10534 u32 *matchp = va_arg (*args, u32 *);
10542 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10544 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10546 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10548 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10550 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10564 if (mask || l2 || l3 || l4)
10566 if (l2 || l3 || l4)
10568 /* "With a free Ethernet header in every package" */
10570 vec_validate (l2, 13);
10574 vec_append (mask, l3);
10579 vec_append (mask, l4);
10584 /* Scan forward looking for the first significant mask octet */
10585 for (i = 0; i < vec_len (mask); i++)
10589 /* compute (skip, match) params */
10590 *skipp = i / sizeof (u32x4);
10591 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10593 /* Pad mask to an even multiple of the vector size */
10594 while (vec_len (mask) % sizeof (u32x4))
10595 vec_add1 (mask, 0);
10597 match = vec_len (mask) / sizeof (u32x4);
10599 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10601 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10602 if (*tmp || *(tmp + 1))
10607 clib_warning ("BUG: match 0");
10609 _vec_len (mask) = match * sizeof (u32x4);
10619 #endif /* VPP_API_TEST_BUILTIN */
10621 #define foreach_l2_next \
10623 _(ethernet, ETHERNET_INPUT) \
10624 _(ip4, IP4_INPUT) \
10628 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10630 u32 *miss_next_indexp = va_arg (*args, u32 *);
10631 u32 next_index = 0;
10635 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10639 if (unformat (input, "%d", &tmp))
10648 *miss_next_indexp = next_index;
10652 #define foreach_ip_next \
10655 _(rewrite, REWRITE)
10658 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10660 u32 *miss_next_indexp = va_arg (*args, u32 *);
10661 u32 next_index = 0;
10665 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10669 if (unformat (input, "%d", &tmp))
10678 *miss_next_indexp = next_index;
10682 #define foreach_acl_next \
10686 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10688 u32 *miss_next_indexp = va_arg (*args, u32 *);
10689 u32 next_index = 0;
10693 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10697 if (unformat (input, "permit"))
10702 else if (unformat (input, "%d", &tmp))
10711 *miss_next_indexp = next_index;
10716 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10718 u32 *r = va_arg (*args, u32 *);
10720 if (unformat (input, "conform-color"))
10721 *r = POLICE_CONFORM;
10722 else if (unformat (input, "exceed-color"))
10723 *r = POLICE_EXCEED;
10731 api_classify_add_del_table (vat_main_t * vam)
10733 unformat_input_t *i = vam->input;
10734 vl_api_classify_add_del_table_t *mp;
10741 u32 table_index = ~0;
10742 u32 next_table_index = ~0;
10743 u32 miss_next_index = ~0;
10744 u32 memory_size = 32 << 20;
10746 u32 current_data_flag = 0;
10747 int current_data_offset = 0;
10750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10752 if (unformat (i, "del"))
10754 else if (unformat (i, "del-chain"))
10759 else if (unformat (i, "buckets %d", &nbuckets))
10761 else if (unformat (i, "memory_size %d", &memory_size))
10763 else if (unformat (i, "skip %d", &skip))
10765 else if (unformat (i, "match %d", &match))
10767 else if (unformat (i, "table %d", &table_index))
10769 else if (unformat (i, "mask %U", unformat_classify_mask,
10770 &mask, &skip, &match))
10772 else if (unformat (i, "next-table %d", &next_table_index))
10774 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10777 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10780 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10783 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10785 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10791 if (is_add && mask == 0)
10793 errmsg ("Mask required");
10797 if (is_add && skip == ~0)
10799 errmsg ("skip count required");
10803 if (is_add && match == ~0)
10805 errmsg ("match count required");
10809 if (!is_add && table_index == ~0)
10811 errmsg ("table index required for delete");
10815 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10817 mp->is_add = is_add;
10818 mp->del_chain = del_chain;
10819 mp->table_index = ntohl (table_index);
10820 mp->nbuckets = ntohl (nbuckets);
10821 mp->memory_size = ntohl (memory_size);
10822 mp->skip_n_vectors = ntohl (skip);
10823 mp->match_n_vectors = ntohl (match);
10824 mp->next_table_index = ntohl (next_table_index);
10825 mp->miss_next_index = ntohl (miss_next_index);
10826 mp->current_data_flag = ntohl (current_data_flag);
10827 mp->current_data_offset = ntohl (current_data_offset);
10828 clib_memcpy (mp->mask, mask, vec_len (mask));
10837 #if VPP_API_TEST_BUILTIN == 0
10839 unformat_l4_match (unformat_input_t * input, va_list * args)
10841 u8 **matchp = va_arg (*args, u8 **);
10843 u8 *proto_header = 0;
10849 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10851 if (unformat (input, "src_port %d", &src_port))
10853 else if (unformat (input, "dst_port %d", &dst_port))
10859 h.src_port = clib_host_to_net_u16 (src_port);
10860 h.dst_port = clib_host_to_net_u16 (dst_port);
10861 vec_validate (proto_header, sizeof (h) - 1);
10862 memcpy (proto_header, &h, sizeof (h));
10864 *matchp = proto_header;
10870 unformat_ip4_match (unformat_input_t * input, va_list * args)
10872 u8 **matchp = va_arg (*args, u8 **);
10877 int hdr_length = 0;
10878 u32 hdr_length_val;
10879 int src = 0, dst = 0;
10880 ip4_address_t src_val, dst_val;
10887 int fragment_id = 0;
10888 u32 fragment_id_val;
10894 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10896 if (unformat (input, "version %d", &version_val))
10898 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10900 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10902 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10904 else if (unformat (input, "proto %d", &proto_val))
10906 else if (unformat (input, "tos %d", &tos_val))
10908 else if (unformat (input, "length %d", &length_val))
10910 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10912 else if (unformat (input, "ttl %d", &ttl_val))
10914 else if (unformat (input, "checksum %d", &checksum_val))
10920 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10921 + ttl + checksum == 0)
10925 * Aligned because we use the real comparison functions
10927 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10929 ip = (ip4_header_t *) match;
10931 /* These are realistically matched in practice */
10933 ip->src_address.as_u32 = src_val.as_u32;
10936 ip->dst_address.as_u32 = dst_val.as_u32;
10939 ip->protocol = proto_val;
10942 /* These are not, but they're included for completeness */
10944 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10947 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10953 ip->length = clib_host_to_net_u16 (length_val);
10959 ip->checksum = clib_host_to_net_u16 (checksum_val);
10966 unformat_ip6_match (unformat_input_t * input, va_list * args)
10968 u8 **matchp = va_arg (*args, u8 **);
10973 u8 traffic_class = 0;
10974 u32 traffic_class_val = 0;
10977 int src = 0, dst = 0;
10978 ip6_address_t src_val, dst_val;
10981 int payload_length = 0;
10982 u32 payload_length_val;
10985 u32 ip_version_traffic_class_and_flow_label;
10987 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10989 if (unformat (input, "version %d", &version_val))
10991 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10993 else if (unformat (input, "flow_label %d", &flow_label_val))
10995 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10997 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10999 else if (unformat (input, "proto %d", &proto_val))
11001 else if (unformat (input, "payload_length %d", &payload_length_val))
11002 payload_length = 1;
11003 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11009 if (version + traffic_class + flow_label + src + dst + proto +
11010 payload_length + hop_limit == 0)
11014 * Aligned because we use the real comparison functions
11016 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11018 ip = (ip6_header_t *) match;
11021 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11024 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11027 ip->protocol = proto_val;
11029 ip_version_traffic_class_and_flow_label = 0;
11032 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11035 ip_version_traffic_class_and_flow_label |=
11036 (traffic_class_val & 0xFF) << 20;
11039 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11041 ip->ip_version_traffic_class_and_flow_label =
11042 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11044 if (payload_length)
11045 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11048 ip->hop_limit = hop_limit_val;
11055 unformat_l3_match (unformat_input_t * input, va_list * args)
11057 u8 **matchp = va_arg (*args, u8 **);
11059 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11061 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11063 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11072 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11074 u8 *tagp = va_arg (*args, u8 *);
11077 if (unformat (input, "%d", &tag))
11079 tagp[0] = (tag >> 8) & 0x0F;
11080 tagp[1] = tag & 0xFF;
11088 unformat_l2_match (unformat_input_t * input, va_list * args)
11090 u8 **matchp = va_arg (*args, u8 **);
11103 u8 ignore_tag1 = 0;
11104 u8 ignore_tag2 = 0;
11110 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11112 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11115 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11117 else if (unformat (input, "proto %U",
11118 unformat_ethernet_type_host_byte_order, &proto_val))
11120 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11122 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11124 else if (unformat (input, "ignore-tag1"))
11126 else if (unformat (input, "ignore-tag2"))
11128 else if (unformat (input, "cos1 %d", &cos1_val))
11130 else if (unformat (input, "cos2 %d", &cos2_val))
11135 if ((src + dst + proto + tag1 + tag2 +
11136 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11139 if (tag1 || ignore_tag1 || cos1)
11141 if (tag2 || ignore_tag2 || cos2)
11144 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11147 clib_memcpy (match, dst_val, 6);
11150 clib_memcpy (match + 6, src_val, 6);
11154 /* inner vlan tag */
11155 match[19] = tag2_val[1];
11156 match[18] = tag2_val[0];
11158 match[18] |= (cos2_val & 0x7) << 5;
11161 match[21] = proto_val & 0xff;
11162 match[20] = proto_val >> 8;
11166 match[15] = tag1_val[1];
11167 match[14] = tag1_val[0];
11170 match[14] |= (cos1_val & 0x7) << 5;
11176 match[15] = tag1_val[1];
11177 match[14] = tag1_val[0];
11180 match[17] = proto_val & 0xff;
11181 match[16] = proto_val >> 8;
11184 match[14] |= (cos1_val & 0x7) << 5;
11190 match[18] |= (cos2_val & 0x7) << 5;
11192 match[14] |= (cos1_val & 0x7) << 5;
11195 match[13] = proto_val & 0xff;
11196 match[12] = proto_val >> 8;
11205 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11207 u8 **matchp = va_arg (*args, u8 **);
11208 u32 skip_n_vectors = va_arg (*args, u32);
11209 u32 match_n_vectors = va_arg (*args, u32);
11216 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11218 if (unformat (input, "hex %U", unformat_hex_string, &match))
11220 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11222 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11224 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11238 if (match || l2 || l3 || l4)
11240 if (l2 || l3 || l4)
11242 /* "Win a free Ethernet header in every packet" */
11244 vec_validate_aligned (l2, 13, sizeof (u32x4));
11248 vec_append_aligned (match, l3, sizeof (u32x4));
11253 vec_append_aligned (match, l4, sizeof (u32x4));
11258 /* Make sure the vector is big enough even if key is all 0's */
11259 vec_validate_aligned
11260 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11263 /* Set size, include skipped vectors */
11264 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11275 api_classify_add_del_session (vat_main_t * vam)
11277 unformat_input_t *i = vam->input;
11278 vl_api_classify_add_del_session_t *mp;
11280 u32 table_index = ~0;
11281 u32 hit_next_index = ~0;
11282 u32 opaque_index = ~0;
11285 u32 skip_n_vectors = 0;
11286 u32 match_n_vectors = 0;
11292 * Warning: you have to supply skip_n and match_n
11293 * because the API client cant simply look at the classify
11297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11299 if (unformat (i, "del"))
11301 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11304 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11307 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11310 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11312 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11314 else if (unformat (i, "opaque-index %d", &opaque_index))
11316 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11318 else if (unformat (i, "match_n %d", &match_n_vectors))
11320 else if (unformat (i, "match %U", api_unformat_classify_match,
11321 &match, skip_n_vectors, match_n_vectors))
11323 else if (unformat (i, "advance %d", &advance))
11325 else if (unformat (i, "table-index %d", &table_index))
11327 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11329 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11331 else if (unformat (i, "action %d", &action))
11333 else if (unformat (i, "metadata %d", &metadata))
11339 if (table_index == ~0)
11341 errmsg ("Table index required");
11345 if (is_add && match == 0)
11347 errmsg ("Match value required");
11351 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11353 mp->is_add = is_add;
11354 mp->table_index = ntohl (table_index);
11355 mp->hit_next_index = ntohl (hit_next_index);
11356 mp->opaque_index = ntohl (opaque_index);
11357 mp->advance = ntohl (advance);
11358 mp->action = action;
11359 mp->metadata = ntohl (metadata);
11360 clib_memcpy (mp->match, match, vec_len (match));
11369 api_classify_set_interface_ip_table (vat_main_t * vam)
11371 unformat_input_t *i = vam->input;
11372 vl_api_classify_set_interface_ip_table_t *mp;
11374 int sw_if_index_set;
11375 u32 table_index = ~0;
11379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11381 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11382 sw_if_index_set = 1;
11383 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11384 sw_if_index_set = 1;
11385 else if (unformat (i, "table %d", &table_index))
11389 clib_warning ("parse error '%U'", format_unformat_error, i);
11394 if (sw_if_index_set == 0)
11396 errmsg ("missing interface name or sw_if_index");
11401 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11403 mp->sw_if_index = ntohl (sw_if_index);
11404 mp->table_index = ntohl (table_index);
11405 mp->is_ipv6 = is_ipv6;
11413 api_classify_set_interface_l2_tables (vat_main_t * vam)
11415 unformat_input_t *i = vam->input;
11416 vl_api_classify_set_interface_l2_tables_t *mp;
11418 int sw_if_index_set;
11419 u32 ip4_table_index = ~0;
11420 u32 ip6_table_index = ~0;
11421 u32 other_table_index = ~0;
11425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11427 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11428 sw_if_index_set = 1;
11429 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11430 sw_if_index_set = 1;
11431 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11433 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11435 else if (unformat (i, "other-table %d", &other_table_index))
11437 else if (unformat (i, "is-input %d", &is_input))
11441 clib_warning ("parse error '%U'", format_unformat_error, i);
11446 if (sw_if_index_set == 0)
11448 errmsg ("missing interface name or sw_if_index");
11453 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11455 mp->sw_if_index = ntohl (sw_if_index);
11456 mp->ip4_table_index = ntohl (ip4_table_index);
11457 mp->ip6_table_index = ntohl (ip6_table_index);
11458 mp->other_table_index = ntohl (other_table_index);
11459 mp->is_input = (u8) is_input;
11467 api_set_ipfix_exporter (vat_main_t * vam)
11469 unformat_input_t *i = vam->input;
11470 vl_api_set_ipfix_exporter_t *mp;
11471 ip4_address_t collector_address;
11472 u8 collector_address_set = 0;
11473 u32 collector_port = ~0;
11474 ip4_address_t src_address;
11475 u8 src_address_set = 0;
11478 u32 template_interval = ~0;
11479 u8 udp_checksum = 0;
11482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11484 if (unformat (i, "collector_address %U", unformat_ip4_address,
11485 &collector_address))
11486 collector_address_set = 1;
11487 else if (unformat (i, "collector_port %d", &collector_port))
11489 else if (unformat (i, "src_address %U", unformat_ip4_address,
11491 src_address_set = 1;
11492 else if (unformat (i, "vrf_id %d", &vrf_id))
11494 else if (unformat (i, "path_mtu %d", &path_mtu))
11496 else if (unformat (i, "template_interval %d", &template_interval))
11498 else if (unformat (i, "udp_checksum"))
11504 if (collector_address_set == 0)
11506 errmsg ("collector_address required");
11510 if (src_address_set == 0)
11512 errmsg ("src_address required");
11516 M (SET_IPFIX_EXPORTER, mp);
11518 memcpy (mp->collector_address, collector_address.data,
11519 sizeof (collector_address.data));
11520 mp->collector_port = htons ((u16) collector_port);
11521 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11522 mp->vrf_id = htonl (vrf_id);
11523 mp->path_mtu = htonl (path_mtu);
11524 mp->template_interval = htonl (template_interval);
11525 mp->udp_checksum = udp_checksum;
11533 api_set_ipfix_classify_stream (vat_main_t * vam)
11535 unformat_input_t *i = vam->input;
11536 vl_api_set_ipfix_classify_stream_t *mp;
11538 u32 src_port = UDP_DST_PORT_ipfix;
11541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11543 if (unformat (i, "domain %d", &domain_id))
11545 else if (unformat (i, "src_port %d", &src_port))
11549 errmsg ("unknown input `%U'", format_unformat_error, i);
11554 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11556 mp->domain_id = htonl (domain_id);
11557 mp->src_port = htons ((u16) src_port);
11565 api_ipfix_classify_table_add_del (vat_main_t * vam)
11567 unformat_input_t *i = vam->input;
11568 vl_api_ipfix_classify_table_add_del_t *mp;
11570 u32 classify_table_index = ~0;
11572 u8 transport_protocol = 255;
11575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11577 if (unformat (i, "add"))
11579 else if (unformat (i, "del"))
11581 else if (unformat (i, "table %d", &classify_table_index))
11583 else if (unformat (i, "ip4"))
11585 else if (unformat (i, "ip6"))
11587 else if (unformat (i, "tcp"))
11588 transport_protocol = 6;
11589 else if (unformat (i, "udp"))
11590 transport_protocol = 17;
11593 errmsg ("unknown input `%U'", format_unformat_error, i);
11600 errmsg ("expecting: add|del");
11603 if (classify_table_index == ~0)
11605 errmsg ("classifier table not specified");
11608 if (ip_version == 0)
11610 errmsg ("IP version not specified");
11614 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11616 mp->is_add = is_add;
11617 mp->table_id = htonl (classify_table_index);
11618 mp->ip_version = ip_version;
11619 mp->transport_protocol = transport_protocol;
11627 api_get_node_index (vat_main_t * vam)
11629 unformat_input_t *i = vam->input;
11630 vl_api_get_node_index_t *mp;
11634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11636 if (unformat (i, "node %s", &name))
11643 errmsg ("node name required");
11646 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11648 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11652 M (GET_NODE_INDEX, mp);
11653 clib_memcpy (mp->node_name, name, vec_len (name));
11662 api_get_next_index (vat_main_t * vam)
11664 unformat_input_t *i = vam->input;
11665 vl_api_get_next_index_t *mp;
11666 u8 *node_name = 0, *next_node_name = 0;
11669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11671 if (unformat (i, "node-name %s", &node_name))
11673 else if (unformat (i, "next-node-name %s", &next_node_name))
11677 if (node_name == 0)
11679 errmsg ("node name required");
11682 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11684 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11688 if (next_node_name == 0)
11690 errmsg ("next node name required");
11693 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11695 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11699 M (GET_NEXT_INDEX, mp);
11700 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11701 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11702 vec_free (node_name);
11703 vec_free (next_node_name);
11711 api_add_node_next (vat_main_t * vam)
11713 unformat_input_t *i = vam->input;
11714 vl_api_add_node_next_t *mp;
11719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11721 if (unformat (i, "node %s", &name))
11723 else if (unformat (i, "next %s", &next))
11730 errmsg ("node name required");
11733 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11735 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11740 errmsg ("next node required");
11743 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11745 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11749 M (ADD_NODE_NEXT, mp);
11750 clib_memcpy (mp->node_name, name, vec_len (name));
11751 clib_memcpy (mp->next_name, next, vec_len (next));
11761 api_l2tpv3_create_tunnel (vat_main_t * vam)
11763 unformat_input_t *i = vam->input;
11764 ip6_address_t client_address, our_address;
11765 int client_address_set = 0;
11766 int our_address_set = 0;
11767 u32 local_session_id = 0;
11768 u32 remote_session_id = 0;
11769 u64 local_cookie = 0;
11770 u64 remote_cookie = 0;
11771 u8 l2_sublayer_present = 0;
11772 vl_api_l2tpv3_create_tunnel_t *mp;
11775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11777 if (unformat (i, "client_address %U", unformat_ip6_address,
11779 client_address_set = 1;
11780 else if (unformat (i, "our_address %U", unformat_ip6_address,
11782 our_address_set = 1;
11783 else if (unformat (i, "local_session_id %d", &local_session_id))
11785 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11787 else if (unformat (i, "local_cookie %lld", &local_cookie))
11789 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11791 else if (unformat (i, "l2-sublayer-present"))
11792 l2_sublayer_present = 1;
11797 if (client_address_set == 0)
11799 errmsg ("client_address required");
11803 if (our_address_set == 0)
11805 errmsg ("our_address required");
11809 M (L2TPV3_CREATE_TUNNEL, mp);
11811 clib_memcpy (mp->client_address, client_address.as_u8,
11812 sizeof (mp->client_address));
11814 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11816 mp->local_session_id = ntohl (local_session_id);
11817 mp->remote_session_id = ntohl (remote_session_id);
11818 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11819 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11820 mp->l2_sublayer_present = l2_sublayer_present;
11829 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11831 unformat_input_t *i = vam->input;
11833 u8 sw_if_index_set = 0;
11834 u64 new_local_cookie = 0;
11835 u64 new_remote_cookie = 0;
11836 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11841 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11842 sw_if_index_set = 1;
11843 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11844 sw_if_index_set = 1;
11845 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11847 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11853 if (sw_if_index_set == 0)
11855 errmsg ("missing interface name or sw_if_index");
11859 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11861 mp->sw_if_index = ntohl (sw_if_index);
11862 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11863 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11871 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11873 unformat_input_t *i = vam->input;
11874 vl_api_l2tpv3_interface_enable_disable_t *mp;
11876 u8 sw_if_index_set = 0;
11877 u8 enable_disable = 1;
11880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11882 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11883 sw_if_index_set = 1;
11884 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11885 sw_if_index_set = 1;
11886 else if (unformat (i, "enable"))
11887 enable_disable = 1;
11888 else if (unformat (i, "disable"))
11889 enable_disable = 0;
11894 if (sw_if_index_set == 0)
11896 errmsg ("missing interface name or sw_if_index");
11900 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11902 mp->sw_if_index = ntohl (sw_if_index);
11903 mp->enable_disable = enable_disable;
11911 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11913 unformat_input_t *i = vam->input;
11914 vl_api_l2tpv3_set_lookup_key_t *mp;
11918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11920 if (unformat (i, "lookup_v6_src"))
11921 key = L2T_LOOKUP_SRC_ADDRESS;
11922 else if (unformat (i, "lookup_v6_dst"))
11923 key = L2T_LOOKUP_DST_ADDRESS;
11924 else if (unformat (i, "lookup_session_id"))
11925 key = L2T_LOOKUP_SESSION_ID;
11930 if (key == (u8) ~ 0)
11932 errmsg ("l2tp session lookup key unset");
11936 M (L2TPV3_SET_LOOKUP_KEY, mp);
11945 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11946 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11948 vat_main_t *vam = &vat_main;
11950 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11951 format_ip6_address, mp->our_address,
11952 format_ip6_address, mp->client_address,
11953 clib_net_to_host_u32 (mp->sw_if_index));
11956 " local cookies %016llx %016llx remote cookie %016llx",
11957 clib_net_to_host_u64 (mp->local_cookie[0]),
11958 clib_net_to_host_u64 (mp->local_cookie[1]),
11959 clib_net_to_host_u64 (mp->remote_cookie));
11961 print (vam->ofp, " local session-id %d remote session-id %d",
11962 clib_net_to_host_u32 (mp->local_session_id),
11963 clib_net_to_host_u32 (mp->remote_session_id));
11965 print (vam->ofp, " l2 specific sublayer %s\n",
11966 mp->l2_sublayer_present ? "preset" : "absent");
11970 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11971 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11973 vat_main_t *vam = &vat_main;
11974 vat_json_node_t *node = NULL;
11975 struct in6_addr addr;
11977 if (VAT_JSON_ARRAY != vam->json_tree.type)
11979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11980 vat_json_init_array (&vam->json_tree);
11982 node = vat_json_array_add (&vam->json_tree);
11984 vat_json_init_object (node);
11986 clib_memcpy (&addr, mp->our_address, sizeof (addr));
11987 vat_json_object_add_ip6 (node, "our_address", addr);
11988 clib_memcpy (&addr, mp->client_address, sizeof (addr));
11989 vat_json_object_add_ip6 (node, "client_address", addr);
11991 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11992 vat_json_init_array (lc);
11993 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11994 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11995 vat_json_object_add_uint (node, "remote_cookie",
11996 clib_net_to_host_u64 (mp->remote_cookie));
11998 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11999 vat_json_object_add_uint (node, "local_session_id",
12000 clib_net_to_host_u32 (mp->local_session_id));
12001 vat_json_object_add_uint (node, "remote_session_id",
12002 clib_net_to_host_u32 (mp->remote_session_id));
12003 vat_json_object_add_string_copy (node, "l2_sublayer",
12004 mp->l2_sublayer_present ? (u8 *) "present"
12005 : (u8 *) "absent");
12009 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12011 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12012 vl_api_control_ping_t *mp_ping;
12015 /* Get list of l2tpv3-tunnel interfaces */
12016 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12019 /* Use a control ping for synchronization */
12020 MPING (CONTROL_PING, mp_ping);
12028 static void vl_api_sw_interface_tap_details_t_handler
12029 (vl_api_sw_interface_tap_details_t * mp)
12031 vat_main_t *vam = &vat_main;
12033 print (vam->ofp, "%-16s %d",
12034 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12037 static void vl_api_sw_interface_tap_details_t_handler_json
12038 (vl_api_sw_interface_tap_details_t * mp)
12040 vat_main_t *vam = &vat_main;
12041 vat_json_node_t *node = NULL;
12043 if (VAT_JSON_ARRAY != vam->json_tree.type)
12045 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12046 vat_json_init_array (&vam->json_tree);
12048 node = vat_json_array_add (&vam->json_tree);
12050 vat_json_init_object (node);
12051 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12052 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12056 api_sw_interface_tap_dump (vat_main_t * vam)
12058 vl_api_sw_interface_tap_dump_t *mp;
12059 vl_api_control_ping_t *mp_ping;
12062 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12063 /* Get list of tap interfaces */
12064 M (SW_INTERFACE_TAP_DUMP, mp);
12067 /* Use a control ping for synchronization */
12068 MPING (CONTROL_PING, mp_ping);
12075 static uword unformat_vxlan_decap_next
12076 (unformat_input_t * input, va_list * args)
12078 u32 *result = va_arg (*args, u32 *);
12081 if (unformat (input, "l2"))
12082 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12083 else if (unformat (input, "%d", &tmp))
12091 api_vxlan_add_del_tunnel (vat_main_t * vam)
12093 unformat_input_t *line_input = vam->input;
12094 vl_api_vxlan_add_del_tunnel_t *mp;
12095 ip46_address_t src, dst;
12097 u8 ipv4_set = 0, ipv6_set = 0;
12101 u32 mcast_sw_if_index = ~0;
12102 u32 encap_vrf_id = 0;
12103 u32 decap_next_index = ~0;
12107 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12108 memset (&src, 0, sizeof src);
12109 memset (&dst, 0, sizeof dst);
12111 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12113 if (unformat (line_input, "del"))
12116 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12122 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12128 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12134 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12139 else if (unformat (line_input, "group %U %U",
12140 unformat_ip4_address, &dst.ip4,
12141 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12143 grp_set = dst_set = 1;
12146 else if (unformat (line_input, "group %U",
12147 unformat_ip4_address, &dst.ip4))
12149 grp_set = dst_set = 1;
12152 else if (unformat (line_input, "group %U %U",
12153 unformat_ip6_address, &dst.ip6,
12154 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12156 grp_set = dst_set = 1;
12159 else if (unformat (line_input, "group %U",
12160 unformat_ip6_address, &dst.ip6))
12162 grp_set = dst_set = 1;
12166 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12168 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12170 else if (unformat (line_input, "decap-next %U",
12171 unformat_vxlan_decap_next, &decap_next_index))
12173 else if (unformat (line_input, "vni %d", &vni))
12177 errmsg ("parse error '%U'", format_unformat_error, line_input);
12184 errmsg ("tunnel src address not specified");
12189 errmsg ("tunnel dst address not specified");
12193 if (grp_set && !ip46_address_is_multicast (&dst))
12195 errmsg ("tunnel group address not multicast");
12198 if (grp_set && mcast_sw_if_index == ~0)
12200 errmsg ("tunnel nonexistent multicast device");
12203 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12205 errmsg ("tunnel dst address must be unicast");
12210 if (ipv4_set && ipv6_set)
12212 errmsg ("both IPv4 and IPv6 addresses specified");
12216 if ((vni == 0) || (vni >> 24))
12218 errmsg ("vni not specified or out of range");
12222 M (VXLAN_ADD_DEL_TUNNEL, mp);
12226 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12227 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12231 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12232 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12234 mp->encap_vrf_id = ntohl (encap_vrf_id);
12235 mp->decap_next_index = ntohl (decap_next_index);
12236 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12237 mp->vni = ntohl (vni);
12238 mp->is_add = is_add;
12239 mp->is_ipv6 = ipv6_set;
12246 static void vl_api_vxlan_tunnel_details_t_handler
12247 (vl_api_vxlan_tunnel_details_t * mp)
12249 vat_main_t *vam = &vat_main;
12250 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12251 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12253 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12254 ntohl (mp->sw_if_index),
12255 format_ip46_address, &src, IP46_TYPE_ANY,
12256 format_ip46_address, &dst, IP46_TYPE_ANY,
12257 ntohl (mp->encap_vrf_id),
12258 ntohl (mp->decap_next_index), ntohl (mp->vni),
12259 ntohl (mp->mcast_sw_if_index));
12262 static void vl_api_vxlan_tunnel_details_t_handler_json
12263 (vl_api_vxlan_tunnel_details_t * mp)
12265 vat_main_t *vam = &vat_main;
12266 vat_json_node_t *node = NULL;
12268 if (VAT_JSON_ARRAY != vam->json_tree.type)
12270 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12271 vat_json_init_array (&vam->json_tree);
12273 node = vat_json_array_add (&vam->json_tree);
12275 vat_json_init_object (node);
12276 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12279 struct in6_addr ip6;
12281 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12282 vat_json_object_add_ip6 (node, "src_address", ip6);
12283 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12284 vat_json_object_add_ip6 (node, "dst_address", ip6);
12288 struct in_addr ip4;
12290 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12291 vat_json_object_add_ip4 (node, "src_address", ip4);
12292 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12293 vat_json_object_add_ip4 (node, "dst_address", ip4);
12295 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12296 vat_json_object_add_uint (node, "decap_next_index",
12297 ntohl (mp->decap_next_index));
12298 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12299 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12300 vat_json_object_add_uint (node, "mcast_sw_if_index",
12301 ntohl (mp->mcast_sw_if_index));
12305 api_vxlan_tunnel_dump (vat_main_t * vam)
12307 unformat_input_t *i = vam->input;
12308 vl_api_vxlan_tunnel_dump_t *mp;
12309 vl_api_control_ping_t *mp_ping;
12311 u8 sw_if_index_set = 0;
12314 /* Parse args required to build the message */
12315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12317 if (unformat (i, "sw_if_index %d", &sw_if_index))
12318 sw_if_index_set = 1;
12323 if (sw_if_index_set == 0)
12328 if (!vam->json_output)
12330 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12331 "sw_if_index", "src_address", "dst_address",
12332 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12335 /* Get list of vxlan-tunnel interfaces */
12336 M (VXLAN_TUNNEL_DUMP, mp);
12338 mp->sw_if_index = htonl (sw_if_index);
12342 /* Use a control ping for synchronization */
12343 MPING (CONTROL_PING, mp_ping);
12350 static uword unformat_geneve_decap_next
12351 (unformat_input_t * input, va_list * args)
12353 u32 *result = va_arg (*args, u32 *);
12356 if (unformat (input, "l2"))
12357 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12358 else if (unformat (input, "%d", &tmp))
12366 api_geneve_add_del_tunnel (vat_main_t * vam)
12368 unformat_input_t *line_input = vam->input;
12369 vl_api_geneve_add_del_tunnel_t *mp;
12370 ip46_address_t src, dst;
12372 u8 ipv4_set = 0, ipv6_set = 0;
12376 u32 mcast_sw_if_index = ~0;
12377 u32 encap_vrf_id = 0;
12378 u32 decap_next_index = ~0;
12382 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12383 memset (&src, 0, sizeof src);
12384 memset (&dst, 0, sizeof dst);
12386 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12388 if (unformat (line_input, "del"))
12391 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12397 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12403 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12409 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12414 else if (unformat (line_input, "group %U %U",
12415 unformat_ip4_address, &dst.ip4,
12416 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12418 grp_set = dst_set = 1;
12421 else if (unformat (line_input, "group %U",
12422 unformat_ip4_address, &dst.ip4))
12424 grp_set = dst_set = 1;
12427 else if (unformat (line_input, "group %U %U",
12428 unformat_ip6_address, &dst.ip6,
12429 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12431 grp_set = dst_set = 1;
12434 else if (unformat (line_input, "group %U",
12435 unformat_ip6_address, &dst.ip6))
12437 grp_set = dst_set = 1;
12441 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12443 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12445 else if (unformat (line_input, "decap-next %U",
12446 unformat_geneve_decap_next, &decap_next_index))
12448 else if (unformat (line_input, "vni %d", &vni))
12452 errmsg ("parse error '%U'", format_unformat_error, line_input);
12459 errmsg ("tunnel src address not specified");
12464 errmsg ("tunnel dst address not specified");
12468 if (grp_set && !ip46_address_is_multicast (&dst))
12470 errmsg ("tunnel group address not multicast");
12473 if (grp_set && mcast_sw_if_index == ~0)
12475 errmsg ("tunnel nonexistent multicast device");
12478 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12480 errmsg ("tunnel dst address must be unicast");
12485 if (ipv4_set && ipv6_set)
12487 errmsg ("both IPv4 and IPv6 addresses specified");
12491 if ((vni == 0) || (vni >> 24))
12493 errmsg ("vni not specified or out of range");
12497 M (GENEVE_ADD_DEL_TUNNEL, mp);
12501 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12502 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12506 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12507 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12509 mp->encap_vrf_id = ntohl (encap_vrf_id);
12510 mp->decap_next_index = ntohl (decap_next_index);
12511 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12512 mp->vni = ntohl (vni);
12513 mp->is_add = is_add;
12514 mp->is_ipv6 = ipv6_set;
12521 static void vl_api_geneve_tunnel_details_t_handler
12522 (vl_api_geneve_tunnel_details_t * mp)
12524 vat_main_t *vam = &vat_main;
12525 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12526 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12528 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12529 ntohl (mp->sw_if_index),
12530 format_ip46_address, &src, IP46_TYPE_ANY,
12531 format_ip46_address, &dst, IP46_TYPE_ANY,
12532 ntohl (mp->encap_vrf_id),
12533 ntohl (mp->decap_next_index), ntohl (mp->vni),
12534 ntohl (mp->mcast_sw_if_index));
12537 static void vl_api_geneve_tunnel_details_t_handler_json
12538 (vl_api_geneve_tunnel_details_t * mp)
12540 vat_main_t *vam = &vat_main;
12541 vat_json_node_t *node = NULL;
12543 if (VAT_JSON_ARRAY != vam->json_tree.type)
12545 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12546 vat_json_init_array (&vam->json_tree);
12548 node = vat_json_array_add (&vam->json_tree);
12550 vat_json_init_object (node);
12551 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12554 struct in6_addr ip6;
12556 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12557 vat_json_object_add_ip6 (node, "src_address", ip6);
12558 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12559 vat_json_object_add_ip6 (node, "dst_address", ip6);
12563 struct in_addr ip4;
12565 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12566 vat_json_object_add_ip4 (node, "src_address", ip4);
12567 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12568 vat_json_object_add_ip4 (node, "dst_address", ip4);
12570 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12571 vat_json_object_add_uint (node, "decap_next_index",
12572 ntohl (mp->decap_next_index));
12573 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12574 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12575 vat_json_object_add_uint (node, "mcast_sw_if_index",
12576 ntohl (mp->mcast_sw_if_index));
12580 api_geneve_tunnel_dump (vat_main_t * vam)
12582 unformat_input_t *i = vam->input;
12583 vl_api_geneve_tunnel_dump_t *mp;
12584 vl_api_control_ping_t *mp_ping;
12586 u8 sw_if_index_set = 0;
12589 /* Parse args required to build the message */
12590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12592 if (unformat (i, "sw_if_index %d", &sw_if_index))
12593 sw_if_index_set = 1;
12598 if (sw_if_index_set == 0)
12603 if (!vam->json_output)
12605 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12606 "sw_if_index", "local_address", "remote_address",
12607 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12610 /* Get list of geneve-tunnel interfaces */
12611 M (GENEVE_TUNNEL_DUMP, mp);
12613 mp->sw_if_index = htonl (sw_if_index);
12617 /* Use a control ping for synchronization */
12618 M (CONTROL_PING, mp_ping);
12626 api_gre_add_del_tunnel (vat_main_t * vam)
12628 unformat_input_t *line_input = vam->input;
12629 vl_api_gre_add_del_tunnel_t *mp;
12630 ip4_address_t src4, dst4;
12631 ip6_address_t src6, dst6;
12638 u32 outer_fib_id = 0;
12641 memset (&src4, 0, sizeof src4);
12642 memset (&dst4, 0, sizeof dst4);
12643 memset (&src6, 0, sizeof src6);
12644 memset (&dst6, 0, sizeof dst6);
12646 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12648 if (unformat (line_input, "del"))
12650 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
12655 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
12660 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
12665 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
12670 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
12672 else if (unformat (line_input, "teb"))
12676 errmsg ("parse error '%U'", format_unformat_error, line_input);
12683 errmsg ("tunnel src address not specified");
12688 errmsg ("tunnel dst address not specified");
12691 if (ipv4_set && ipv6_set)
12693 errmsg ("both IPv4 and IPv6 addresses specified");
12698 M (GRE_ADD_DEL_TUNNEL, mp);
12702 clib_memcpy (&mp->src_address, &src4, 4);
12703 clib_memcpy (&mp->dst_address, &dst4, 4);
12707 clib_memcpy (&mp->src_address, &src6, 16);
12708 clib_memcpy (&mp->dst_address, &dst6, 16);
12710 mp->outer_fib_id = ntohl (outer_fib_id);
12711 mp->is_add = is_add;
12713 mp->is_ipv6 = ipv6_set;
12720 static void vl_api_gre_tunnel_details_t_handler
12721 (vl_api_gre_tunnel_details_t * mp)
12723 vat_main_t *vam = &vat_main;
12724 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
12725 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
12727 print (vam->ofp, "%11d%24U%24U%6d%14d",
12728 ntohl (mp->sw_if_index),
12729 format_ip46_address, &src, IP46_TYPE_ANY,
12730 format_ip46_address, &dst, IP46_TYPE_ANY,
12731 mp->teb, ntohl (mp->outer_fib_id));
12734 static void vl_api_gre_tunnel_details_t_handler_json
12735 (vl_api_gre_tunnel_details_t * mp)
12737 vat_main_t *vam = &vat_main;
12738 vat_json_node_t *node = NULL;
12739 struct in_addr ip4;
12740 struct in6_addr ip6;
12742 if (VAT_JSON_ARRAY != vam->json_tree.type)
12744 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12745 vat_json_init_array (&vam->json_tree);
12747 node = vat_json_array_add (&vam->json_tree);
12749 vat_json_init_object (node);
12750 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12753 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
12754 vat_json_object_add_ip4 (node, "src_address", ip4);
12755 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
12756 vat_json_object_add_ip4 (node, "dst_address", ip4);
12760 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
12761 vat_json_object_add_ip6 (node, "src_address", ip6);
12762 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
12763 vat_json_object_add_ip6 (node, "dst_address", ip6);
12765 vat_json_object_add_uint (node, "teb", mp->teb);
12766 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
12767 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
12771 api_gre_tunnel_dump (vat_main_t * vam)
12773 unformat_input_t *i = vam->input;
12774 vl_api_gre_tunnel_dump_t *mp;
12775 vl_api_control_ping_t *mp_ping;
12777 u8 sw_if_index_set = 0;
12780 /* Parse args required to build the message */
12781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12783 if (unformat (i, "sw_if_index %d", &sw_if_index))
12784 sw_if_index_set = 1;
12789 if (sw_if_index_set == 0)
12794 if (!vam->json_output)
12796 print (vam->ofp, "%11s%24s%24s%6s%14s",
12797 "sw_if_index", "src_address", "dst_address", "teb",
12801 /* Get list of gre-tunnel interfaces */
12802 M (GRE_TUNNEL_DUMP, mp);
12804 mp->sw_if_index = htonl (sw_if_index);
12808 /* Use a control ping for synchronization */
12809 MPING (CONTROL_PING, mp_ping);
12817 api_l2_fib_clear_table (vat_main_t * vam)
12819 // unformat_input_t * i = vam->input;
12820 vl_api_l2_fib_clear_table_t *mp;
12823 M (L2_FIB_CLEAR_TABLE, mp);
12831 api_l2_interface_efp_filter (vat_main_t * vam)
12833 unformat_input_t *i = vam->input;
12834 vl_api_l2_interface_efp_filter_t *mp;
12837 u8 sw_if_index_set = 0;
12840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12842 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12843 sw_if_index_set = 1;
12844 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12845 sw_if_index_set = 1;
12846 else if (unformat (i, "enable"))
12848 else if (unformat (i, "disable"))
12852 clib_warning ("parse error '%U'", format_unformat_error, i);
12857 if (sw_if_index_set == 0)
12859 errmsg ("missing sw_if_index");
12863 M (L2_INTERFACE_EFP_FILTER, mp);
12865 mp->sw_if_index = ntohl (sw_if_index);
12866 mp->enable_disable = enable;
12873 #define foreach_vtr_op \
12874 _("disable", L2_VTR_DISABLED) \
12875 _("push-1", L2_VTR_PUSH_1) \
12876 _("push-2", L2_VTR_PUSH_2) \
12877 _("pop-1", L2_VTR_POP_1) \
12878 _("pop-2", L2_VTR_POP_2) \
12879 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12880 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12881 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12882 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12885 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12887 unformat_input_t *i = vam->input;
12888 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12890 u8 sw_if_index_set = 0;
12893 u32 push_dot1q = 1;
12898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12900 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12901 sw_if_index_set = 1;
12902 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12903 sw_if_index_set = 1;
12904 else if (unformat (i, "vtr_op %d", &vtr_op))
12906 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12909 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12911 else if (unformat (i, "tag1 %d", &tag1))
12913 else if (unformat (i, "tag2 %d", &tag2))
12917 clib_warning ("parse error '%U'", format_unformat_error, i);
12922 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12924 errmsg ("missing vtr operation or sw_if_index");
12928 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12929 mp->sw_if_index = ntohl (sw_if_index);
12930 mp->vtr_op = ntohl (vtr_op);
12931 mp->push_dot1q = ntohl (push_dot1q);
12932 mp->tag1 = ntohl (tag1);
12933 mp->tag2 = ntohl (tag2);
12941 api_create_vhost_user_if (vat_main_t * vam)
12943 unformat_input_t *i = vam->input;
12944 vl_api_create_vhost_user_if_t *mp;
12947 u8 file_name_set = 0;
12948 u32 custom_dev_instance = ~0;
12950 u8 use_custom_mac = 0;
12954 /* Shut up coverity */
12955 memset (hwaddr, 0, sizeof (hwaddr));
12957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12959 if (unformat (i, "socket %s", &file_name))
12963 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12965 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12966 use_custom_mac = 1;
12967 else if (unformat (i, "server"))
12969 else if (unformat (i, "tag %s", &tag))
12975 if (file_name_set == 0)
12977 errmsg ("missing socket file name");
12981 if (vec_len (file_name) > 255)
12983 errmsg ("socket file name too long");
12986 vec_add1 (file_name, 0);
12988 M (CREATE_VHOST_USER_IF, mp);
12990 mp->is_server = is_server;
12991 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12992 vec_free (file_name);
12993 if (custom_dev_instance != ~0)
12996 mp->custom_dev_instance = ntohl (custom_dev_instance);
12998 mp->use_custom_mac = use_custom_mac;
12999 clib_memcpy (mp->mac_address, hwaddr, 6);
13001 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13010 api_modify_vhost_user_if (vat_main_t * vam)
13012 unformat_input_t *i = vam->input;
13013 vl_api_modify_vhost_user_if_t *mp;
13016 u8 file_name_set = 0;
13017 u32 custom_dev_instance = ~0;
13018 u8 sw_if_index_set = 0;
13019 u32 sw_if_index = (u32) ~ 0;
13022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13024 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13025 sw_if_index_set = 1;
13026 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13027 sw_if_index_set = 1;
13028 else if (unformat (i, "socket %s", &file_name))
13032 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13034 else if (unformat (i, "server"))
13040 if (sw_if_index_set == 0)
13042 errmsg ("missing sw_if_index or interface name");
13046 if (file_name_set == 0)
13048 errmsg ("missing socket file name");
13052 if (vec_len (file_name) > 255)
13054 errmsg ("socket file name too long");
13057 vec_add1 (file_name, 0);
13059 M (MODIFY_VHOST_USER_IF, mp);
13061 mp->sw_if_index = ntohl (sw_if_index);
13062 mp->is_server = is_server;
13063 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13064 vec_free (file_name);
13065 if (custom_dev_instance != ~0)
13068 mp->custom_dev_instance = ntohl (custom_dev_instance);
13077 api_delete_vhost_user_if (vat_main_t * vam)
13079 unformat_input_t *i = vam->input;
13080 vl_api_delete_vhost_user_if_t *mp;
13081 u32 sw_if_index = ~0;
13082 u8 sw_if_index_set = 0;
13085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13087 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13088 sw_if_index_set = 1;
13089 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13090 sw_if_index_set = 1;
13095 if (sw_if_index_set == 0)
13097 errmsg ("missing sw_if_index or interface name");
13102 M (DELETE_VHOST_USER_IF, mp);
13104 mp->sw_if_index = ntohl (sw_if_index);
13111 static void vl_api_sw_interface_vhost_user_details_t_handler
13112 (vl_api_sw_interface_vhost_user_details_t * mp)
13114 vat_main_t *vam = &vat_main;
13116 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13117 (char *) mp->interface_name,
13118 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13119 clib_net_to_host_u64 (mp->features), mp->is_server,
13120 ntohl (mp->num_regions), (char *) mp->sock_filename);
13121 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13124 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13125 (vl_api_sw_interface_vhost_user_details_t * mp)
13127 vat_main_t *vam = &vat_main;
13128 vat_json_node_t *node = NULL;
13130 if (VAT_JSON_ARRAY != vam->json_tree.type)
13132 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13133 vat_json_init_array (&vam->json_tree);
13135 node = vat_json_array_add (&vam->json_tree);
13137 vat_json_init_object (node);
13138 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13139 vat_json_object_add_string_copy (node, "interface_name",
13140 mp->interface_name);
13141 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13142 ntohl (mp->virtio_net_hdr_sz));
13143 vat_json_object_add_uint (node, "features",
13144 clib_net_to_host_u64 (mp->features));
13145 vat_json_object_add_uint (node, "is_server", mp->is_server);
13146 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13147 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13148 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13152 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13154 vl_api_sw_interface_vhost_user_dump_t *mp;
13155 vl_api_control_ping_t *mp_ping;
13158 "Interface name idx hdr_sz features server regions filename");
13160 /* Get list of vhost-user interfaces */
13161 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13164 /* Use a control ping for synchronization */
13165 MPING (CONTROL_PING, mp_ping);
13173 api_show_version (vat_main_t * vam)
13175 vl_api_show_version_t *mp;
13178 M (SHOW_VERSION, mp);
13187 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13189 unformat_input_t *line_input = vam->input;
13190 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13191 ip4_address_t local4, remote4;
13192 ip6_address_t local6, remote6;
13194 u8 ipv4_set = 0, ipv6_set = 0;
13198 u32 mcast_sw_if_index = ~0;
13199 u32 encap_vrf_id = 0;
13200 u32 decap_vrf_id = 0;
13206 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13207 memset (&local4, 0, sizeof local4);
13208 memset (&remote4, 0, sizeof remote4);
13209 memset (&local6, 0, sizeof local6);
13210 memset (&remote6, 0, sizeof remote6);
13212 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13214 if (unformat (line_input, "del"))
13216 else if (unformat (line_input, "local %U",
13217 unformat_ip4_address, &local4))
13222 else if (unformat (line_input, "remote %U",
13223 unformat_ip4_address, &remote4))
13228 else if (unformat (line_input, "local %U",
13229 unformat_ip6_address, &local6))
13234 else if (unformat (line_input, "remote %U",
13235 unformat_ip6_address, &remote6))
13240 else if (unformat (line_input, "group %U %U",
13241 unformat_ip4_address, &remote4,
13242 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13244 grp_set = remote_set = 1;
13247 else if (unformat (line_input, "group %U",
13248 unformat_ip4_address, &remote4))
13250 grp_set = remote_set = 1;
13253 else if (unformat (line_input, "group %U %U",
13254 unformat_ip6_address, &remote6,
13255 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13257 grp_set = remote_set = 1;
13260 else if (unformat (line_input, "group %U",
13261 unformat_ip6_address, &remote6))
13263 grp_set = remote_set = 1;
13267 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13269 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13271 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13273 else if (unformat (line_input, "vni %d", &vni))
13275 else if (unformat (line_input, "next-ip4"))
13277 else if (unformat (line_input, "next-ip6"))
13279 else if (unformat (line_input, "next-ethernet"))
13281 else if (unformat (line_input, "next-nsh"))
13285 errmsg ("parse error '%U'", format_unformat_error, line_input);
13290 if (local_set == 0)
13292 errmsg ("tunnel local address not specified");
13295 if (remote_set == 0)
13297 errmsg ("tunnel remote address not specified");
13300 if (grp_set && mcast_sw_if_index == ~0)
13302 errmsg ("tunnel nonexistent multicast device");
13305 if (ipv4_set && ipv6_set)
13307 errmsg ("both IPv4 and IPv6 addresses specified");
13313 errmsg ("vni not specified");
13317 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13322 clib_memcpy (&mp->local, &local6, sizeof (local6));
13323 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13327 clib_memcpy (&mp->local, &local4, sizeof (local4));
13328 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13331 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13332 mp->encap_vrf_id = ntohl (encap_vrf_id);
13333 mp->decap_vrf_id = ntohl (decap_vrf_id);
13334 mp->protocol = protocol;
13335 mp->vni = ntohl (vni);
13336 mp->is_add = is_add;
13337 mp->is_ipv6 = ipv6_set;
13344 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13345 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13347 vat_main_t *vam = &vat_main;
13348 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13349 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13351 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13352 ntohl (mp->sw_if_index),
13353 format_ip46_address, &local, IP46_TYPE_ANY,
13354 format_ip46_address, &remote, IP46_TYPE_ANY,
13355 ntohl (mp->vni), mp->protocol,
13356 ntohl (mp->mcast_sw_if_index),
13357 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13361 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13362 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13364 vat_main_t *vam = &vat_main;
13365 vat_json_node_t *node = NULL;
13366 struct in_addr ip4;
13367 struct in6_addr ip6;
13369 if (VAT_JSON_ARRAY != vam->json_tree.type)
13371 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13372 vat_json_init_array (&vam->json_tree);
13374 node = vat_json_array_add (&vam->json_tree);
13376 vat_json_init_object (node);
13377 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13380 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13381 vat_json_object_add_ip6 (node, "local", ip6);
13382 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13383 vat_json_object_add_ip6 (node, "remote", ip6);
13387 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13388 vat_json_object_add_ip4 (node, "local", ip4);
13389 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13390 vat_json_object_add_ip4 (node, "remote", ip4);
13392 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13393 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13394 vat_json_object_add_uint (node, "mcast_sw_if_index",
13395 ntohl (mp->mcast_sw_if_index));
13396 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13397 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13398 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13402 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13404 unformat_input_t *i = vam->input;
13405 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13406 vl_api_control_ping_t *mp_ping;
13408 u8 sw_if_index_set = 0;
13411 /* Parse args required to build the message */
13412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13414 if (unformat (i, "sw_if_index %d", &sw_if_index))
13415 sw_if_index_set = 1;
13420 if (sw_if_index_set == 0)
13425 if (!vam->json_output)
13427 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13428 "sw_if_index", "local", "remote", "vni",
13429 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13432 /* Get list of vxlan-tunnel interfaces */
13433 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13435 mp->sw_if_index = htonl (sw_if_index);
13439 /* Use a control ping for synchronization */
13440 MPING (CONTROL_PING, mp_ping);
13447 static void vl_api_l2_fib_table_details_t_handler
13448 (vl_api_l2_fib_table_details_t * mp)
13450 vat_main_t *vam = &vat_main;
13452 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13454 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13455 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13459 static void vl_api_l2_fib_table_details_t_handler_json
13460 (vl_api_l2_fib_table_details_t * mp)
13462 vat_main_t *vam = &vat_main;
13463 vat_json_node_t *node = NULL;
13465 if (VAT_JSON_ARRAY != vam->json_tree.type)
13467 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13468 vat_json_init_array (&vam->json_tree);
13470 node = vat_json_array_add (&vam->json_tree);
13472 vat_json_init_object (node);
13473 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13474 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13475 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13476 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13477 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13478 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13482 api_l2_fib_table_dump (vat_main_t * vam)
13484 unformat_input_t *i = vam->input;
13485 vl_api_l2_fib_table_dump_t *mp;
13486 vl_api_control_ping_t *mp_ping;
13491 /* Parse args required to build the message */
13492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13494 if (unformat (i, "bd_id %d", &bd_id))
13500 if (bd_id_set == 0)
13502 errmsg ("missing bridge domain");
13506 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13508 /* Get list of l2 fib entries */
13509 M (L2_FIB_TABLE_DUMP, mp);
13511 mp->bd_id = ntohl (bd_id);
13514 /* Use a control ping for synchronization */
13515 MPING (CONTROL_PING, mp_ping);
13524 api_interface_name_renumber (vat_main_t * vam)
13526 unformat_input_t *line_input = vam->input;
13527 vl_api_interface_name_renumber_t *mp;
13528 u32 sw_if_index = ~0;
13529 u32 new_show_dev_instance = ~0;
13532 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13534 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13537 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13539 else if (unformat (line_input, "new_show_dev_instance %d",
13540 &new_show_dev_instance))
13546 if (sw_if_index == ~0)
13548 errmsg ("missing interface name or sw_if_index");
13552 if (new_show_dev_instance == ~0)
13554 errmsg ("missing new_show_dev_instance");
13558 M (INTERFACE_NAME_RENUMBER, mp);
13560 mp->sw_if_index = ntohl (sw_if_index);
13561 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13569 api_want_ip4_arp_events (vat_main_t * vam)
13571 unformat_input_t *line_input = vam->input;
13572 vl_api_want_ip4_arp_events_t *mp;
13573 ip4_address_t address;
13574 int address_set = 0;
13575 u32 enable_disable = 1;
13578 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13580 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13582 else if (unformat (line_input, "del"))
13583 enable_disable = 0;
13588 if (address_set == 0)
13590 errmsg ("missing addresses");
13594 M (WANT_IP4_ARP_EVENTS, mp);
13595 mp->enable_disable = enable_disable;
13596 mp->pid = htonl (getpid ());
13597 mp->address = address.as_u32;
13605 api_want_ip6_nd_events (vat_main_t * vam)
13607 unformat_input_t *line_input = vam->input;
13608 vl_api_want_ip6_nd_events_t *mp;
13609 ip6_address_t address;
13610 int address_set = 0;
13611 u32 enable_disable = 1;
13614 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13616 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
13618 else if (unformat (line_input, "del"))
13619 enable_disable = 0;
13624 if (address_set == 0)
13626 errmsg ("missing addresses");
13630 M (WANT_IP6_ND_EVENTS, mp);
13631 mp->enable_disable = enable_disable;
13632 mp->pid = htonl (getpid ());
13633 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
13641 api_want_l2_macs_events (vat_main_t * vam)
13643 unformat_input_t *line_input = vam->input;
13644 vl_api_want_l2_macs_events_t *mp;
13645 u8 enable_disable = 1;
13646 u32 scan_delay = 0;
13647 u32 max_macs_in_event = 0;
13648 u32 learn_limit = 0;
13651 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13653 if (unformat (line_input, "learn-limit %d", &learn_limit))
13655 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13657 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13659 else if (unformat (line_input, "disable"))
13660 enable_disable = 0;
13665 M (WANT_L2_MACS_EVENTS, mp);
13666 mp->enable_disable = enable_disable;
13667 mp->pid = htonl (getpid ());
13668 mp->learn_limit = htonl (learn_limit);
13669 mp->scan_delay = (u8) scan_delay;
13670 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13677 api_input_acl_set_interface (vat_main_t * vam)
13679 unformat_input_t *i = vam->input;
13680 vl_api_input_acl_set_interface_t *mp;
13682 int sw_if_index_set;
13683 u32 ip4_table_index = ~0;
13684 u32 ip6_table_index = ~0;
13685 u32 l2_table_index = ~0;
13689 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13691 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13692 sw_if_index_set = 1;
13693 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13694 sw_if_index_set = 1;
13695 else if (unformat (i, "del"))
13697 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13699 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13701 else if (unformat (i, "l2-table %d", &l2_table_index))
13705 clib_warning ("parse error '%U'", format_unformat_error, i);
13710 if (sw_if_index_set == 0)
13712 errmsg ("missing interface name or sw_if_index");
13716 M (INPUT_ACL_SET_INTERFACE, mp);
13718 mp->sw_if_index = ntohl (sw_if_index);
13719 mp->ip4_table_index = ntohl (ip4_table_index);
13720 mp->ip6_table_index = ntohl (ip6_table_index);
13721 mp->l2_table_index = ntohl (l2_table_index);
13722 mp->is_add = is_add;
13730 api_ip_address_dump (vat_main_t * vam)
13732 unformat_input_t *i = vam->input;
13733 vl_api_ip_address_dump_t *mp;
13734 vl_api_control_ping_t *mp_ping;
13735 u32 sw_if_index = ~0;
13736 u8 sw_if_index_set = 0;
13741 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13743 if (unformat (i, "sw_if_index %d", &sw_if_index))
13744 sw_if_index_set = 1;
13746 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13747 sw_if_index_set = 1;
13748 else if (unformat (i, "ipv4"))
13750 else if (unformat (i, "ipv6"))
13756 if (ipv4_set && ipv6_set)
13758 errmsg ("ipv4 and ipv6 flags cannot be both set");
13762 if ((!ipv4_set) && (!ipv6_set))
13764 errmsg ("no ipv4 nor ipv6 flag set");
13768 if (sw_if_index_set == 0)
13770 errmsg ("missing interface name or sw_if_index");
13774 vam->current_sw_if_index = sw_if_index;
13775 vam->is_ipv6 = ipv6_set;
13777 M (IP_ADDRESS_DUMP, mp);
13778 mp->sw_if_index = ntohl (sw_if_index);
13779 mp->is_ipv6 = ipv6_set;
13782 /* Use a control ping for synchronization */
13783 MPING (CONTROL_PING, mp_ping);
13791 api_ip_dump (vat_main_t * vam)
13793 vl_api_ip_dump_t *mp;
13794 vl_api_control_ping_t *mp_ping;
13795 unformat_input_t *in = vam->input;
13802 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13804 if (unformat (in, "ipv4"))
13806 else if (unformat (in, "ipv6"))
13812 if (ipv4_set && ipv6_set)
13814 errmsg ("ipv4 and ipv6 flags cannot be both set");
13818 if ((!ipv4_set) && (!ipv6_set))
13820 errmsg ("no ipv4 nor ipv6 flag set");
13824 is_ipv6 = ipv6_set;
13825 vam->is_ipv6 = is_ipv6;
13827 /* free old data */
13828 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13830 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13832 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13835 mp->is_ipv6 = ipv6_set;
13838 /* Use a control ping for synchronization */
13839 MPING (CONTROL_PING, mp_ping);
13847 api_ipsec_spd_add_del (vat_main_t * vam)
13849 unformat_input_t *i = vam->input;
13850 vl_api_ipsec_spd_add_del_t *mp;
13855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13857 if (unformat (i, "spd_id %d", &spd_id))
13859 else if (unformat (i, "del"))
13863 clib_warning ("parse error '%U'", format_unformat_error, i);
13869 errmsg ("spd_id must be set");
13873 M (IPSEC_SPD_ADD_DEL, mp);
13875 mp->spd_id = ntohl (spd_id);
13876 mp->is_add = is_add;
13884 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13886 unformat_input_t *i = vam->input;
13887 vl_api_ipsec_interface_add_del_spd_t *mp;
13889 u8 sw_if_index_set = 0;
13890 u32 spd_id = (u32) ~ 0;
13894 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13896 if (unformat (i, "del"))
13898 else if (unformat (i, "spd_id %d", &spd_id))
13901 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13902 sw_if_index_set = 1;
13903 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13904 sw_if_index_set = 1;
13907 clib_warning ("parse error '%U'", format_unformat_error, i);
13913 if (spd_id == (u32) ~ 0)
13915 errmsg ("spd_id must be set");
13919 if (sw_if_index_set == 0)
13921 errmsg ("missing interface name or sw_if_index");
13925 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13927 mp->spd_id = ntohl (spd_id);
13928 mp->sw_if_index = ntohl (sw_if_index);
13929 mp->is_add = is_add;
13937 api_ipsec_spd_add_del_entry (vat_main_t * vam)
13939 unformat_input_t *i = vam->input;
13940 vl_api_ipsec_spd_add_del_entry_t *mp;
13941 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
13942 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13944 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13945 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13946 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
13947 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
13950 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
13951 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
13952 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
13953 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
13954 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
13955 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
13957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13959 if (unformat (i, "del"))
13961 if (unformat (i, "outbound"))
13963 if (unformat (i, "inbound"))
13965 else if (unformat (i, "spd_id %d", &spd_id))
13967 else if (unformat (i, "sa_id %d", &sa_id))
13969 else if (unformat (i, "priority %d", &priority))
13971 else if (unformat (i, "protocol %d", &protocol))
13973 else if (unformat (i, "lport_start %d", &lport_start))
13975 else if (unformat (i, "lport_stop %d", &lport_stop))
13977 else if (unformat (i, "rport_start %d", &rport_start))
13979 else if (unformat (i, "rport_stop %d", &rport_stop))
13983 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
13989 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
13996 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14002 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14009 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14015 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14022 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14028 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14034 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14036 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14038 clib_warning ("unsupported action: 'resolve'");
14044 clib_warning ("parse error '%U'", format_unformat_error, i);
14050 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14052 mp->spd_id = ntohl (spd_id);
14053 mp->priority = ntohl (priority);
14054 mp->is_outbound = is_outbound;
14056 mp->is_ipv6 = is_ipv6;
14057 if (is_ipv6 || is_ip_any)
14059 clib_memcpy (mp->remote_address_start, &raddr6_start,
14060 sizeof (ip6_address_t));
14061 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14062 sizeof (ip6_address_t));
14063 clib_memcpy (mp->local_address_start, &laddr6_start,
14064 sizeof (ip6_address_t));
14065 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14066 sizeof (ip6_address_t));
14070 clib_memcpy (mp->remote_address_start, &raddr4_start,
14071 sizeof (ip4_address_t));
14072 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14073 sizeof (ip4_address_t));
14074 clib_memcpy (mp->local_address_start, &laddr4_start,
14075 sizeof (ip4_address_t));
14076 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14077 sizeof (ip4_address_t));
14079 mp->protocol = (u8) protocol;
14080 mp->local_port_start = ntohs ((u16) lport_start);
14081 mp->local_port_stop = ntohs ((u16) lport_stop);
14082 mp->remote_port_start = ntohs ((u16) rport_start);
14083 mp->remote_port_stop = ntohs ((u16) rport_stop);
14084 mp->policy = (u8) policy;
14085 mp->sa_id = ntohl (sa_id);
14086 mp->is_add = is_add;
14087 mp->is_ip_any = is_ip_any;
14094 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14096 unformat_input_t *i = vam->input;
14097 vl_api_ipsec_sad_add_del_entry_t *mp;
14098 u32 sad_id = 0, spi = 0;
14099 u8 *ck = 0, *ik = 0;
14102 u8 protocol = IPSEC_PROTOCOL_AH;
14103 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14104 u32 crypto_alg = 0, integ_alg = 0;
14105 ip4_address_t tun_src4;
14106 ip4_address_t tun_dst4;
14107 ip6_address_t tun_src6;
14108 ip6_address_t tun_dst6;
14111 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14113 if (unformat (i, "del"))
14115 else if (unformat (i, "sad_id %d", &sad_id))
14117 else if (unformat (i, "spi %d", &spi))
14119 else if (unformat (i, "esp"))
14120 protocol = IPSEC_PROTOCOL_ESP;
14121 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14124 is_tunnel_ipv6 = 0;
14126 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14129 is_tunnel_ipv6 = 0;
14131 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14134 is_tunnel_ipv6 = 1;
14136 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14139 is_tunnel_ipv6 = 1;
14143 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14145 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14146 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14148 clib_warning ("unsupported crypto-alg: '%U'",
14149 format_ipsec_crypto_alg, crypto_alg);
14153 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14157 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14159 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14160 integ_alg >= IPSEC_INTEG_N_ALG)
14162 clib_warning ("unsupported integ-alg: '%U'",
14163 format_ipsec_integ_alg, integ_alg);
14167 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14171 clib_warning ("parse error '%U'", format_unformat_error, i);
14177 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14179 mp->sad_id = ntohl (sad_id);
14180 mp->is_add = is_add;
14181 mp->protocol = protocol;
14182 mp->spi = ntohl (spi);
14183 mp->is_tunnel = is_tunnel;
14184 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14185 mp->crypto_algorithm = crypto_alg;
14186 mp->integrity_algorithm = integ_alg;
14187 mp->crypto_key_length = vec_len (ck);
14188 mp->integrity_key_length = vec_len (ik);
14190 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14191 mp->crypto_key_length = sizeof (mp->crypto_key);
14193 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14194 mp->integrity_key_length = sizeof (mp->integrity_key);
14197 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14199 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14203 if (is_tunnel_ipv6)
14205 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14206 sizeof (ip6_address_t));
14207 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14208 sizeof (ip6_address_t));
14212 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14213 sizeof (ip4_address_t));
14214 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14215 sizeof (ip4_address_t));
14225 api_ipsec_sa_set_key (vat_main_t * vam)
14227 unformat_input_t *i = vam->input;
14228 vl_api_ipsec_sa_set_key_t *mp;
14230 u8 *ck = 0, *ik = 0;
14233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14235 if (unformat (i, "sa_id %d", &sa_id))
14237 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14239 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14243 clib_warning ("parse error '%U'", format_unformat_error, i);
14248 M (IPSEC_SA_SET_KEY, mp);
14250 mp->sa_id = ntohl (sa_id);
14251 mp->crypto_key_length = vec_len (ck);
14252 mp->integrity_key_length = vec_len (ik);
14254 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14255 mp->crypto_key_length = sizeof (mp->crypto_key);
14257 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14258 mp->integrity_key_length = sizeof (mp->integrity_key);
14261 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14263 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14271 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14273 unformat_input_t *i = vam->input;
14274 vl_api_ipsec_tunnel_if_add_del_t *mp;
14275 u32 local_spi = 0, remote_spi = 0;
14276 u32 crypto_alg = 0, integ_alg = 0;
14277 u8 *lck = NULL, *rck = NULL;
14278 u8 *lik = NULL, *rik = NULL;
14279 ip4_address_t local_ip = { {0} };
14280 ip4_address_t remote_ip = { {0} };
14283 u8 anti_replay = 0;
14286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14288 if (unformat (i, "del"))
14290 else if (unformat (i, "esn"))
14292 else if (unformat (i, "anti_replay"))
14294 else if (unformat (i, "local_spi %d", &local_spi))
14296 else if (unformat (i, "remote_spi %d", &remote_spi))
14298 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14300 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14302 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14305 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14307 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14309 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14313 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14315 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14316 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14318 errmsg ("unsupported crypto-alg: '%U'\n",
14319 format_ipsec_crypto_alg, crypto_alg);
14325 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14327 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14328 integ_alg >= IPSEC_INTEG_N_ALG)
14330 errmsg ("unsupported integ-alg: '%U'\n",
14331 format_ipsec_integ_alg, integ_alg);
14337 errmsg ("parse error '%U'\n", format_unformat_error, i);
14342 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14344 mp->is_add = is_add;
14346 mp->anti_replay = anti_replay;
14348 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14349 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14351 mp->local_spi = htonl (local_spi);
14352 mp->remote_spi = htonl (remote_spi);
14353 mp->crypto_alg = (u8) crypto_alg;
14355 mp->local_crypto_key_len = 0;
14358 mp->local_crypto_key_len = vec_len (lck);
14359 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14360 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14361 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14364 mp->remote_crypto_key_len = 0;
14367 mp->remote_crypto_key_len = vec_len (rck);
14368 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14369 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14370 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14373 mp->integ_alg = (u8) integ_alg;
14375 mp->local_integ_key_len = 0;
14378 mp->local_integ_key_len = vec_len (lik);
14379 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14380 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14381 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14384 mp->remote_integ_key_len = 0;
14387 mp->remote_integ_key_len = vec_len (rik);
14388 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14389 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14390 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14399 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14401 vat_main_t *vam = &vat_main;
14403 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14404 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14405 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14406 "tunnel_src_addr %U tunnel_dst_addr %U "
14407 "salt %u seq_outbound %lu last_seq_inbound %lu "
14408 "replay_window %lu total_data_size %lu\n",
14409 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14411 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14412 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14413 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14414 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14415 mp->tunnel_src_addr,
14416 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14417 mp->tunnel_dst_addr,
14419 clib_net_to_host_u64 (mp->seq_outbound),
14420 clib_net_to_host_u64 (mp->last_seq_inbound),
14421 clib_net_to_host_u64 (mp->replay_window),
14422 clib_net_to_host_u64 (mp->total_data_size));
14425 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14426 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14428 static void vl_api_ipsec_sa_details_t_handler_json
14429 (vl_api_ipsec_sa_details_t * mp)
14431 vat_main_t *vam = &vat_main;
14432 vat_json_node_t *node = NULL;
14433 struct in_addr src_ip4, dst_ip4;
14434 struct in6_addr src_ip6, dst_ip6;
14436 if (VAT_JSON_ARRAY != vam->json_tree.type)
14438 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14439 vat_json_init_array (&vam->json_tree);
14441 node = vat_json_array_add (&vam->json_tree);
14443 vat_json_init_object (node);
14444 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14445 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14446 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14447 vat_json_object_add_uint (node, "proto", mp->protocol);
14448 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14449 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14450 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14451 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14452 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14453 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14454 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14455 mp->crypto_key_len);
14456 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14457 mp->integ_key_len);
14458 if (mp->is_tunnel_ip6)
14460 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14461 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14462 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14463 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14467 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14468 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14469 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14470 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14472 vat_json_object_add_uint (node, "replay_window",
14473 clib_net_to_host_u64 (mp->replay_window));
14474 vat_json_object_add_uint (node, "total_data_size",
14475 clib_net_to_host_u64 (mp->total_data_size));
14480 api_ipsec_sa_dump (vat_main_t * vam)
14482 unformat_input_t *i = vam->input;
14483 vl_api_ipsec_sa_dump_t *mp;
14484 vl_api_control_ping_t *mp_ping;
14488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14490 if (unformat (i, "sa_id %d", &sa_id))
14494 clib_warning ("parse error '%U'", format_unformat_error, i);
14499 M (IPSEC_SA_DUMP, mp);
14501 mp->sa_id = ntohl (sa_id);
14505 /* Use a control ping for synchronization */
14506 M (CONTROL_PING, mp_ping);
14514 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14516 unformat_input_t *i = vam->input;
14517 vl_api_ipsec_tunnel_if_set_key_t *mp;
14518 u32 sw_if_index = ~0;
14519 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14526 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14529 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14530 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14532 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14533 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14534 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14535 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14537 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14538 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14539 else if (unformat (i, "%U", unformat_hex_string, &key))
14543 clib_warning ("parse error '%U'", format_unformat_error, i);
14548 if (sw_if_index == ~0)
14550 errmsg ("interface must be specified");
14554 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14556 errmsg ("key type must be specified");
14562 errmsg ("algorithm must be specified");
14566 if (vec_len (key) == 0)
14568 errmsg ("key must be specified");
14572 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14574 mp->sw_if_index = htonl (sw_if_index);
14576 mp->key_type = key_type;
14577 mp->key_len = vec_len (key);
14578 clib_memcpy (mp->key, key, vec_len (key));
14587 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14589 unformat_input_t *i = vam->input;
14590 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14591 u32 sw_if_index = ~0;
14593 u8 is_outbound = (u8) ~ 0;
14596 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14598 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14600 else if (unformat (i, "sa_id %d", &sa_id))
14602 else if (unformat (i, "outbound"))
14604 else if (unformat (i, "inbound"))
14608 clib_warning ("parse error '%U'", format_unformat_error, i);
14613 if (sw_if_index == ~0)
14615 errmsg ("interface must be specified");
14621 errmsg ("SA ID must be specified");
14625 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14627 mp->sw_if_index = htonl (sw_if_index);
14628 mp->sa_id = htonl (sa_id);
14629 mp->is_outbound = is_outbound;
14638 api_ikev2_profile_add_del (vat_main_t * vam)
14640 unformat_input_t *i = vam->input;
14641 vl_api_ikev2_profile_add_del_t *mp;
14646 const char *valid_chars = "a-zA-Z0-9_";
14648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14650 if (unformat (i, "del"))
14652 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14653 vec_add1 (name, 0);
14656 errmsg ("parse error '%U'", format_unformat_error, i);
14661 if (!vec_len (name))
14663 errmsg ("profile name must be specified");
14667 if (vec_len (name) > 64)
14669 errmsg ("profile name too long");
14673 M (IKEV2_PROFILE_ADD_DEL, mp);
14675 clib_memcpy (mp->name, name, vec_len (name));
14676 mp->is_add = is_add;
14685 api_ikev2_profile_set_auth (vat_main_t * vam)
14687 unformat_input_t *i = vam->input;
14688 vl_api_ikev2_profile_set_auth_t *mp;
14691 u32 auth_method = 0;
14695 const char *valid_chars = "a-zA-Z0-9_";
14697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14699 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14700 vec_add1 (name, 0);
14701 else if (unformat (i, "auth_method %U",
14702 unformat_ikev2_auth_method, &auth_method))
14704 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
14706 else if (unformat (i, "auth_data %v", &data))
14710 errmsg ("parse error '%U'", format_unformat_error, i);
14715 if (!vec_len (name))
14717 errmsg ("profile name must be specified");
14721 if (vec_len (name) > 64)
14723 errmsg ("profile name too long");
14727 if (!vec_len (data))
14729 errmsg ("auth_data must be specified");
14735 errmsg ("auth_method must be specified");
14739 M (IKEV2_PROFILE_SET_AUTH, mp);
14741 mp->is_hex = is_hex;
14742 mp->auth_method = (u8) auth_method;
14743 mp->data_len = vec_len (data);
14744 clib_memcpy (mp->name, name, vec_len (name));
14745 clib_memcpy (mp->data, data, vec_len (data));
14755 api_ikev2_profile_set_id (vat_main_t * vam)
14757 unformat_input_t *i = vam->input;
14758 vl_api_ikev2_profile_set_id_t *mp;
14766 const char *valid_chars = "a-zA-Z0-9_";
14768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14770 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14771 vec_add1 (name, 0);
14772 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
14774 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
14776 data = vec_new (u8, 4);
14777 clib_memcpy (data, ip4.as_u8, 4);
14779 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
14781 else if (unformat (i, "id_data %v", &data))
14783 else if (unformat (i, "local"))
14785 else if (unformat (i, "remote"))
14789 errmsg ("parse error '%U'", format_unformat_error, i);
14794 if (!vec_len (name))
14796 errmsg ("profile name must be specified");
14800 if (vec_len (name) > 64)
14802 errmsg ("profile name too long");
14806 if (!vec_len (data))
14808 errmsg ("id_data must be specified");
14814 errmsg ("id_type must be specified");
14818 M (IKEV2_PROFILE_SET_ID, mp);
14820 mp->is_local = is_local;
14821 mp->id_type = (u8) id_type;
14822 mp->data_len = vec_len (data);
14823 clib_memcpy (mp->name, name, vec_len (name));
14824 clib_memcpy (mp->data, data, vec_len (data));
14834 api_ikev2_profile_set_ts (vat_main_t * vam)
14836 unformat_input_t *i = vam->input;
14837 vl_api_ikev2_profile_set_ts_t *mp;
14840 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
14841 ip4_address_t start_addr, end_addr;
14843 const char *valid_chars = "a-zA-Z0-9_";
14846 start_addr.as_u32 = 0;
14847 end_addr.as_u32 = (u32) ~ 0;
14849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14851 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14852 vec_add1 (name, 0);
14853 else if (unformat (i, "protocol %d", &proto))
14855 else if (unformat (i, "start_port %d", &start_port))
14857 else if (unformat (i, "end_port %d", &end_port))
14860 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
14862 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
14864 else if (unformat (i, "local"))
14866 else if (unformat (i, "remote"))
14870 errmsg ("parse error '%U'", format_unformat_error, i);
14875 if (!vec_len (name))
14877 errmsg ("profile name must be specified");
14881 if (vec_len (name) > 64)
14883 errmsg ("profile name too long");
14887 M (IKEV2_PROFILE_SET_TS, mp);
14889 mp->is_local = is_local;
14890 mp->proto = (u8) proto;
14891 mp->start_port = (u16) start_port;
14892 mp->end_port = (u16) end_port;
14893 mp->start_addr = start_addr.as_u32;
14894 mp->end_addr = end_addr.as_u32;
14895 clib_memcpy (mp->name, name, vec_len (name));
14904 api_ikev2_set_local_key (vat_main_t * vam)
14906 unformat_input_t *i = vam->input;
14907 vl_api_ikev2_set_local_key_t *mp;
14911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14913 if (unformat (i, "file %v", &file))
14914 vec_add1 (file, 0);
14917 errmsg ("parse error '%U'", format_unformat_error, i);
14922 if (!vec_len (file))
14924 errmsg ("RSA key file must be specified");
14928 if (vec_len (file) > 256)
14930 errmsg ("file name too long");
14934 M (IKEV2_SET_LOCAL_KEY, mp);
14936 clib_memcpy (mp->key_file, file, vec_len (file));
14945 api_ikev2_set_responder (vat_main_t * vam)
14947 unformat_input_t *i = vam->input;
14948 vl_api_ikev2_set_responder_t *mp;
14951 u32 sw_if_index = ~0;
14952 ip4_address_t address;
14954 const char *valid_chars = "a-zA-Z0-9_";
14956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14959 (i, "%U interface %d address %U", unformat_token, valid_chars,
14960 &name, &sw_if_index, unformat_ip4_address, &address))
14961 vec_add1 (name, 0);
14964 errmsg ("parse error '%U'", format_unformat_error, i);
14969 if (!vec_len (name))
14971 errmsg ("profile name must be specified");
14975 if (vec_len (name) > 64)
14977 errmsg ("profile name too long");
14981 M (IKEV2_SET_RESPONDER, mp);
14983 clib_memcpy (mp->name, name, vec_len (name));
14986 mp->sw_if_index = sw_if_index;
14987 clib_memcpy (mp->address, &address, sizeof (address));
14995 api_ikev2_set_ike_transforms (vat_main_t * vam)
14997 unformat_input_t *i = vam->input;
14998 vl_api_ikev2_set_ike_transforms_t *mp;
15001 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15003 const char *valid_chars = "a-zA-Z0-9_";
15005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15007 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15008 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15009 vec_add1 (name, 0);
15012 errmsg ("parse error '%U'", format_unformat_error, i);
15017 if (!vec_len (name))
15019 errmsg ("profile name must be specified");
15023 if (vec_len (name) > 64)
15025 errmsg ("profile name too long");
15029 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15031 clib_memcpy (mp->name, name, vec_len (name));
15033 mp->crypto_alg = crypto_alg;
15034 mp->crypto_key_size = crypto_key_size;
15035 mp->integ_alg = integ_alg;
15036 mp->dh_group = dh_group;
15045 api_ikev2_set_esp_transforms (vat_main_t * vam)
15047 unformat_input_t *i = vam->input;
15048 vl_api_ikev2_set_esp_transforms_t *mp;
15051 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15053 const char *valid_chars = "a-zA-Z0-9_";
15055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15057 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15058 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15059 vec_add1 (name, 0);
15062 errmsg ("parse error '%U'", format_unformat_error, i);
15067 if (!vec_len (name))
15069 errmsg ("profile name must be specified");
15073 if (vec_len (name) > 64)
15075 errmsg ("profile name too long");
15079 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15081 clib_memcpy (mp->name, name, vec_len (name));
15083 mp->crypto_alg = crypto_alg;
15084 mp->crypto_key_size = crypto_key_size;
15085 mp->integ_alg = integ_alg;
15086 mp->dh_group = dh_group;
15094 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15096 unformat_input_t *i = vam->input;
15097 vl_api_ikev2_set_sa_lifetime_t *mp;
15100 u64 lifetime, lifetime_maxdata;
15101 u32 lifetime_jitter, handover;
15103 const char *valid_chars = "a-zA-Z0-9_";
15105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15107 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15108 &lifetime, &lifetime_jitter, &handover,
15109 &lifetime_maxdata))
15110 vec_add1 (name, 0);
15113 errmsg ("parse error '%U'", format_unformat_error, i);
15118 if (!vec_len (name))
15120 errmsg ("profile name must be specified");
15124 if (vec_len (name) > 64)
15126 errmsg ("profile name too long");
15130 M (IKEV2_SET_SA_LIFETIME, mp);
15132 clib_memcpy (mp->name, name, vec_len (name));
15134 mp->lifetime = lifetime;
15135 mp->lifetime_jitter = lifetime_jitter;
15136 mp->handover = handover;
15137 mp->lifetime_maxdata = lifetime_maxdata;
15145 api_ikev2_initiate_sa_init (vat_main_t * vam)
15147 unformat_input_t *i = vam->input;
15148 vl_api_ikev2_initiate_sa_init_t *mp;
15152 const char *valid_chars = "a-zA-Z0-9_";
15154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15156 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15157 vec_add1 (name, 0);
15160 errmsg ("parse error '%U'", format_unformat_error, i);
15165 if (!vec_len (name))
15167 errmsg ("profile name must be specified");
15171 if (vec_len (name) > 64)
15173 errmsg ("profile name too long");
15177 M (IKEV2_INITIATE_SA_INIT, mp);
15179 clib_memcpy (mp->name, name, vec_len (name));
15188 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15190 unformat_input_t *i = vam->input;
15191 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15196 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15198 if (unformat (i, "%lx", &ispi))
15202 errmsg ("parse error '%U'", format_unformat_error, i);
15207 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15217 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15219 unformat_input_t *i = vam->input;
15220 vl_api_ikev2_initiate_del_child_sa_t *mp;
15225 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15227 if (unformat (i, "%x", &ispi))
15231 errmsg ("parse error '%U'", format_unformat_error, i);
15236 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15246 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15248 unformat_input_t *i = vam->input;
15249 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15256 if (unformat (i, "%x", &ispi))
15260 errmsg ("parse error '%U'", format_unformat_error, i);
15265 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15278 api_map_add_domain (vat_main_t * vam)
15280 unformat_input_t *i = vam->input;
15281 vl_api_map_add_domain_t *mp;
15283 ip4_address_t ip4_prefix;
15284 ip6_address_t ip6_prefix;
15285 ip6_address_t ip6_src;
15286 u32 num_m_args = 0;
15287 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15288 0, psid_length = 0;
15289 u8 is_translation = 0;
15291 u32 ip6_src_len = 128;
15294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15296 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15297 &ip4_prefix, &ip4_prefix_len))
15299 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15300 &ip6_prefix, &ip6_prefix_len))
15304 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15307 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15309 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15311 else if (unformat (i, "psid-offset %d", &psid_offset))
15313 else if (unformat (i, "psid-len %d", &psid_length))
15315 else if (unformat (i, "mtu %d", &mtu))
15317 else if (unformat (i, "map-t"))
15318 is_translation = 1;
15321 clib_warning ("parse error '%U'", format_unformat_error, i);
15326 if (num_m_args < 3)
15328 errmsg ("mandatory argument(s) missing");
15332 /* Construct the API message */
15333 M (MAP_ADD_DOMAIN, mp);
15335 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15336 mp->ip4_prefix_len = ip4_prefix_len;
15338 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15339 mp->ip6_prefix_len = ip6_prefix_len;
15341 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15342 mp->ip6_src_prefix_len = ip6_src_len;
15344 mp->ea_bits_len = ea_bits_len;
15345 mp->psid_offset = psid_offset;
15346 mp->psid_length = psid_length;
15347 mp->is_translation = is_translation;
15348 mp->mtu = htons (mtu);
15353 /* Wait for a reply, return good/bad news */
15359 api_map_del_domain (vat_main_t * vam)
15361 unformat_input_t *i = vam->input;
15362 vl_api_map_del_domain_t *mp;
15364 u32 num_m_args = 0;
15368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15370 if (unformat (i, "index %d", &index))
15374 clib_warning ("parse error '%U'", format_unformat_error, i);
15379 if (num_m_args != 1)
15381 errmsg ("mandatory argument(s) missing");
15385 /* Construct the API message */
15386 M (MAP_DEL_DOMAIN, mp);
15388 mp->index = ntohl (index);
15393 /* Wait for a reply, return good/bad news */
15399 api_map_add_del_rule (vat_main_t * vam)
15401 unformat_input_t *i = vam->input;
15402 vl_api_map_add_del_rule_t *mp;
15404 ip6_address_t ip6_dst;
15405 u32 num_m_args = 0, index, psid = 0;
15408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15410 if (unformat (i, "index %d", &index))
15412 else if (unformat (i, "psid %d", &psid))
15414 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15416 else if (unformat (i, "del"))
15422 clib_warning ("parse error '%U'", format_unformat_error, i);
15427 /* Construct the API message */
15428 M (MAP_ADD_DEL_RULE, mp);
15430 mp->index = ntohl (index);
15431 mp->is_add = is_add;
15432 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15433 mp->psid = ntohs (psid);
15438 /* Wait for a reply, return good/bad news */
15444 api_map_domain_dump (vat_main_t * vam)
15446 vl_api_map_domain_dump_t *mp;
15447 vl_api_control_ping_t *mp_ping;
15450 /* Construct the API message */
15451 M (MAP_DOMAIN_DUMP, mp);
15456 /* Use a control ping for synchronization */
15457 MPING (CONTROL_PING, mp_ping);
15465 api_map_rule_dump (vat_main_t * vam)
15467 unformat_input_t *i = vam->input;
15468 vl_api_map_rule_dump_t *mp;
15469 vl_api_control_ping_t *mp_ping;
15470 u32 domain_index = ~0;
15473 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15475 if (unformat (i, "index %u", &domain_index))
15481 if (domain_index == ~0)
15483 clib_warning ("parse error: domain index expected");
15487 /* Construct the API message */
15488 M (MAP_RULE_DUMP, mp);
15490 mp->domain_index = htonl (domain_index);
15495 /* Use a control ping for synchronization */
15496 MPING (CONTROL_PING, mp_ping);
15503 static void vl_api_map_add_domain_reply_t_handler
15504 (vl_api_map_add_domain_reply_t * mp)
15506 vat_main_t *vam = &vat_main;
15507 i32 retval = ntohl (mp->retval);
15509 if (vam->async_mode)
15511 vam->async_errors += (retval < 0);
15515 vam->retval = retval;
15516 vam->result_ready = 1;
15520 static void vl_api_map_add_domain_reply_t_handler_json
15521 (vl_api_map_add_domain_reply_t * mp)
15523 vat_main_t *vam = &vat_main;
15524 vat_json_node_t node;
15526 vat_json_init_object (&node);
15527 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15528 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15530 vat_json_print (vam->ofp, &node);
15531 vat_json_free (&node);
15533 vam->retval = ntohl (mp->retval);
15534 vam->result_ready = 1;
15538 api_get_first_msg_id (vat_main_t * vam)
15540 vl_api_get_first_msg_id_t *mp;
15541 unformat_input_t *i = vam->input;
15546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15548 if (unformat (i, "client %s", &name))
15556 errmsg ("missing client name");
15559 vec_add1 (name, 0);
15561 if (vec_len (name) > 63)
15563 errmsg ("client name too long");
15567 M (GET_FIRST_MSG_ID, mp);
15568 clib_memcpy (mp->name, name, vec_len (name));
15575 api_cop_interface_enable_disable (vat_main_t * vam)
15577 unformat_input_t *line_input = vam->input;
15578 vl_api_cop_interface_enable_disable_t *mp;
15579 u32 sw_if_index = ~0;
15580 u8 enable_disable = 1;
15583 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15585 if (unformat (line_input, "disable"))
15586 enable_disable = 0;
15587 if (unformat (line_input, "enable"))
15588 enable_disable = 1;
15589 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15590 vam, &sw_if_index))
15592 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15598 if (sw_if_index == ~0)
15600 errmsg ("missing interface name or sw_if_index");
15604 /* Construct the API message */
15605 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15606 mp->sw_if_index = ntohl (sw_if_index);
15607 mp->enable_disable = enable_disable;
15611 /* Wait for the reply */
15617 api_cop_whitelist_enable_disable (vat_main_t * vam)
15619 unformat_input_t *line_input = vam->input;
15620 vl_api_cop_whitelist_enable_disable_t *mp;
15621 u32 sw_if_index = ~0;
15622 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15626 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15628 if (unformat (line_input, "ip4"))
15630 else if (unformat (line_input, "ip6"))
15632 else if (unformat (line_input, "default"))
15634 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15635 vam, &sw_if_index))
15637 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15639 else if (unformat (line_input, "fib-id %d", &fib_id))
15645 if (sw_if_index == ~0)
15647 errmsg ("missing interface name or sw_if_index");
15651 /* Construct the API message */
15652 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15653 mp->sw_if_index = ntohl (sw_if_index);
15654 mp->fib_id = ntohl (fib_id);
15657 mp->default_cop = default_cop;
15661 /* Wait for the reply */
15667 api_get_node_graph (vat_main_t * vam)
15669 vl_api_get_node_graph_t *mp;
15672 M (GET_NODE_GRAPH, mp);
15676 /* Wait for the reply */
15682 /** Used for parsing LISP eids */
15683 typedef CLIB_PACKED(struct{
15684 u8 addr[16]; /**< eid address */
15685 u32 len; /**< prefix length if IP */
15686 u8 type; /**< type of eid */
15691 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15693 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15695 memset (a, 0, sizeof (a[0]));
15697 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15699 a->type = 0; /* ipv4 type */
15701 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15703 a->type = 1; /* ipv6 type */
15705 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15707 a->type = 2; /* mac type */
15709 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15711 a->type = 3; /* NSH type */
15712 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15713 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15720 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15729 lisp_eid_size_vat (u8 type)
15746 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15748 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15752 api_one_add_del_locator_set (vat_main_t * vam)
15754 unformat_input_t *input = vam->input;
15755 vl_api_one_add_del_locator_set_t *mp;
15757 u8 *locator_set_name = NULL;
15758 u8 locator_set_name_set = 0;
15759 vl_api_local_locator_t locator, *locators = 0;
15760 u32 sw_if_index, priority, weight;
15764 /* Parse args required to build the message */
15765 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15767 if (unformat (input, "del"))
15771 else if (unformat (input, "locator-set %s", &locator_set_name))
15773 locator_set_name_set = 1;
15775 else if (unformat (input, "sw_if_index %u p %u w %u",
15776 &sw_if_index, &priority, &weight))
15778 locator.sw_if_index = htonl (sw_if_index);
15779 locator.priority = priority;
15780 locator.weight = weight;
15781 vec_add1 (locators, locator);
15785 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15786 &sw_if_index, &priority, &weight))
15788 locator.sw_if_index = htonl (sw_if_index);
15789 locator.priority = priority;
15790 locator.weight = weight;
15791 vec_add1 (locators, locator);
15797 if (locator_set_name_set == 0)
15799 errmsg ("missing locator-set name");
15800 vec_free (locators);
15804 if (vec_len (locator_set_name) > 64)
15806 errmsg ("locator-set name too long");
15807 vec_free (locator_set_name);
15808 vec_free (locators);
15811 vec_add1 (locator_set_name, 0);
15813 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15815 /* Construct the API message */
15816 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15818 mp->is_add = is_add;
15819 clib_memcpy (mp->locator_set_name, locator_set_name,
15820 vec_len (locator_set_name));
15821 vec_free (locator_set_name);
15823 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15825 clib_memcpy (mp->locators, locators, data_len);
15826 vec_free (locators);
15831 /* Wait for a reply... */
15836 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15839 api_one_add_del_locator (vat_main_t * vam)
15841 unformat_input_t *input = vam->input;
15842 vl_api_one_add_del_locator_t *mp;
15843 u32 tmp_if_index = ~0;
15844 u32 sw_if_index = ~0;
15845 u8 sw_if_index_set = 0;
15846 u8 sw_if_index_if_name_set = 0;
15848 u8 priority_set = 0;
15852 u8 *locator_set_name = NULL;
15853 u8 locator_set_name_set = 0;
15856 /* Parse args required to build the message */
15857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15859 if (unformat (input, "del"))
15863 else if (unformat (input, "locator-set %s", &locator_set_name))
15865 locator_set_name_set = 1;
15867 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15870 sw_if_index_if_name_set = 1;
15871 sw_if_index = tmp_if_index;
15873 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15875 sw_if_index_set = 1;
15876 sw_if_index = tmp_if_index;
15878 else if (unformat (input, "p %d", &priority))
15882 else if (unformat (input, "w %d", &weight))
15890 if (locator_set_name_set == 0)
15892 errmsg ("missing locator-set name");
15896 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15898 errmsg ("missing sw_if_index");
15899 vec_free (locator_set_name);
15903 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15905 errmsg ("cannot use both params interface name and sw_if_index");
15906 vec_free (locator_set_name);
15910 if (priority_set == 0)
15912 errmsg ("missing locator-set priority");
15913 vec_free (locator_set_name);
15917 if (weight_set == 0)
15919 errmsg ("missing locator-set weight");
15920 vec_free (locator_set_name);
15924 if (vec_len (locator_set_name) > 64)
15926 errmsg ("locator-set name too long");
15927 vec_free (locator_set_name);
15930 vec_add1 (locator_set_name, 0);
15932 /* Construct the API message */
15933 M (ONE_ADD_DEL_LOCATOR, mp);
15935 mp->is_add = is_add;
15936 mp->sw_if_index = ntohl (sw_if_index);
15937 mp->priority = priority;
15938 mp->weight = weight;
15939 clib_memcpy (mp->locator_set_name, locator_set_name,
15940 vec_len (locator_set_name));
15941 vec_free (locator_set_name);
15946 /* Wait for a reply... */
15951 #define api_lisp_add_del_locator api_one_add_del_locator
15954 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15956 u32 *key_id = va_arg (*args, u32 *);
15959 if (unformat (input, "%s", &s))
15961 if (!strcmp ((char *) s, "sha1"))
15962 key_id[0] = HMAC_SHA_1_96;
15963 else if (!strcmp ((char *) s, "sha256"))
15964 key_id[0] = HMAC_SHA_256_128;
15967 clib_warning ("invalid key_id: '%s'", s);
15968 key_id[0] = HMAC_NO_KEY;
15979 api_one_add_del_local_eid (vat_main_t * vam)
15981 unformat_input_t *input = vam->input;
15982 vl_api_one_add_del_local_eid_t *mp;
15985 lisp_eid_vat_t _eid, *eid = &_eid;
15986 u8 *locator_set_name = 0;
15987 u8 locator_set_name_set = 0;
15993 /* Parse args required to build the message */
15994 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15996 if (unformat (input, "del"))
16000 else if (unformat (input, "vni %d", &vni))
16004 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16008 else if (unformat (input, "locator-set %s", &locator_set_name))
16010 locator_set_name_set = 1;
16012 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16014 else if (unformat (input, "secret-key %_%v%_", &key))
16020 if (locator_set_name_set == 0)
16022 errmsg ("missing locator-set name");
16028 errmsg ("EID address not set!");
16029 vec_free (locator_set_name);
16033 if (key && (0 == key_id))
16035 errmsg ("invalid key_id!");
16039 if (vec_len (key) > 64)
16041 errmsg ("key too long");
16046 if (vec_len (locator_set_name) > 64)
16048 errmsg ("locator-set name too long");
16049 vec_free (locator_set_name);
16052 vec_add1 (locator_set_name, 0);
16054 /* Construct the API message */
16055 M (ONE_ADD_DEL_LOCAL_EID, mp);
16057 mp->is_add = is_add;
16058 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16059 mp->eid_type = eid->type;
16060 mp->prefix_len = eid->len;
16061 mp->vni = clib_host_to_net_u32 (vni);
16062 mp->key_id = clib_host_to_net_u16 (key_id);
16063 clib_memcpy (mp->locator_set_name, locator_set_name,
16064 vec_len (locator_set_name));
16065 clib_memcpy (mp->key, key, vec_len (key));
16067 vec_free (locator_set_name);
16073 /* Wait for a reply... */
16078 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16081 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16083 u32 dp_table = 0, vni = 0;;
16084 unformat_input_t *input = vam->input;
16085 vl_api_gpe_add_del_fwd_entry_t *mp;
16087 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16088 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16089 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16090 u32 action = ~0, w;
16091 ip4_address_t rmt_rloc4, lcl_rloc4;
16092 ip6_address_t rmt_rloc6, lcl_rloc6;
16093 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16096 memset (&rloc, 0, sizeof (rloc));
16098 /* Parse args required to build the message */
16099 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16101 if (unformat (input, "del"))
16103 else if (unformat (input, "add"))
16105 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16109 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16113 else if (unformat (input, "vrf %d", &dp_table))
16115 else if (unformat (input, "bd %d", &dp_table))
16117 else if (unformat (input, "vni %d", &vni))
16119 else if (unformat (input, "w %d", &w))
16123 errmsg ("No RLOC configured for setting priority/weight!");
16126 curr_rloc->weight = w;
16128 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16129 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16133 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16135 vec_add1 (lcl_locs, rloc);
16137 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16138 vec_add1 (rmt_locs, rloc);
16139 /* weight saved in rmt loc */
16140 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16142 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16143 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16146 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16148 vec_add1 (lcl_locs, rloc);
16150 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16151 vec_add1 (rmt_locs, rloc);
16152 /* weight saved in rmt loc */
16153 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16155 else if (unformat (input, "action %d", &action))
16161 clib_warning ("parse error '%U'", format_unformat_error, input);
16168 errmsg ("remote eid addresses not set");
16172 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16174 errmsg ("eid types don't match");
16178 if (0 == rmt_locs && (u32) ~ 0 == action)
16180 errmsg ("action not set for negative mapping");
16184 /* Construct the API message */
16185 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16186 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16188 mp->is_add = is_add;
16189 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16190 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16191 mp->eid_type = rmt_eid->type;
16192 mp->dp_table = clib_host_to_net_u32 (dp_table);
16193 mp->vni = clib_host_to_net_u32 (vni);
16194 mp->rmt_len = rmt_eid->len;
16195 mp->lcl_len = lcl_eid->len;
16196 mp->action = action;
16198 if (0 != rmt_locs && 0 != lcl_locs)
16200 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16201 clib_memcpy (mp->locs, lcl_locs,
16202 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16204 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16205 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16206 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16208 vec_free (lcl_locs);
16209 vec_free (rmt_locs);
16214 /* Wait for a reply... */
16220 api_one_add_del_map_server (vat_main_t * vam)
16222 unformat_input_t *input = vam->input;
16223 vl_api_one_add_del_map_server_t *mp;
16227 ip4_address_t ipv4;
16228 ip6_address_t ipv6;
16231 /* Parse args required to build the message */
16232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16234 if (unformat (input, "del"))
16238 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16242 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16250 if (ipv4_set && ipv6_set)
16252 errmsg ("both eid v4 and v6 addresses set");
16256 if (!ipv4_set && !ipv6_set)
16258 errmsg ("eid addresses not set");
16262 /* Construct the API message */
16263 M (ONE_ADD_DEL_MAP_SERVER, mp);
16265 mp->is_add = is_add;
16269 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16274 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16280 /* Wait for a reply... */
16285 #define api_lisp_add_del_map_server api_one_add_del_map_server
16288 api_one_add_del_map_resolver (vat_main_t * vam)
16290 unformat_input_t *input = vam->input;
16291 vl_api_one_add_del_map_resolver_t *mp;
16295 ip4_address_t ipv4;
16296 ip6_address_t ipv6;
16299 /* Parse args required to build the message */
16300 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16302 if (unformat (input, "del"))
16306 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16310 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16318 if (ipv4_set && ipv6_set)
16320 errmsg ("both eid v4 and v6 addresses set");
16324 if (!ipv4_set && !ipv6_set)
16326 errmsg ("eid addresses not set");
16330 /* Construct the API message */
16331 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16333 mp->is_add = is_add;
16337 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16342 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16348 /* Wait for a reply... */
16353 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16356 api_lisp_gpe_enable_disable (vat_main_t * vam)
16358 unformat_input_t *input = vam->input;
16359 vl_api_gpe_enable_disable_t *mp;
16364 /* Parse args required to build the message */
16365 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16367 if (unformat (input, "enable"))
16372 else if (unformat (input, "disable"))
16383 errmsg ("Value not set");
16387 /* Construct the API message */
16388 M (GPE_ENABLE_DISABLE, mp);
16395 /* Wait for a reply... */
16401 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16403 unformat_input_t *input = vam->input;
16404 vl_api_one_rloc_probe_enable_disable_t *mp;
16409 /* Parse args required to build the message */
16410 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16412 if (unformat (input, "enable"))
16417 else if (unformat (input, "disable"))
16425 errmsg ("Value not set");
16429 /* Construct the API message */
16430 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16432 mp->is_enabled = is_en;
16437 /* Wait for a reply... */
16442 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16445 api_one_map_register_enable_disable (vat_main_t * vam)
16447 unformat_input_t *input = vam->input;
16448 vl_api_one_map_register_enable_disable_t *mp;
16453 /* Parse args required to build the message */
16454 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16456 if (unformat (input, "enable"))
16461 else if (unformat (input, "disable"))
16469 errmsg ("Value not set");
16473 /* Construct the API message */
16474 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16476 mp->is_enabled = is_en;
16481 /* Wait for a reply... */
16486 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16489 api_one_enable_disable (vat_main_t * vam)
16491 unformat_input_t *input = vam->input;
16492 vl_api_one_enable_disable_t *mp;
16497 /* Parse args required to build the message */
16498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16500 if (unformat (input, "enable"))
16505 else if (unformat (input, "disable"))
16515 errmsg ("Value not set");
16519 /* Construct the API message */
16520 M (ONE_ENABLE_DISABLE, mp);
16527 /* Wait for a reply... */
16532 #define api_lisp_enable_disable api_one_enable_disable
16535 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16537 unformat_input_t *input = vam->input;
16538 vl_api_one_enable_disable_xtr_mode_t *mp;
16543 /* Parse args required to build the message */
16544 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16546 if (unformat (input, "enable"))
16551 else if (unformat (input, "disable"))
16561 errmsg ("Value not set");
16565 /* Construct the API message */
16566 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16573 /* Wait for a reply... */
16579 api_one_show_xtr_mode (vat_main_t * vam)
16581 vl_api_one_show_xtr_mode_t *mp;
16584 /* Construct the API message */
16585 M (ONE_SHOW_XTR_MODE, mp);
16590 /* Wait for a reply... */
16596 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16598 unformat_input_t *input = vam->input;
16599 vl_api_one_enable_disable_pitr_mode_t *mp;
16604 /* Parse args required to build the message */
16605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16607 if (unformat (input, "enable"))
16612 else if (unformat (input, "disable"))
16622 errmsg ("Value not set");
16626 /* Construct the API message */
16627 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16634 /* Wait for a reply... */
16640 api_one_show_pitr_mode (vat_main_t * vam)
16642 vl_api_one_show_pitr_mode_t *mp;
16645 /* Construct the API message */
16646 M (ONE_SHOW_PITR_MODE, mp);
16651 /* Wait for a reply... */
16657 api_one_enable_disable_petr_mode (vat_main_t * vam)
16659 unformat_input_t *input = vam->input;
16660 vl_api_one_enable_disable_petr_mode_t *mp;
16665 /* Parse args required to build the message */
16666 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16668 if (unformat (input, "enable"))
16673 else if (unformat (input, "disable"))
16683 errmsg ("Value not set");
16687 /* Construct the API message */
16688 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16695 /* Wait for a reply... */
16701 api_one_show_petr_mode (vat_main_t * vam)
16703 vl_api_one_show_petr_mode_t *mp;
16706 /* Construct the API message */
16707 M (ONE_SHOW_PETR_MODE, mp);
16712 /* Wait for a reply... */
16718 api_show_one_map_register_state (vat_main_t * vam)
16720 vl_api_show_one_map_register_state_t *mp;
16723 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16728 /* wait for reply */
16733 #define api_show_lisp_map_register_state api_show_one_map_register_state
16736 api_show_one_rloc_probe_state (vat_main_t * vam)
16738 vl_api_show_one_rloc_probe_state_t *mp;
16741 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16746 /* wait for reply */
16751 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16754 api_one_add_del_ndp_entry (vat_main_t * vam)
16756 vl_api_one_add_del_ndp_entry_t *mp;
16757 unformat_input_t *input = vam->input;
16762 u8 mac[6] = { 0, };
16763 u8 ip6[16] = { 0, };
16767 /* Parse args required to build the message */
16768 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16770 if (unformat (input, "del"))
16772 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16774 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16776 else if (unformat (input, "bd %d", &bd))
16780 errmsg ("parse error '%U'", format_unformat_error, input);
16785 if (!bd_set || !ip_set || (!mac_set && is_add))
16787 errmsg ("Missing BD, IP or MAC!");
16791 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16792 mp->is_add = is_add;
16793 clib_memcpy (mp->mac, mac, 6);
16794 mp->bd = clib_host_to_net_u32 (bd);
16795 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16800 /* wait for reply */
16806 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16808 vl_api_one_add_del_l2_arp_entry_t *mp;
16809 unformat_input_t *input = vam->input;
16814 u8 mac[6] = { 0, };
16815 u32 ip4 = 0, bd = ~0;
16818 /* Parse args required to build the message */
16819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16821 if (unformat (input, "del"))
16823 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16825 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16827 else if (unformat (input, "bd %d", &bd))
16831 errmsg ("parse error '%U'", format_unformat_error, input);
16836 if (!bd_set || !ip_set || (!mac_set && is_add))
16838 errmsg ("Missing BD, IP or MAC!");
16842 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16843 mp->is_add = is_add;
16844 clib_memcpy (mp->mac, mac, 6);
16845 mp->bd = clib_host_to_net_u32 (bd);
16851 /* wait for reply */
16857 api_one_ndp_bd_get (vat_main_t * vam)
16859 vl_api_one_ndp_bd_get_t *mp;
16862 M (ONE_NDP_BD_GET, mp);
16867 /* wait for reply */
16873 api_one_ndp_entries_get (vat_main_t * vam)
16875 vl_api_one_ndp_entries_get_t *mp;
16876 unformat_input_t *input = vam->input;
16881 /* Parse args required to build the message */
16882 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16884 if (unformat (input, "bd %d", &bd))
16888 errmsg ("parse error '%U'", format_unformat_error, input);
16895 errmsg ("Expected bridge domain!");
16899 M (ONE_NDP_ENTRIES_GET, mp);
16900 mp->bd = clib_host_to_net_u32 (bd);
16905 /* wait for reply */
16911 api_one_l2_arp_bd_get (vat_main_t * vam)
16913 vl_api_one_l2_arp_bd_get_t *mp;
16916 M (ONE_L2_ARP_BD_GET, mp);
16921 /* wait for reply */
16927 api_one_l2_arp_entries_get (vat_main_t * vam)
16929 vl_api_one_l2_arp_entries_get_t *mp;
16930 unformat_input_t *input = vam->input;
16935 /* Parse args required to build the message */
16936 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16938 if (unformat (input, "bd %d", &bd))
16942 errmsg ("parse error '%U'", format_unformat_error, input);
16949 errmsg ("Expected bridge domain!");
16953 M (ONE_L2_ARP_ENTRIES_GET, mp);
16954 mp->bd = clib_host_to_net_u32 (bd);
16959 /* wait for reply */
16965 api_one_stats_enable_disable (vat_main_t * vam)
16967 vl_api_one_stats_enable_disable_t *mp;
16968 unformat_input_t *input = vam->input;
16973 /* Parse args required to build the message */
16974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16976 if (unformat (input, "enable"))
16981 else if (unformat (input, "disable"))
16991 errmsg ("Value not set");
16995 M (ONE_STATS_ENABLE_DISABLE, mp);
17001 /* wait for reply */
17007 api_show_one_stats_enable_disable (vat_main_t * vam)
17009 vl_api_show_one_stats_enable_disable_t *mp;
17012 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17017 /* wait for reply */
17023 api_show_one_map_request_mode (vat_main_t * vam)
17025 vl_api_show_one_map_request_mode_t *mp;
17028 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17033 /* wait for reply */
17038 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17041 api_one_map_request_mode (vat_main_t * vam)
17043 unformat_input_t *input = vam->input;
17044 vl_api_one_map_request_mode_t *mp;
17048 /* Parse args required to build the message */
17049 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17051 if (unformat (input, "dst-only"))
17053 else if (unformat (input, "src-dst"))
17057 errmsg ("parse error '%U'", format_unformat_error, input);
17062 M (ONE_MAP_REQUEST_MODE, mp);
17069 /* wait for reply */
17074 #define api_lisp_map_request_mode api_one_map_request_mode
17077 * Enable/disable ONE proxy ITR.
17079 * @param vam vpp API test context
17080 * @return return code
17083 api_one_pitr_set_locator_set (vat_main_t * vam)
17085 u8 ls_name_set = 0;
17086 unformat_input_t *input = vam->input;
17087 vl_api_one_pitr_set_locator_set_t *mp;
17092 /* Parse args required to build the message */
17093 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17095 if (unformat (input, "del"))
17097 else if (unformat (input, "locator-set %s", &ls_name))
17101 errmsg ("parse error '%U'", format_unformat_error, input);
17108 errmsg ("locator-set name not set!");
17112 M (ONE_PITR_SET_LOCATOR_SET, mp);
17114 mp->is_add = is_add;
17115 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17116 vec_free (ls_name);
17121 /* wait for reply */
17126 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17129 api_one_nsh_set_locator_set (vat_main_t * vam)
17131 u8 ls_name_set = 0;
17132 unformat_input_t *input = vam->input;
17133 vl_api_one_nsh_set_locator_set_t *mp;
17138 /* Parse args required to build the message */
17139 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17141 if (unformat (input, "del"))
17143 else if (unformat (input, "ls %s", &ls_name))
17147 errmsg ("parse error '%U'", format_unformat_error, input);
17152 if (!ls_name_set && is_add)
17154 errmsg ("locator-set name not set!");
17158 M (ONE_NSH_SET_LOCATOR_SET, mp);
17160 mp->is_add = is_add;
17161 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17162 vec_free (ls_name);
17167 /* wait for reply */
17173 api_show_one_pitr (vat_main_t * vam)
17175 vl_api_show_one_pitr_t *mp;
17178 if (!vam->json_output)
17180 print (vam->ofp, "%=20s", "lisp status:");
17183 M (SHOW_ONE_PITR, mp);
17187 /* Wait for a reply... */
17192 #define api_show_lisp_pitr api_show_one_pitr
17195 api_one_use_petr (vat_main_t * vam)
17197 unformat_input_t *input = vam->input;
17198 vl_api_one_use_petr_t *mp;
17203 memset (&ip, 0, sizeof (ip));
17205 /* Parse args required to build the message */
17206 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17208 if (unformat (input, "disable"))
17211 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17214 ip_addr_version (&ip) = IP4;
17217 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17220 ip_addr_version (&ip) = IP6;
17224 errmsg ("parse error '%U'", format_unformat_error, input);
17229 M (ONE_USE_PETR, mp);
17231 mp->is_add = is_add;
17234 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17236 clib_memcpy (mp->address, &ip, 4);
17238 clib_memcpy (mp->address, &ip, 16);
17244 /* wait for reply */
17249 #define api_lisp_use_petr api_one_use_petr
17252 api_show_one_nsh_mapping (vat_main_t * vam)
17254 vl_api_show_one_use_petr_t *mp;
17257 if (!vam->json_output)
17259 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17262 M (SHOW_ONE_NSH_MAPPING, mp);
17266 /* Wait for a reply... */
17272 api_show_one_use_petr (vat_main_t * vam)
17274 vl_api_show_one_use_petr_t *mp;
17277 if (!vam->json_output)
17279 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17282 M (SHOW_ONE_USE_PETR, mp);
17286 /* Wait for a reply... */
17291 #define api_show_lisp_use_petr api_show_one_use_petr
17294 * Add/delete mapping between vni and vrf
17297 api_one_eid_table_add_del_map (vat_main_t * vam)
17299 unformat_input_t *input = vam->input;
17300 vl_api_one_eid_table_add_del_map_t *mp;
17301 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17302 u32 vni, vrf, bd_index;
17305 /* Parse args required to build the message */
17306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17308 if (unformat (input, "del"))
17310 else if (unformat (input, "vrf %d", &vrf))
17312 else if (unformat (input, "bd_index %d", &bd_index))
17314 else if (unformat (input, "vni %d", &vni))
17320 if (!vni_set || (!vrf_set && !bd_index_set))
17322 errmsg ("missing arguments!");
17326 if (vrf_set && bd_index_set)
17328 errmsg ("error: both vrf and bd entered!");
17332 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17334 mp->is_add = is_add;
17335 mp->vni = htonl (vni);
17336 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17337 mp->is_l2 = bd_index_set;
17342 /* wait for reply */
17347 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17350 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17352 u32 *action = va_arg (*args, u32 *);
17355 if (unformat (input, "%s", &s))
17357 if (!strcmp ((char *) s, "no-action"))
17359 else if (!strcmp ((char *) s, "natively-forward"))
17361 else if (!strcmp ((char *) s, "send-map-request"))
17363 else if (!strcmp ((char *) s, "drop"))
17367 clib_warning ("invalid action: '%s'", s);
17379 * Add/del remote mapping to/from ONE control plane
17381 * @param vam vpp API test context
17382 * @return return code
17385 api_one_add_del_remote_mapping (vat_main_t * vam)
17387 unformat_input_t *input = vam->input;
17388 vl_api_one_add_del_remote_mapping_t *mp;
17390 lisp_eid_vat_t _eid, *eid = &_eid;
17391 lisp_eid_vat_t _seid, *seid = &_seid;
17392 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17393 u32 action = ~0, p, w, data_len;
17394 ip4_address_t rloc4;
17395 ip6_address_t rloc6;
17396 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17399 memset (&rloc, 0, sizeof (rloc));
17401 /* Parse args required to build the message */
17402 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17404 if (unformat (input, "del-all"))
17408 else if (unformat (input, "del"))
17412 else if (unformat (input, "add"))
17416 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17420 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17424 else if (unformat (input, "vni %d", &vni))
17428 else if (unformat (input, "p %d w %d", &p, &w))
17432 errmsg ("No RLOC configured for setting priority/weight!");
17435 curr_rloc->priority = p;
17436 curr_rloc->weight = w;
17438 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17441 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17442 vec_add1 (rlocs, rloc);
17443 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17445 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17448 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17449 vec_add1 (rlocs, rloc);
17450 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17452 else if (unformat (input, "action %U",
17453 unformat_negative_mapping_action, &action))
17459 clib_warning ("parse error '%U'", format_unformat_error, input);
17466 errmsg ("missing params!");
17470 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17472 errmsg ("no action set for negative map-reply!");
17476 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17478 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17479 mp->is_add = is_add;
17480 mp->vni = htonl (vni);
17481 mp->action = (u8) action;
17482 mp->is_src_dst = seid_set;
17483 mp->eid_len = eid->len;
17484 mp->seid_len = seid->len;
17485 mp->del_all = del_all;
17486 mp->eid_type = eid->type;
17487 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17488 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17490 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17491 clib_memcpy (mp->rlocs, rlocs, data_len);
17497 /* Wait for a reply... */
17502 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17505 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17506 * forwarding entries in data-plane accordingly.
17508 * @param vam vpp API test context
17509 * @return return code
17512 api_one_add_del_adjacency (vat_main_t * vam)
17514 unformat_input_t *input = vam->input;
17515 vl_api_one_add_del_adjacency_t *mp;
17517 ip4_address_t leid4, reid4;
17518 ip6_address_t leid6, reid6;
17519 u8 reid_mac[6] = { 0 };
17520 u8 leid_mac[6] = { 0 };
17521 u8 reid_type, leid_type;
17522 u32 leid_len = 0, reid_len = 0, len;
17526 leid_type = reid_type = (u8) ~ 0;
17528 /* Parse args required to build the message */
17529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17531 if (unformat (input, "del"))
17535 else if (unformat (input, "add"))
17539 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17542 reid_type = 0; /* ipv4 */
17545 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17548 reid_type = 1; /* ipv6 */
17551 else if (unformat (input, "reid %U", unformat_ethernet_address,
17554 reid_type = 2; /* mac */
17556 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17559 leid_type = 0; /* ipv4 */
17562 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17565 leid_type = 1; /* ipv6 */
17568 else if (unformat (input, "leid %U", unformat_ethernet_address,
17571 leid_type = 2; /* mac */
17573 else if (unformat (input, "vni %d", &vni))
17579 errmsg ("parse error '%U'", format_unformat_error, input);
17584 if ((u8) ~ 0 == reid_type)
17586 errmsg ("missing params!");
17590 if (leid_type != reid_type)
17592 errmsg ("remote and local EIDs are of different types!");
17596 M (ONE_ADD_DEL_ADJACENCY, mp);
17597 mp->is_add = is_add;
17598 mp->vni = htonl (vni);
17599 mp->leid_len = leid_len;
17600 mp->reid_len = reid_len;
17601 mp->eid_type = reid_type;
17603 switch (mp->eid_type)
17606 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17607 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17610 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17611 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17614 clib_memcpy (mp->leid, leid_mac, 6);
17615 clib_memcpy (mp->reid, reid_mac, 6);
17618 errmsg ("unknown EID type %d!", mp->eid_type);
17625 /* Wait for a reply... */
17630 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17633 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17635 u32 *mode = va_arg (*args, u32 *);
17637 if (unformat (input, "lisp"))
17639 else if (unformat (input, "vxlan"))
17648 api_gpe_get_encap_mode (vat_main_t * vam)
17650 vl_api_gpe_get_encap_mode_t *mp;
17653 /* Construct the API message */
17654 M (GPE_GET_ENCAP_MODE, mp);
17659 /* Wait for a reply... */
17665 api_gpe_set_encap_mode (vat_main_t * vam)
17667 unformat_input_t *input = vam->input;
17668 vl_api_gpe_set_encap_mode_t *mp;
17672 /* Parse args required to build the message */
17673 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17675 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17681 /* Construct the API message */
17682 M (GPE_SET_ENCAP_MODE, mp);
17689 /* Wait for a reply... */
17695 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17697 unformat_input_t *input = vam->input;
17698 vl_api_gpe_add_del_iface_t *mp;
17699 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17700 u32 dp_table = 0, vni = 0;
17703 /* Parse args required to build the message */
17704 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17706 if (unformat (input, "up"))
17711 else if (unformat (input, "down"))
17716 else if (unformat (input, "table_id %d", &dp_table))
17720 else if (unformat (input, "bd_id %d", &dp_table))
17725 else if (unformat (input, "vni %d", &vni))
17733 if (action_set == 0)
17735 errmsg ("Action not set");
17738 if (dp_table_set == 0 || vni_set == 0)
17740 errmsg ("vni and dp_table must be set");
17744 /* Construct the API message */
17745 M (GPE_ADD_DEL_IFACE, mp);
17747 mp->is_add = is_add;
17748 mp->dp_table = clib_host_to_net_u32 (dp_table);
17750 mp->vni = clib_host_to_net_u32 (vni);
17755 /* Wait for a reply... */
17761 api_one_map_register_fallback_threshold (vat_main_t * vam)
17763 unformat_input_t *input = vam->input;
17764 vl_api_one_map_register_fallback_threshold_t *mp;
17769 /* Parse args required to build the message */
17770 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17772 if (unformat (input, "%u", &value))
17776 clib_warning ("parse error '%U'", format_unformat_error, input);
17783 errmsg ("fallback threshold value is missing!");
17787 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17788 mp->value = clib_host_to_net_u32 (value);
17793 /* Wait for a reply... */
17799 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17801 vl_api_show_one_map_register_fallback_threshold_t *mp;
17804 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17809 /* Wait for a reply... */
17815 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17817 u32 *proto = va_arg (*args, u32 *);
17819 if (unformat (input, "udp"))
17821 else if (unformat (input, "api"))
17830 api_one_set_transport_protocol (vat_main_t * vam)
17832 unformat_input_t *input = vam->input;
17833 vl_api_one_set_transport_protocol_t *mp;
17838 /* Parse args required to build the message */
17839 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17841 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17845 clib_warning ("parse error '%U'", format_unformat_error, input);
17852 errmsg ("Transport protocol missing!");
17856 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17857 mp->protocol = (u8) protocol;
17862 /* Wait for a reply... */
17868 api_one_get_transport_protocol (vat_main_t * vam)
17870 vl_api_one_get_transport_protocol_t *mp;
17873 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17878 /* Wait for a reply... */
17884 api_one_map_register_set_ttl (vat_main_t * vam)
17886 unformat_input_t *input = vam->input;
17887 vl_api_one_map_register_set_ttl_t *mp;
17892 /* Parse args required to build the message */
17893 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17895 if (unformat (input, "%u", &ttl))
17899 clib_warning ("parse error '%U'", format_unformat_error, input);
17906 errmsg ("TTL value missing!");
17910 M (ONE_MAP_REGISTER_SET_TTL, mp);
17911 mp->ttl = clib_host_to_net_u32 (ttl);
17916 /* Wait for a reply... */
17922 api_show_one_map_register_ttl (vat_main_t * vam)
17924 vl_api_show_one_map_register_ttl_t *mp;
17927 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17932 /* Wait for a reply... */
17938 * Add/del map request itr rlocs from ONE control plane and updates
17940 * @param vam vpp API test context
17941 * @return return code
17944 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17946 unformat_input_t *input = vam->input;
17947 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17948 u8 *locator_set_name = 0;
17949 u8 locator_set_name_set = 0;
17953 /* Parse args required to build the message */
17954 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17956 if (unformat (input, "del"))
17960 else if (unformat (input, "%_%v%_", &locator_set_name))
17962 locator_set_name_set = 1;
17966 clib_warning ("parse error '%U'", format_unformat_error, input);
17971 if (is_add && !locator_set_name_set)
17973 errmsg ("itr-rloc is not set!");
17977 if (is_add && vec_len (locator_set_name) > 64)
17979 errmsg ("itr-rloc locator-set name too long");
17980 vec_free (locator_set_name);
17984 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17985 mp->is_add = is_add;
17988 clib_memcpy (mp->locator_set_name, locator_set_name,
17989 vec_len (locator_set_name));
17993 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17995 vec_free (locator_set_name);
18000 /* Wait for a reply... */
18005 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18008 api_one_locator_dump (vat_main_t * vam)
18010 unformat_input_t *input = vam->input;
18011 vl_api_one_locator_dump_t *mp;
18012 vl_api_control_ping_t *mp_ping;
18013 u8 is_index_set = 0, is_name_set = 0;
18018 /* Parse args required to build the message */
18019 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18021 if (unformat (input, "ls_name %_%v%_", &ls_name))
18025 else if (unformat (input, "ls_index %d", &ls_index))
18031 errmsg ("parse error '%U'", format_unformat_error, input);
18036 if (!is_index_set && !is_name_set)
18038 errmsg ("error: expected one of index or name!");
18042 if (is_index_set && is_name_set)
18044 errmsg ("error: only one param expected!");
18048 if (vec_len (ls_name) > 62)
18050 errmsg ("error: locator set name too long!");
18054 if (!vam->json_output)
18056 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18059 M (ONE_LOCATOR_DUMP, mp);
18060 mp->is_index_set = is_index_set;
18063 mp->ls_index = clib_host_to_net_u32 (ls_index);
18066 vec_add1 (ls_name, 0);
18067 strncpy ((char *) mp->ls_name, (char *) ls_name,
18068 sizeof (mp->ls_name) - 1);
18074 /* Use a control ping for synchronization */
18075 MPING (CONTROL_PING, mp_ping);
18078 /* Wait for a reply... */
18083 #define api_lisp_locator_dump api_one_locator_dump
18086 api_one_locator_set_dump (vat_main_t * vam)
18088 vl_api_one_locator_set_dump_t *mp;
18089 vl_api_control_ping_t *mp_ping;
18090 unformat_input_t *input = vam->input;
18094 /* Parse args required to build the message */
18095 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18097 if (unformat (input, "local"))
18101 else if (unformat (input, "remote"))
18107 errmsg ("parse error '%U'", format_unformat_error, input);
18112 if (!vam->json_output)
18114 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18117 M (ONE_LOCATOR_SET_DUMP, mp);
18119 mp->filter = filter;
18124 /* Use a control ping for synchronization */
18125 MPING (CONTROL_PING, mp_ping);
18128 /* Wait for a reply... */
18133 #define api_lisp_locator_set_dump api_one_locator_set_dump
18136 api_one_eid_table_map_dump (vat_main_t * vam)
18140 unformat_input_t *input = vam->input;
18141 vl_api_one_eid_table_map_dump_t *mp;
18142 vl_api_control_ping_t *mp_ping;
18145 /* Parse args required to build the message */
18146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18148 if (unformat (input, "l2"))
18153 else if (unformat (input, "l3"))
18160 errmsg ("parse error '%U'", format_unformat_error, input);
18167 errmsg ("expected one of 'l2' or 'l3' parameter!");
18171 if (!vam->json_output)
18173 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18176 M (ONE_EID_TABLE_MAP_DUMP, mp);
18182 /* Use a control ping for synchronization */
18183 MPING (CONTROL_PING, mp_ping);
18186 /* Wait for a reply... */
18191 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18194 api_one_eid_table_vni_dump (vat_main_t * vam)
18196 vl_api_one_eid_table_vni_dump_t *mp;
18197 vl_api_control_ping_t *mp_ping;
18200 if (!vam->json_output)
18202 print (vam->ofp, "VNI");
18205 M (ONE_EID_TABLE_VNI_DUMP, mp);
18210 /* Use a control ping for synchronization */
18211 MPING (CONTROL_PING, mp_ping);
18214 /* Wait for a reply... */
18219 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18222 api_one_eid_table_dump (vat_main_t * vam)
18224 unformat_input_t *i = vam->input;
18225 vl_api_one_eid_table_dump_t *mp;
18226 vl_api_control_ping_t *mp_ping;
18227 struct in_addr ip4;
18228 struct in6_addr ip6;
18230 u8 eid_type = ~0, eid_set = 0;
18231 u32 prefix_length = ~0, t, vni = 0;
18234 lisp_nsh_api_t nsh;
18236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18238 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18244 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18250 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18255 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18260 else if (unformat (i, "vni %d", &t))
18264 else if (unformat (i, "local"))
18268 else if (unformat (i, "remote"))
18274 errmsg ("parse error '%U'", format_unformat_error, i);
18279 if (!vam->json_output)
18281 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18282 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18285 M (ONE_EID_TABLE_DUMP, mp);
18287 mp->filter = filter;
18291 mp->vni = htonl (vni);
18292 mp->eid_type = eid_type;
18296 mp->prefix_length = prefix_length;
18297 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18300 mp->prefix_length = prefix_length;
18301 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18304 clib_memcpy (mp->eid, mac, sizeof (mac));
18307 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18310 errmsg ("unknown EID type %d!", eid_type);
18318 /* Use a control ping for synchronization */
18319 MPING (CONTROL_PING, mp_ping);
18322 /* Wait for a reply... */
18327 #define api_lisp_eid_table_dump api_one_eid_table_dump
18330 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18332 unformat_input_t *i = vam->input;
18333 vl_api_gpe_fwd_entries_get_t *mp;
18338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18340 if (unformat (i, "vni %d", &vni))
18346 errmsg ("parse error '%U'", format_unformat_error, i);
18353 errmsg ("vni not set!");
18357 if (!vam->json_output)
18359 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18363 M (GPE_FWD_ENTRIES_GET, mp);
18364 mp->vni = clib_host_to_net_u32 (vni);
18369 /* Wait for a reply... */
18374 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18375 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18376 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18377 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18378 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18379 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18380 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18381 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18384 api_one_adjacencies_get (vat_main_t * vam)
18386 unformat_input_t *i = vam->input;
18387 vl_api_one_adjacencies_get_t *mp;
18392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18394 if (unformat (i, "vni %d", &vni))
18400 errmsg ("parse error '%U'", format_unformat_error, i);
18407 errmsg ("vni not set!");
18411 if (!vam->json_output)
18413 print (vam->ofp, "%s %40s", "leid", "reid");
18416 M (ONE_ADJACENCIES_GET, mp);
18417 mp->vni = clib_host_to_net_u32 (vni);
18422 /* Wait for a reply... */
18427 #define api_lisp_adjacencies_get api_one_adjacencies_get
18430 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18432 unformat_input_t *i = vam->input;
18433 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18435 u8 ip_family_set = 0, is_ip4 = 1;
18437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18439 if (unformat (i, "ip4"))
18444 else if (unformat (i, "ip6"))
18451 errmsg ("parse error '%U'", format_unformat_error, i);
18456 if (!ip_family_set)
18458 errmsg ("ip family not set!");
18462 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18463 mp->is_ip4 = is_ip4;
18468 /* Wait for a reply... */
18474 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18476 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18479 if (!vam->json_output)
18481 print (vam->ofp, "VNIs");
18484 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18489 /* Wait for a reply... */
18495 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18497 unformat_input_t *i = vam->input;
18498 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18500 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18501 struct in_addr ip4;
18502 struct in6_addr ip6;
18503 u32 table_id = 0, nh_sw_if_index = ~0;
18505 memset (&ip4, 0, sizeof (ip4));
18506 memset (&ip6, 0, sizeof (ip6));
18508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18510 if (unformat (i, "del"))
18512 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18513 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18518 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18519 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18524 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18528 nh_sw_if_index = ~0;
18530 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18534 nh_sw_if_index = ~0;
18536 else if (unformat (i, "table %d", &table_id))
18540 errmsg ("parse error '%U'", format_unformat_error, i);
18547 errmsg ("nh addr not set!");
18551 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18552 mp->is_add = is_add;
18553 mp->table_id = clib_host_to_net_u32 (table_id);
18554 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18555 mp->is_ip4 = is_ip4;
18557 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18559 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18564 /* Wait for a reply... */
18570 api_one_map_server_dump (vat_main_t * vam)
18572 vl_api_one_map_server_dump_t *mp;
18573 vl_api_control_ping_t *mp_ping;
18576 if (!vam->json_output)
18578 print (vam->ofp, "%=20s", "Map server");
18581 M (ONE_MAP_SERVER_DUMP, mp);
18585 /* Use a control ping for synchronization */
18586 MPING (CONTROL_PING, mp_ping);
18589 /* Wait for a reply... */
18594 #define api_lisp_map_server_dump api_one_map_server_dump
18597 api_one_map_resolver_dump (vat_main_t * vam)
18599 vl_api_one_map_resolver_dump_t *mp;
18600 vl_api_control_ping_t *mp_ping;
18603 if (!vam->json_output)
18605 print (vam->ofp, "%=20s", "Map resolver");
18608 M (ONE_MAP_RESOLVER_DUMP, mp);
18612 /* Use a control ping for synchronization */
18613 MPING (CONTROL_PING, mp_ping);
18616 /* Wait for a reply... */
18621 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18624 api_one_stats_flush (vat_main_t * vam)
18626 vl_api_one_stats_flush_t *mp;
18629 M (ONE_STATS_FLUSH, mp);
18636 api_one_stats_dump (vat_main_t * vam)
18638 vl_api_one_stats_dump_t *mp;
18639 vl_api_control_ping_t *mp_ping;
18642 M (ONE_STATS_DUMP, mp);
18646 /* Use a control ping for synchronization */
18647 MPING (CONTROL_PING, mp_ping);
18650 /* Wait for a reply... */
18656 api_show_one_status (vat_main_t * vam)
18658 vl_api_show_one_status_t *mp;
18661 if (!vam->json_output)
18663 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18666 M (SHOW_ONE_STATUS, mp);
18669 /* Wait for a reply... */
18674 #define api_show_lisp_status api_show_one_status
18677 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18679 vl_api_gpe_fwd_entry_path_dump_t *mp;
18680 vl_api_control_ping_t *mp_ping;
18681 unformat_input_t *i = vam->input;
18682 u32 fwd_entry_index = ~0;
18685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18687 if (unformat (i, "index %d", &fwd_entry_index))
18693 if (~0 == fwd_entry_index)
18695 errmsg ("no index specified!");
18699 if (!vam->json_output)
18701 print (vam->ofp, "first line");
18704 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18708 /* Use a control ping for synchronization */
18709 MPING (CONTROL_PING, mp_ping);
18712 /* Wait for a reply... */
18718 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18720 vl_api_one_get_map_request_itr_rlocs_t *mp;
18723 if (!vam->json_output)
18725 print (vam->ofp, "%=20s", "itr-rlocs:");
18728 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18731 /* Wait for a reply... */
18736 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18739 api_af_packet_create (vat_main_t * vam)
18741 unformat_input_t *i = vam->input;
18742 vl_api_af_packet_create_t *mp;
18743 u8 *host_if_name = 0;
18745 u8 random_hw_addr = 1;
18748 memset (hw_addr, 0, sizeof (hw_addr));
18750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18752 if (unformat (i, "name %s", &host_if_name))
18753 vec_add1 (host_if_name, 0);
18754 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18755 random_hw_addr = 0;
18760 if (!vec_len (host_if_name))
18762 errmsg ("host-interface name must be specified");
18766 if (vec_len (host_if_name) > 64)
18768 errmsg ("host-interface name too long");
18772 M (AF_PACKET_CREATE, mp);
18774 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18775 clib_memcpy (mp->hw_addr, hw_addr, 6);
18776 mp->use_random_hw_addr = random_hw_addr;
18777 vec_free (host_if_name);
18785 fprintf (vam->ofp ? vam->ofp : stderr,
18786 " new sw_if_index = %d\n", vam->sw_if_index);
18793 api_af_packet_delete (vat_main_t * vam)
18795 unformat_input_t *i = vam->input;
18796 vl_api_af_packet_delete_t *mp;
18797 u8 *host_if_name = 0;
18800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18802 if (unformat (i, "name %s", &host_if_name))
18803 vec_add1 (host_if_name, 0);
18808 if (!vec_len (host_if_name))
18810 errmsg ("host-interface name must be specified");
18814 if (vec_len (host_if_name) > 64)
18816 errmsg ("host-interface name too long");
18820 M (AF_PACKET_DELETE, mp);
18822 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18823 vec_free (host_if_name);
18831 api_policer_add_del (vat_main_t * vam)
18833 unformat_input_t *i = vam->input;
18834 vl_api_policer_add_del_t *mp;
18844 u8 color_aware = 0;
18845 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18848 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18849 conform_action.dscp = 0;
18850 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18851 exceed_action.dscp = 0;
18852 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18853 violate_action.dscp = 0;
18855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18857 if (unformat (i, "del"))
18859 else if (unformat (i, "name %s", &name))
18860 vec_add1 (name, 0);
18861 else if (unformat (i, "cir %u", &cir))
18863 else if (unformat (i, "eir %u", &eir))
18865 else if (unformat (i, "cb %u", &cb))
18867 else if (unformat (i, "eb %u", &eb))
18869 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18872 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18875 else if (unformat (i, "type %U", unformat_policer_type, &type))
18877 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18880 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18883 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18886 else if (unformat (i, "color-aware"))
18892 if (!vec_len (name))
18894 errmsg ("policer name must be specified");
18898 if (vec_len (name) > 64)
18900 errmsg ("policer name too long");
18904 M (POLICER_ADD_DEL, mp);
18906 clib_memcpy (mp->name, name, vec_len (name));
18908 mp->is_add = is_add;
18909 mp->cir = ntohl (cir);
18910 mp->eir = ntohl (eir);
18911 mp->cb = clib_net_to_host_u64 (cb);
18912 mp->eb = clib_net_to_host_u64 (eb);
18913 mp->rate_type = rate_type;
18914 mp->round_type = round_type;
18916 mp->conform_action_type = conform_action.action_type;
18917 mp->conform_dscp = conform_action.dscp;
18918 mp->exceed_action_type = exceed_action.action_type;
18919 mp->exceed_dscp = exceed_action.dscp;
18920 mp->violate_action_type = violate_action.action_type;
18921 mp->violate_dscp = violate_action.dscp;
18922 mp->color_aware = color_aware;
18930 api_policer_dump (vat_main_t * vam)
18932 unformat_input_t *i = vam->input;
18933 vl_api_policer_dump_t *mp;
18934 vl_api_control_ping_t *mp_ping;
18935 u8 *match_name = 0;
18936 u8 match_name_valid = 0;
18939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18941 if (unformat (i, "name %s", &match_name))
18943 vec_add1 (match_name, 0);
18944 match_name_valid = 1;
18950 M (POLICER_DUMP, mp);
18951 mp->match_name_valid = match_name_valid;
18952 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18953 vec_free (match_name);
18957 /* Use a control ping for synchronization */
18958 MPING (CONTROL_PING, mp_ping);
18961 /* Wait for a reply... */
18967 api_policer_classify_set_interface (vat_main_t * vam)
18969 unformat_input_t *i = vam->input;
18970 vl_api_policer_classify_set_interface_t *mp;
18972 int sw_if_index_set;
18973 u32 ip4_table_index = ~0;
18974 u32 ip6_table_index = ~0;
18975 u32 l2_table_index = ~0;
18979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18981 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18982 sw_if_index_set = 1;
18983 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18984 sw_if_index_set = 1;
18985 else if (unformat (i, "del"))
18987 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18989 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18991 else if (unformat (i, "l2-table %d", &l2_table_index))
18995 clib_warning ("parse error '%U'", format_unformat_error, i);
19000 if (sw_if_index_set == 0)
19002 errmsg ("missing interface name or sw_if_index");
19006 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19008 mp->sw_if_index = ntohl (sw_if_index);
19009 mp->ip4_table_index = ntohl (ip4_table_index);
19010 mp->ip6_table_index = ntohl (ip6_table_index);
19011 mp->l2_table_index = ntohl (l2_table_index);
19012 mp->is_add = is_add;
19020 api_policer_classify_dump (vat_main_t * vam)
19022 unformat_input_t *i = vam->input;
19023 vl_api_policer_classify_dump_t *mp;
19024 vl_api_control_ping_t *mp_ping;
19025 u8 type = POLICER_CLASSIFY_N_TABLES;
19028 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19032 errmsg ("classify table type must be specified");
19036 if (!vam->json_output)
19038 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19041 M (POLICER_CLASSIFY_DUMP, mp);
19046 /* Use a control ping for synchronization */
19047 MPING (CONTROL_PING, mp_ping);
19050 /* Wait for a reply... */
19056 api_netmap_create (vat_main_t * vam)
19058 unformat_input_t *i = vam->input;
19059 vl_api_netmap_create_t *mp;
19062 u8 random_hw_addr = 1;
19067 memset (hw_addr, 0, sizeof (hw_addr));
19069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19071 if (unformat (i, "name %s", &if_name))
19072 vec_add1 (if_name, 0);
19073 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19074 random_hw_addr = 0;
19075 else if (unformat (i, "pipe"))
19077 else if (unformat (i, "master"))
19079 else if (unformat (i, "slave"))
19085 if (!vec_len (if_name))
19087 errmsg ("interface name must be specified");
19091 if (vec_len (if_name) > 64)
19093 errmsg ("interface name too long");
19097 M (NETMAP_CREATE, mp);
19099 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19100 clib_memcpy (mp->hw_addr, hw_addr, 6);
19101 mp->use_random_hw_addr = random_hw_addr;
19102 mp->is_pipe = is_pipe;
19103 mp->is_master = is_master;
19104 vec_free (if_name);
19112 api_netmap_delete (vat_main_t * vam)
19114 unformat_input_t *i = vam->input;
19115 vl_api_netmap_delete_t *mp;
19119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19121 if (unformat (i, "name %s", &if_name))
19122 vec_add1 (if_name, 0);
19127 if (!vec_len (if_name))
19129 errmsg ("interface name must be specified");
19133 if (vec_len (if_name) > 64)
19135 errmsg ("interface name too long");
19139 M (NETMAP_DELETE, mp);
19141 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19142 vec_free (if_name);
19150 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19152 if (fp->afi == IP46_TYPE_IP6)
19154 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19155 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19156 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19157 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19158 format_ip6_address, fp->next_hop);
19159 else if (fp->afi == IP46_TYPE_IP4)
19161 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19162 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19163 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19164 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19165 format_ip4_address, fp->next_hop);
19169 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19170 vl_api_fib_path2_t * fp)
19172 struct in_addr ip4;
19173 struct in6_addr ip6;
19175 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19176 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19177 vat_json_object_add_uint (node, "is_local", fp->is_local);
19178 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19179 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19180 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19181 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19182 if (fp->afi == IP46_TYPE_IP4)
19184 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19185 vat_json_object_add_ip4 (node, "next_hop", ip4);
19187 else if (fp->afi == IP46_TYPE_IP6)
19189 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19190 vat_json_object_add_ip6 (node, "next_hop", ip6);
19195 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19197 vat_main_t *vam = &vat_main;
19198 int count = ntohl (mp->mt_count);
19199 vl_api_fib_path2_t *fp;
19202 print (vam->ofp, "[%d]: sw_if_index %d via:",
19203 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19205 for (i = 0; i < count; i++)
19207 vl_api_mpls_fib_path_print (vam, fp);
19211 print (vam->ofp, "");
19214 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19215 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19218 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19220 vat_main_t *vam = &vat_main;
19221 vat_json_node_t *node = NULL;
19222 int count = ntohl (mp->mt_count);
19223 vl_api_fib_path2_t *fp;
19226 if (VAT_JSON_ARRAY != vam->json_tree.type)
19228 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19229 vat_json_init_array (&vam->json_tree);
19231 node = vat_json_array_add (&vam->json_tree);
19233 vat_json_init_object (node);
19234 vat_json_object_add_uint (node, "tunnel_index",
19235 ntohl (mp->mt_tunnel_index));
19236 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19238 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19241 for (i = 0; i < count; i++)
19243 vl_api_mpls_fib_path_json_print (node, fp);
19249 api_mpls_tunnel_dump (vat_main_t * vam)
19251 vl_api_mpls_tunnel_dump_t *mp;
19252 vl_api_control_ping_t *mp_ping;
19256 /* Parse args required to build the message */
19257 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19259 if (!unformat (vam->input, "tunnel_index %d", &index))
19266 print (vam->ofp, " tunnel_index %d", index);
19268 M (MPLS_TUNNEL_DUMP, mp);
19269 mp->tunnel_index = htonl (index);
19272 /* Use a control ping for synchronization */
19273 MPING (CONTROL_PING, mp_ping);
19280 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19281 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19285 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19287 vat_main_t *vam = &vat_main;
19288 int count = ntohl (mp->count);
19289 vl_api_fib_path2_t *fp;
19293 "table-id %d, label %u, ess_bit %u",
19294 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19296 for (i = 0; i < count; i++)
19298 vl_api_mpls_fib_path_print (vam, fp);
19303 static void vl_api_mpls_fib_details_t_handler_json
19304 (vl_api_mpls_fib_details_t * mp)
19306 vat_main_t *vam = &vat_main;
19307 int count = ntohl (mp->count);
19308 vat_json_node_t *node = NULL;
19309 vl_api_fib_path2_t *fp;
19312 if (VAT_JSON_ARRAY != vam->json_tree.type)
19314 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19315 vat_json_init_array (&vam->json_tree);
19317 node = vat_json_array_add (&vam->json_tree);
19319 vat_json_init_object (node);
19320 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19321 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19322 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19323 vat_json_object_add_uint (node, "path_count", count);
19325 for (i = 0; i < count; i++)
19327 vl_api_mpls_fib_path_json_print (node, fp);
19333 api_mpls_fib_dump (vat_main_t * vam)
19335 vl_api_mpls_fib_dump_t *mp;
19336 vl_api_control_ping_t *mp_ping;
19339 M (MPLS_FIB_DUMP, mp);
19342 /* Use a control ping for synchronization */
19343 MPING (CONTROL_PING, mp_ping);
19350 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19351 #define vl_api_ip_fib_details_t_print vl_noop_handler
19354 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19356 vat_main_t *vam = &vat_main;
19357 int count = ntohl (mp->count);
19358 vl_api_fib_path_t *fp;
19362 "table-id %d, prefix %U/%d",
19363 ntohl (mp->table_id), format_ip4_address, mp->address,
19364 mp->address_length);
19366 for (i = 0; i < count; i++)
19368 if (fp->afi == IP46_TYPE_IP6)
19370 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19371 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19372 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19373 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19374 format_ip6_address, fp->next_hop);
19375 else if (fp->afi == IP46_TYPE_IP4)
19377 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19378 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19379 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19380 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19381 format_ip4_address, fp->next_hop);
19386 static void vl_api_ip_fib_details_t_handler_json
19387 (vl_api_ip_fib_details_t * mp)
19389 vat_main_t *vam = &vat_main;
19390 int count = ntohl (mp->count);
19391 vat_json_node_t *node = NULL;
19392 struct in_addr ip4;
19393 struct in6_addr ip6;
19394 vl_api_fib_path_t *fp;
19397 if (VAT_JSON_ARRAY != vam->json_tree.type)
19399 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19400 vat_json_init_array (&vam->json_tree);
19402 node = vat_json_array_add (&vam->json_tree);
19404 vat_json_init_object (node);
19405 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19406 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19407 vat_json_object_add_ip4 (node, "prefix", ip4);
19408 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19409 vat_json_object_add_uint (node, "path_count", count);
19411 for (i = 0; i < count; i++)
19413 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19414 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19415 vat_json_object_add_uint (node, "is_local", fp->is_local);
19416 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19417 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19418 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19419 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19420 if (fp->afi == IP46_TYPE_IP4)
19422 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19423 vat_json_object_add_ip4 (node, "next_hop", ip4);
19425 else if (fp->afi == IP46_TYPE_IP6)
19427 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19428 vat_json_object_add_ip6 (node, "next_hop", ip6);
19434 api_ip_fib_dump (vat_main_t * vam)
19436 vl_api_ip_fib_dump_t *mp;
19437 vl_api_control_ping_t *mp_ping;
19440 M (IP_FIB_DUMP, mp);
19443 /* Use a control ping for synchronization */
19444 MPING (CONTROL_PING, mp_ping);
19452 api_ip_mfib_dump (vat_main_t * vam)
19454 vl_api_ip_mfib_dump_t *mp;
19455 vl_api_control_ping_t *mp_ping;
19458 M (IP_MFIB_DUMP, mp);
19461 /* Use a control ping for synchronization */
19462 MPING (CONTROL_PING, mp_ping);
19469 static void vl_api_ip_neighbor_details_t_handler
19470 (vl_api_ip_neighbor_details_t * mp)
19472 vat_main_t *vam = &vat_main;
19474 print (vam->ofp, "%c %U %U",
19475 (mp->is_static) ? 'S' : 'D',
19476 format_ethernet_address, &mp->mac_address,
19477 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19481 static void vl_api_ip_neighbor_details_t_handler_json
19482 (vl_api_ip_neighbor_details_t * mp)
19485 vat_main_t *vam = &vat_main;
19486 vat_json_node_t *node;
19487 struct in_addr ip4;
19488 struct in6_addr ip6;
19490 if (VAT_JSON_ARRAY != vam->json_tree.type)
19492 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19493 vat_json_init_array (&vam->json_tree);
19495 node = vat_json_array_add (&vam->json_tree);
19497 vat_json_init_object (node);
19498 vat_json_object_add_string_copy (node, "flag",
19499 (mp->is_static) ? (u8 *) "static" : (u8 *)
19502 vat_json_object_add_string_copy (node, "link_layer",
19503 format (0, "%U", format_ethernet_address,
19504 &mp->mac_address));
19508 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19509 vat_json_object_add_ip6 (node, "ip_address", ip6);
19513 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19514 vat_json_object_add_ip4 (node, "ip_address", ip4);
19519 api_ip_neighbor_dump (vat_main_t * vam)
19521 unformat_input_t *i = vam->input;
19522 vl_api_ip_neighbor_dump_t *mp;
19523 vl_api_control_ping_t *mp_ping;
19525 u32 sw_if_index = ~0;
19528 /* Parse args required to build the message */
19529 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19531 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19533 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19535 else if (unformat (i, "ip6"))
19541 if (sw_if_index == ~0)
19543 errmsg ("missing interface name or sw_if_index");
19547 M (IP_NEIGHBOR_DUMP, mp);
19548 mp->is_ipv6 = (u8) is_ipv6;
19549 mp->sw_if_index = ntohl (sw_if_index);
19552 /* Use a control ping for synchronization */
19553 MPING (CONTROL_PING, mp_ping);
19560 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19561 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19564 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19566 vat_main_t *vam = &vat_main;
19567 int count = ntohl (mp->count);
19568 vl_api_fib_path_t *fp;
19572 "table-id %d, prefix %U/%d",
19573 ntohl (mp->table_id), format_ip6_address, mp->address,
19574 mp->address_length);
19576 for (i = 0; i < count; i++)
19578 if (fp->afi == IP46_TYPE_IP6)
19580 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19581 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19582 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19583 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19584 format_ip6_address, fp->next_hop);
19585 else if (fp->afi == IP46_TYPE_IP4)
19587 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19588 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19589 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19590 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19591 format_ip4_address, fp->next_hop);
19596 static void vl_api_ip6_fib_details_t_handler_json
19597 (vl_api_ip6_fib_details_t * mp)
19599 vat_main_t *vam = &vat_main;
19600 int count = ntohl (mp->count);
19601 vat_json_node_t *node = NULL;
19602 struct in_addr ip4;
19603 struct in6_addr ip6;
19604 vl_api_fib_path_t *fp;
19607 if (VAT_JSON_ARRAY != vam->json_tree.type)
19609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19610 vat_json_init_array (&vam->json_tree);
19612 node = vat_json_array_add (&vam->json_tree);
19614 vat_json_init_object (node);
19615 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19616 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19617 vat_json_object_add_ip6 (node, "prefix", ip6);
19618 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19619 vat_json_object_add_uint (node, "path_count", count);
19621 for (i = 0; i < count; i++)
19623 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19624 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19625 vat_json_object_add_uint (node, "is_local", fp->is_local);
19626 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19627 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19628 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19629 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19630 if (fp->afi == IP46_TYPE_IP4)
19632 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19633 vat_json_object_add_ip4 (node, "next_hop", ip4);
19635 else if (fp->afi == IP46_TYPE_IP6)
19637 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19638 vat_json_object_add_ip6 (node, "next_hop", ip6);
19644 api_ip6_fib_dump (vat_main_t * vam)
19646 vl_api_ip6_fib_dump_t *mp;
19647 vl_api_control_ping_t *mp_ping;
19650 M (IP6_FIB_DUMP, mp);
19653 /* Use a control ping for synchronization */
19654 MPING (CONTROL_PING, mp_ping);
19662 api_ip6_mfib_dump (vat_main_t * vam)
19664 vl_api_ip6_mfib_dump_t *mp;
19665 vl_api_control_ping_t *mp_ping;
19668 M (IP6_MFIB_DUMP, mp);
19671 /* Use a control ping for synchronization */
19672 MPING (CONTROL_PING, mp_ping);
19680 api_classify_table_ids (vat_main_t * vam)
19682 vl_api_classify_table_ids_t *mp;
19685 /* Construct the API message */
19686 M (CLASSIFY_TABLE_IDS, mp);
19695 api_classify_table_by_interface (vat_main_t * vam)
19697 unformat_input_t *input = vam->input;
19698 vl_api_classify_table_by_interface_t *mp;
19700 u32 sw_if_index = ~0;
19702 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19704 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19706 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19711 if (sw_if_index == ~0)
19713 errmsg ("missing interface name or sw_if_index");
19717 /* Construct the API message */
19718 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19720 mp->sw_if_index = ntohl (sw_if_index);
19728 api_classify_table_info (vat_main_t * vam)
19730 unformat_input_t *input = vam->input;
19731 vl_api_classify_table_info_t *mp;
19735 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19737 if (unformat (input, "table_id %d", &table_id))
19742 if (table_id == ~0)
19744 errmsg ("missing table id");
19748 /* Construct the API message */
19749 M (CLASSIFY_TABLE_INFO, mp);
19751 mp->table_id = ntohl (table_id);
19759 api_classify_session_dump (vat_main_t * vam)
19761 unformat_input_t *input = vam->input;
19762 vl_api_classify_session_dump_t *mp;
19763 vl_api_control_ping_t *mp_ping;
19767 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19769 if (unformat (input, "table_id %d", &table_id))
19774 if (table_id == ~0)
19776 errmsg ("missing table id");
19780 /* Construct the API message */
19781 M (CLASSIFY_SESSION_DUMP, mp);
19783 mp->table_id = ntohl (table_id);
19786 /* Use a control ping for synchronization */
19787 MPING (CONTROL_PING, mp_ping);
19795 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19797 vat_main_t *vam = &vat_main;
19799 print (vam->ofp, "collector_address %U, collector_port %d, "
19800 "src_address %U, vrf_id %d, path_mtu %u, "
19801 "template_interval %u, udp_checksum %d",
19802 format_ip4_address, mp->collector_address,
19803 ntohs (mp->collector_port),
19804 format_ip4_address, mp->src_address,
19805 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19806 ntohl (mp->template_interval), mp->udp_checksum);
19809 vam->result_ready = 1;
19813 vl_api_ipfix_exporter_details_t_handler_json
19814 (vl_api_ipfix_exporter_details_t * mp)
19816 vat_main_t *vam = &vat_main;
19817 vat_json_node_t node;
19818 struct in_addr collector_address;
19819 struct in_addr src_address;
19821 vat_json_init_object (&node);
19822 clib_memcpy (&collector_address, &mp->collector_address,
19823 sizeof (collector_address));
19824 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19825 vat_json_object_add_uint (&node, "collector_port",
19826 ntohs (mp->collector_port));
19827 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19828 vat_json_object_add_ip4 (&node, "src_address", src_address);
19829 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19830 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19831 vat_json_object_add_uint (&node, "template_interval",
19832 ntohl (mp->template_interval));
19833 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19835 vat_json_print (vam->ofp, &node);
19836 vat_json_free (&node);
19838 vam->result_ready = 1;
19842 api_ipfix_exporter_dump (vat_main_t * vam)
19844 vl_api_ipfix_exporter_dump_t *mp;
19847 /* Construct the API message */
19848 M (IPFIX_EXPORTER_DUMP, mp);
19857 api_ipfix_classify_stream_dump (vat_main_t * vam)
19859 vl_api_ipfix_classify_stream_dump_t *mp;
19862 /* Construct the API message */
19863 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19874 vl_api_ipfix_classify_stream_details_t_handler
19875 (vl_api_ipfix_classify_stream_details_t * mp)
19877 vat_main_t *vam = &vat_main;
19878 print (vam->ofp, "domain_id %d, src_port %d",
19879 ntohl (mp->domain_id), ntohs (mp->src_port));
19881 vam->result_ready = 1;
19885 vl_api_ipfix_classify_stream_details_t_handler_json
19886 (vl_api_ipfix_classify_stream_details_t * mp)
19888 vat_main_t *vam = &vat_main;
19889 vat_json_node_t node;
19891 vat_json_init_object (&node);
19892 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19893 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19895 vat_json_print (vam->ofp, &node);
19896 vat_json_free (&node);
19898 vam->result_ready = 1;
19902 api_ipfix_classify_table_dump (vat_main_t * vam)
19904 vl_api_ipfix_classify_table_dump_t *mp;
19905 vl_api_control_ping_t *mp_ping;
19908 if (!vam->json_output)
19910 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19911 "transport_protocol");
19914 /* Construct the API message */
19915 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19920 /* Use a control ping for synchronization */
19921 MPING (CONTROL_PING, mp_ping);
19929 vl_api_ipfix_classify_table_details_t_handler
19930 (vl_api_ipfix_classify_table_details_t * mp)
19932 vat_main_t *vam = &vat_main;
19933 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19934 mp->transport_protocol);
19938 vl_api_ipfix_classify_table_details_t_handler_json
19939 (vl_api_ipfix_classify_table_details_t * mp)
19941 vat_json_node_t *node = NULL;
19942 vat_main_t *vam = &vat_main;
19944 if (VAT_JSON_ARRAY != vam->json_tree.type)
19946 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19947 vat_json_init_array (&vam->json_tree);
19950 node = vat_json_array_add (&vam->json_tree);
19951 vat_json_init_object (node);
19953 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19954 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19955 vat_json_object_add_uint (node, "transport_protocol",
19956 mp->transport_protocol);
19960 api_sw_interface_span_enable_disable (vat_main_t * vam)
19962 unformat_input_t *i = vam->input;
19963 vl_api_sw_interface_span_enable_disable_t *mp;
19964 u32 src_sw_if_index = ~0;
19965 u32 dst_sw_if_index = ~0;
19970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19973 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19975 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19979 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19981 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19983 else if (unformat (i, "disable"))
19985 else if (unformat (i, "rx"))
19987 else if (unformat (i, "tx"))
19989 else if (unformat (i, "both"))
19991 else if (unformat (i, "l2"))
19997 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19999 mp->sw_if_index_from = htonl (src_sw_if_index);
20000 mp->sw_if_index_to = htonl (dst_sw_if_index);
20010 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20013 vat_main_t *vam = &vat_main;
20014 u8 *sw_if_from_name = 0;
20015 u8 *sw_if_to_name = 0;
20016 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20017 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20018 char *states[] = { "none", "rx", "tx", "both" };
20022 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20024 if ((u32) p->value[0] == sw_if_index_from)
20026 sw_if_from_name = (u8 *)(p->key);
20030 if ((u32) p->value[0] == sw_if_index_to)
20032 sw_if_to_name = (u8 *)(p->key);
20033 if (sw_if_from_name)
20038 print (vam->ofp, "%20s => %20s (%s)",
20039 sw_if_from_name, sw_if_to_name, states[mp->state]);
20043 vl_api_sw_interface_span_details_t_handler_json
20044 (vl_api_sw_interface_span_details_t * mp)
20046 vat_main_t *vam = &vat_main;
20047 vat_json_node_t *node = NULL;
20048 u8 *sw_if_from_name = 0;
20049 u8 *sw_if_to_name = 0;
20050 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20051 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20055 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20057 if ((u32) p->value[0] == sw_if_index_from)
20059 sw_if_from_name = (u8 *)(p->key);
20063 if ((u32) p->value[0] == sw_if_index_to)
20065 sw_if_to_name = (u8 *)(p->key);
20066 if (sw_if_from_name)
20072 if (VAT_JSON_ARRAY != vam->json_tree.type)
20074 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20075 vat_json_init_array (&vam->json_tree);
20077 node = vat_json_array_add (&vam->json_tree);
20079 vat_json_init_object (node);
20080 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20081 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20082 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20083 if (0 != sw_if_to_name)
20085 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20087 vat_json_object_add_uint (node, "state", mp->state);
20091 api_sw_interface_span_dump (vat_main_t * vam)
20093 unformat_input_t *input = vam->input;
20094 vl_api_sw_interface_span_dump_t *mp;
20095 vl_api_control_ping_t *mp_ping;
20099 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20101 if (unformat (input, "l2"))
20107 M (SW_INTERFACE_SPAN_DUMP, mp);
20111 /* Use a control ping for synchronization */
20112 MPING (CONTROL_PING, mp_ping);
20120 api_pg_create_interface (vat_main_t * vam)
20122 unformat_input_t *input = vam->input;
20123 vl_api_pg_create_interface_t *mp;
20127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20129 if (unformat (input, "if_id %d", &if_id))
20136 errmsg ("missing pg interface index");
20140 /* Construct the API message */
20141 M (PG_CREATE_INTERFACE, mp);
20143 mp->interface_id = ntohl (if_id);
20151 api_pg_capture (vat_main_t * vam)
20153 unformat_input_t *input = vam->input;
20154 vl_api_pg_capture_t *mp;
20159 u8 pcap_file_set = 0;
20162 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20164 if (unformat (input, "if_id %d", &if_id))
20166 else if (unformat (input, "pcap %s", &pcap_file))
20168 else if (unformat (input, "count %d", &count))
20170 else if (unformat (input, "disable"))
20177 errmsg ("missing pg interface index");
20180 if (pcap_file_set > 0)
20182 if (vec_len (pcap_file) > 255)
20184 errmsg ("pcap file name is too long");
20189 u32 name_len = vec_len (pcap_file);
20190 /* Construct the API message */
20191 M (PG_CAPTURE, mp);
20193 mp->interface_id = ntohl (if_id);
20194 mp->is_enabled = enable;
20195 mp->count = ntohl (count);
20196 mp->pcap_name_length = ntohl (name_len);
20197 if (pcap_file_set != 0)
20199 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20201 vec_free (pcap_file);
20209 api_pg_enable_disable (vat_main_t * vam)
20211 unformat_input_t *input = vam->input;
20212 vl_api_pg_enable_disable_t *mp;
20215 u8 stream_name_set = 0;
20216 u8 *stream_name = 0;
20218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20220 if (unformat (input, "stream %s", &stream_name))
20221 stream_name_set = 1;
20222 else if (unformat (input, "disable"))
20228 if (stream_name_set > 0)
20230 if (vec_len (stream_name) > 255)
20232 errmsg ("stream name too long");
20237 u32 name_len = vec_len (stream_name);
20238 /* Construct the API message */
20239 M (PG_ENABLE_DISABLE, mp);
20241 mp->is_enabled = enable;
20242 if (stream_name_set != 0)
20244 mp->stream_name_length = ntohl (name_len);
20245 clib_memcpy (mp->stream_name, stream_name, name_len);
20247 vec_free (stream_name);
20255 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20257 unformat_input_t *input = vam->input;
20258 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20260 u16 *low_ports = 0;
20261 u16 *high_ports = 0;
20264 ip4_address_t ip4_addr;
20265 ip6_address_t ip6_addr;
20274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20276 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20282 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20287 else if (unformat (input, "vrf %d", &vrf_id))
20289 else if (unformat (input, "del"))
20291 else if (unformat (input, "port %d", &tmp))
20293 if (tmp == 0 || tmp > 65535)
20295 errmsg ("port %d out of range", tmp);
20299 this_hi = this_low + 1;
20300 vec_add1 (low_ports, this_low);
20301 vec_add1 (high_ports, this_hi);
20303 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20305 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20307 errmsg ("incorrect range parameters");
20311 /* Note: in debug CLI +1 is added to high before
20312 passing to real fn that does "the work"
20313 (ip_source_and_port_range_check_add_del).
20314 This fn is a wrapper around the binary API fn a
20315 control plane will call, which expects this increment
20316 to have occurred. Hence letting the binary API control
20317 plane fn do the increment for consistency between VAT
20318 and other control planes.
20321 vec_add1 (low_ports, this_low);
20322 vec_add1 (high_ports, this_hi);
20328 if (prefix_set == 0)
20330 errmsg ("<address>/<mask> not specified");
20336 errmsg ("VRF ID required, not specified");
20343 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20347 if (vec_len (low_ports) == 0)
20349 errmsg ("At least one port or port range required");
20353 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20355 mp->is_add = is_add;
20360 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20365 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20368 mp->mask_length = length;
20369 mp->number_of_ranges = vec_len (low_ports);
20371 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20372 vec_free (low_ports);
20374 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20375 vec_free (high_ports);
20377 mp->vrf_id = ntohl (vrf_id);
20385 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20387 unformat_input_t *input = vam->input;
20388 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20389 u32 sw_if_index = ~0;
20391 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20392 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20396 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20398 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20400 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20402 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20404 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20406 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20408 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20410 else if (unformat (input, "del"))
20416 if (sw_if_index == ~0)
20418 errmsg ("Interface required but not specified");
20424 errmsg ("VRF ID required but not specified");
20428 if (tcp_out_vrf_id == 0
20429 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20432 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20436 /* Construct the API message */
20437 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20439 mp->sw_if_index = ntohl (sw_if_index);
20440 mp->is_add = is_add;
20441 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20442 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20443 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20444 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20449 /* Wait for a reply... */
20455 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20457 unformat_input_t *i = vam->input;
20458 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20459 u32 local_sa_id = 0;
20460 u32 remote_sa_id = 0;
20461 ip4_address_t src_address;
20462 ip4_address_t dst_address;
20466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20468 if (unformat (i, "local_sa %d", &local_sa_id))
20470 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20472 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20474 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20476 else if (unformat (i, "del"))
20480 clib_warning ("parse error '%U'", format_unformat_error, i);
20485 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20487 mp->local_sa_id = ntohl (local_sa_id);
20488 mp->remote_sa_id = ntohl (remote_sa_id);
20489 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20490 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20491 mp->is_add = is_add;
20499 api_punt (vat_main_t * vam)
20501 unformat_input_t *i = vam->input;
20509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20511 if (unformat (i, "ip %d", &ipv))
20513 else if (unformat (i, "protocol %d", &protocol))
20515 else if (unformat (i, "port %d", &port))
20517 else if (unformat (i, "del"))
20521 clib_warning ("parse error '%U'", format_unformat_error, i);
20528 mp->is_add = (u8) is_add;
20529 mp->ipv = (u8) ipv;
20530 mp->l4_protocol = (u8) protocol;
20531 mp->l4_port = htons ((u16) port);
20538 static void vl_api_ipsec_gre_tunnel_details_t_handler
20539 (vl_api_ipsec_gre_tunnel_details_t * mp)
20541 vat_main_t *vam = &vat_main;
20543 print (vam->ofp, "%11d%15U%15U%14d%14d",
20544 ntohl (mp->sw_if_index),
20545 format_ip4_address, &mp->src_address,
20546 format_ip4_address, &mp->dst_address,
20547 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20550 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20551 (vl_api_ipsec_gre_tunnel_details_t * mp)
20553 vat_main_t *vam = &vat_main;
20554 vat_json_node_t *node = NULL;
20555 struct in_addr ip4;
20557 if (VAT_JSON_ARRAY != vam->json_tree.type)
20559 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20560 vat_json_init_array (&vam->json_tree);
20562 node = vat_json_array_add (&vam->json_tree);
20564 vat_json_init_object (node);
20565 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20566 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20567 vat_json_object_add_ip4 (node, "src_address", ip4);
20568 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20569 vat_json_object_add_ip4 (node, "dst_address", ip4);
20570 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20571 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20575 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20577 unformat_input_t *i = vam->input;
20578 vl_api_ipsec_gre_tunnel_dump_t *mp;
20579 vl_api_control_ping_t *mp_ping;
20581 u8 sw_if_index_set = 0;
20584 /* Parse args required to build the message */
20585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20587 if (unformat (i, "sw_if_index %d", &sw_if_index))
20588 sw_if_index_set = 1;
20593 if (sw_if_index_set == 0)
20598 if (!vam->json_output)
20600 print (vam->ofp, "%11s%15s%15s%14s%14s",
20601 "sw_if_index", "src_address", "dst_address",
20602 "local_sa_id", "remote_sa_id");
20605 /* Get list of gre-tunnel interfaces */
20606 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20608 mp->sw_if_index = htonl (sw_if_index);
20612 /* Use a control ping for synchronization */
20613 MPING (CONTROL_PING, mp_ping);
20621 api_delete_subif (vat_main_t * vam)
20623 unformat_input_t *i = vam->input;
20624 vl_api_delete_subif_t *mp;
20625 u32 sw_if_index = ~0;
20628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20630 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20632 if (unformat (i, "sw_if_index %d", &sw_if_index))
20638 if (sw_if_index == ~0)
20640 errmsg ("missing sw_if_index");
20644 /* Construct the API message */
20645 M (DELETE_SUBIF, mp);
20646 mp->sw_if_index = ntohl (sw_if_index);
20653 #define foreach_pbb_vtr_op \
20654 _("disable", L2_VTR_DISABLED) \
20655 _("pop", L2_VTR_POP_2) \
20656 _("push", L2_VTR_PUSH_2)
20659 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20661 unformat_input_t *i = vam->input;
20662 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20663 u32 sw_if_index = ~0, vtr_op = ~0;
20664 u16 outer_tag = ~0;
20665 u8 dmac[6], smac[6];
20666 u8 dmac_set = 0, smac_set = 0;
20672 /* Shut up coverity */
20673 memset (dmac, 0, sizeof (dmac));
20674 memset (smac, 0, sizeof (smac));
20676 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20678 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20680 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20682 else if (unformat (i, "vtr_op %d", &vtr_op))
20684 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20687 else if (unformat (i, "translate_pbb_stag"))
20689 if (unformat (i, "%d", &tmp))
20691 vtr_op = L2_VTR_TRANSLATE_2_1;
20697 ("translate_pbb_stag operation requires outer tag definition");
20701 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20703 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20705 else if (unformat (i, "sid %d", &sid))
20707 else if (unformat (i, "vlanid %d", &tmp))
20711 clib_warning ("parse error '%U'", format_unformat_error, i);
20716 if ((sw_if_index == ~0) || (vtr_op == ~0))
20718 errmsg ("missing sw_if_index or vtr operation");
20721 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20722 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20725 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20729 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20730 mp->sw_if_index = ntohl (sw_if_index);
20731 mp->vtr_op = ntohl (vtr_op);
20732 mp->outer_tag = ntohs (outer_tag);
20733 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20734 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20735 mp->b_vlanid = ntohs (vlanid);
20736 mp->i_sid = ntohl (sid);
20744 api_flow_classify_set_interface (vat_main_t * vam)
20746 unformat_input_t *i = vam->input;
20747 vl_api_flow_classify_set_interface_t *mp;
20749 int sw_if_index_set;
20750 u32 ip4_table_index = ~0;
20751 u32 ip6_table_index = ~0;
20755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20757 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20758 sw_if_index_set = 1;
20759 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20760 sw_if_index_set = 1;
20761 else if (unformat (i, "del"))
20763 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20765 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20769 clib_warning ("parse error '%U'", format_unformat_error, i);
20774 if (sw_if_index_set == 0)
20776 errmsg ("missing interface name or sw_if_index");
20780 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20782 mp->sw_if_index = ntohl (sw_if_index);
20783 mp->ip4_table_index = ntohl (ip4_table_index);
20784 mp->ip6_table_index = ntohl (ip6_table_index);
20785 mp->is_add = is_add;
20793 api_flow_classify_dump (vat_main_t * vam)
20795 unformat_input_t *i = vam->input;
20796 vl_api_flow_classify_dump_t *mp;
20797 vl_api_control_ping_t *mp_ping;
20798 u8 type = FLOW_CLASSIFY_N_TABLES;
20801 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20805 errmsg ("classify table type must be specified");
20809 if (!vam->json_output)
20811 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20814 M (FLOW_CLASSIFY_DUMP, mp);
20819 /* Use a control ping for synchronization */
20820 MPING (CONTROL_PING, mp_ping);
20823 /* Wait for a reply... */
20829 api_feature_enable_disable (vat_main_t * vam)
20831 unformat_input_t *i = vam->input;
20832 vl_api_feature_enable_disable_t *mp;
20834 u8 *feature_name = 0;
20835 u32 sw_if_index = ~0;
20839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20841 if (unformat (i, "arc_name %s", &arc_name))
20843 else if (unformat (i, "feature_name %s", &feature_name))
20846 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20848 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20850 else if (unformat (i, "disable"))
20858 errmsg ("missing arc name");
20861 if (vec_len (arc_name) > 63)
20863 errmsg ("arc name too long");
20866 if (feature_name == 0)
20868 errmsg ("missing feature name");
20871 if (vec_len (feature_name) > 63)
20873 errmsg ("feature name too long");
20876 if (sw_if_index == ~0)
20878 errmsg ("missing interface name or sw_if_index");
20882 /* Construct the API message */
20883 M (FEATURE_ENABLE_DISABLE, mp);
20884 mp->sw_if_index = ntohl (sw_if_index);
20885 mp->enable = enable;
20886 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20887 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20888 vec_free (arc_name);
20889 vec_free (feature_name);
20897 api_sw_interface_tag_add_del (vat_main_t * vam)
20899 unformat_input_t *i = vam->input;
20900 vl_api_sw_interface_tag_add_del_t *mp;
20901 u32 sw_if_index = ~0;
20906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20908 if (unformat (i, "tag %s", &tag))
20910 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20912 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20914 else if (unformat (i, "del"))
20920 if (sw_if_index == ~0)
20922 errmsg ("missing interface name or sw_if_index");
20926 if (enable && (tag == 0))
20928 errmsg ("no tag specified");
20932 /* Construct the API message */
20933 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20934 mp->sw_if_index = ntohl (sw_if_index);
20935 mp->is_add = enable;
20937 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20945 static void vl_api_l2_xconnect_details_t_handler
20946 (vl_api_l2_xconnect_details_t * mp)
20948 vat_main_t *vam = &vat_main;
20950 print (vam->ofp, "%15d%15d",
20951 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20954 static void vl_api_l2_xconnect_details_t_handler_json
20955 (vl_api_l2_xconnect_details_t * mp)
20957 vat_main_t *vam = &vat_main;
20958 vat_json_node_t *node = NULL;
20960 if (VAT_JSON_ARRAY != vam->json_tree.type)
20962 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20963 vat_json_init_array (&vam->json_tree);
20965 node = vat_json_array_add (&vam->json_tree);
20967 vat_json_init_object (node);
20968 vat_json_object_add_uint (node, "rx_sw_if_index",
20969 ntohl (mp->rx_sw_if_index));
20970 vat_json_object_add_uint (node, "tx_sw_if_index",
20971 ntohl (mp->tx_sw_if_index));
20975 api_l2_xconnect_dump (vat_main_t * vam)
20977 vl_api_l2_xconnect_dump_t *mp;
20978 vl_api_control_ping_t *mp_ping;
20981 if (!vam->json_output)
20983 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20986 M (L2_XCONNECT_DUMP, mp);
20990 /* Use a control ping for synchronization */
20991 MPING (CONTROL_PING, mp_ping);
20999 api_sw_interface_set_mtu (vat_main_t * vam)
21001 unformat_input_t *i = vam->input;
21002 vl_api_sw_interface_set_mtu_t *mp;
21003 u32 sw_if_index = ~0;
21007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21009 if (unformat (i, "mtu %d", &mtu))
21011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21013 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21019 if (sw_if_index == ~0)
21021 errmsg ("missing interface name or sw_if_index");
21027 errmsg ("no mtu specified");
21031 /* Construct the API message */
21032 M (SW_INTERFACE_SET_MTU, mp);
21033 mp->sw_if_index = ntohl (sw_if_index);
21034 mp->mtu = ntohs ((u16) mtu);
21042 api_p2p_ethernet_add (vat_main_t * vam)
21044 unformat_input_t *i = vam->input;
21045 vl_api_p2p_ethernet_add_t *mp;
21046 u32 parent_if_index = ~0;
21052 memset (remote_mac, 0, sizeof (remote_mac));
21053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21055 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21057 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21061 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21063 else if (unformat (i, "sub_id %d", &sub_id))
21067 clib_warning ("parse error '%U'", format_unformat_error, i);
21072 if (parent_if_index == ~0)
21074 errmsg ("missing interface name or sw_if_index");
21079 errmsg ("missing remote mac address");
21084 errmsg ("missing sub-interface id");
21088 M (P2P_ETHERNET_ADD, mp);
21089 mp->parent_if_index = ntohl (parent_if_index);
21090 mp->subif_id = ntohl (sub_id);
21091 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21099 api_p2p_ethernet_del (vat_main_t * vam)
21101 unformat_input_t *i = vam->input;
21102 vl_api_p2p_ethernet_del_t *mp;
21103 u32 parent_if_index = ~0;
21108 memset (remote_mac, 0, sizeof (remote_mac));
21109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21111 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21113 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21117 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21121 clib_warning ("parse error '%U'", format_unformat_error, i);
21126 if (parent_if_index == ~0)
21128 errmsg ("missing interface name or sw_if_index");
21133 errmsg ("missing remote mac address");
21137 M (P2P_ETHERNET_DEL, mp);
21138 mp->parent_if_index = ntohl (parent_if_index);
21139 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21147 api_lldp_config (vat_main_t * vam)
21149 unformat_input_t *i = vam->input;
21150 vl_api_lldp_config_t *mp;
21152 int tx_interval = 0;
21153 u8 *sys_name = NULL;
21156 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21158 if (unformat (i, "system-name %s", &sys_name))
21160 else if (unformat (i, "tx-hold %d", &tx_hold))
21162 else if (unformat (i, "tx-interval %d", &tx_interval))
21166 clib_warning ("parse error '%U'", format_unformat_error, i);
21171 vec_add1 (sys_name, 0);
21173 M (LLDP_CONFIG, mp);
21174 mp->tx_hold = htonl (tx_hold);
21175 mp->tx_interval = htonl (tx_interval);
21176 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21177 vec_free (sys_name);
21185 api_sw_interface_set_lldp (vat_main_t * vam)
21187 unformat_input_t *i = vam->input;
21188 vl_api_sw_interface_set_lldp_t *mp;
21189 u32 sw_if_index = ~0;
21191 u8 *port_desc = NULL, *mgmt_oid = NULL;
21192 ip4_address_t ip4_addr;
21193 ip6_address_t ip6_addr;
21196 memset (&ip4_addr, 0, sizeof (ip4_addr));
21197 memset (&ip6_addr, 0, sizeof (ip6_addr));
21199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21201 if (unformat (i, "disable"))
21204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21208 else if (unformat (i, "port-desc %s", &port_desc))
21210 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21212 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21214 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21220 if (sw_if_index == ~0)
21222 errmsg ("missing interface name or sw_if_index");
21226 /* Construct the API message */
21227 vec_add1 (port_desc, 0);
21228 vec_add1 (mgmt_oid, 0);
21229 M (SW_INTERFACE_SET_LLDP, mp);
21230 mp->sw_if_index = ntohl (sw_if_index);
21231 mp->enable = enable;
21232 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21233 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21234 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21235 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21236 vec_free (port_desc);
21237 vec_free (mgmt_oid);
21245 api_tcp_configure_src_addresses (vat_main_t * vam)
21247 vl_api_tcp_configure_src_addresses_t *mp;
21248 unformat_input_t *i = vam->input;
21249 ip4_address_t v4first, v4last;
21250 ip6_address_t v6first, v6last;
21255 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21257 if (unformat (i, "%U - %U",
21258 unformat_ip4_address, &v4first,
21259 unformat_ip4_address, &v4last))
21263 errmsg ("one range per message (range already set)");
21268 else if (unformat (i, "%U - %U",
21269 unformat_ip6_address, &v6first,
21270 unformat_ip6_address, &v6last))
21274 errmsg ("one range per message (range already set)");
21279 else if (unformat (i, "vrf %d", &vrf_id))
21285 if (range_set == 0)
21287 errmsg ("address range not set");
21291 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21292 mp->vrf_id = ntohl (vrf_id);
21294 if (range_set == 2)
21297 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21298 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21303 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21304 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21312 api_app_namespace_add_del (vat_main_t * vam)
21314 vl_api_app_namespace_add_del_t *mp;
21315 unformat_input_t *i = vam->input;
21316 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21317 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21321 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21323 if (unformat (i, "id %_%v%_", &ns_id))
21325 else if (unformat (i, "secret %lu", &secret))
21327 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21328 sw_if_index_set = 1;
21329 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21331 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21336 if (!ns_id || !secret_set || !sw_if_index_set)
21338 errmsg ("namespace id, secret and sw_if_index must be set");
21341 if (vec_len (ns_id) > 64)
21343 errmsg ("namespace id too long");
21346 M (APP_NAMESPACE_ADD_DEL, mp);
21348 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21349 mp->namespace_id_len = vec_len (ns_id);
21350 mp->secret = clib_host_to_net_u64 (secret);
21351 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21352 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21353 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21361 api_memfd_segment_create (vat_main_t * vam)
21363 #if VPP_API_TEST_BUILTIN == 0
21364 unformat_input_t *i = vam->input;
21365 vl_api_memfd_segment_create_t *mp;
21366 u64 size = 64 << 20;
21369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21371 if (unformat (i, "size %U", unformat_memory_size, &size))
21377 M (MEMFD_SEGMENT_CREATE, mp);
21378 mp->requested_size = size;
21384 errmsg ("memfd_segment_create (builtin) not supported");
21390 api_dns_enable_disable (vat_main_t * vam)
21392 unformat_input_t *line_input = vam->input;
21393 vl_api_dns_enable_disable_t *mp;
21394 u8 enable_disable = 1;
21397 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21399 if (unformat (line_input, "disable"))
21400 enable_disable = 0;
21401 if (unformat (line_input, "enable"))
21402 enable_disable = 1;
21407 /* Construct the API message */
21408 M (DNS_ENABLE_DISABLE, mp);
21409 mp->enable = enable_disable;
21413 /* Wait for the reply */
21419 api_dns_resolve_name (vat_main_t * vam)
21421 unformat_input_t *line_input = vam->input;
21422 vl_api_dns_resolve_name_t *mp;
21426 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21428 if (unformat (line_input, "%s", &name))
21434 if (vec_len (name) > 127)
21436 errmsg ("name too long");
21440 /* Construct the API message */
21441 M (DNS_RESOLVE_NAME, mp);
21442 memcpy (mp->name, name, vec_len (name));
21447 /* Wait for the reply */
21453 api_dns_resolve_ip (vat_main_t * vam)
21455 unformat_input_t *line_input = vam->input;
21456 vl_api_dns_resolve_ip_t *mp;
21458 ip4_address_t addr4;
21459 ip6_address_t addr6;
21462 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21464 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21466 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21474 errmsg ("missing address");
21478 /* Construct the API message */
21479 M (DNS_RESOLVE_IP, mp);
21480 mp->is_ip6 = is_ip6;
21482 memcpy (mp->address, &addr6, sizeof (addr6));
21484 memcpy (mp->address, &addr4, sizeof (addr4));
21488 /* Wait for the reply */
21494 api_dns_name_server_add_del (vat_main_t * vam)
21496 unformat_input_t *i = vam->input;
21497 vl_api_dns_name_server_add_del_t *mp;
21499 ip6_address_t ip6_server;
21500 ip4_address_t ip4_server;
21505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21507 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21509 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21511 else if (unformat (i, "del"))
21515 clib_warning ("parse error '%U'", format_unformat_error, i);
21520 if (ip4_set && ip6_set)
21522 errmsg ("Only one server address allowed per message");
21525 if ((ip4_set + ip6_set) == 0)
21527 errmsg ("Server address required");
21531 /* Construct the API message */
21532 M (DNS_NAME_SERVER_ADD_DEL, mp);
21536 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21541 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21545 mp->is_add = is_add;
21550 /* Wait for a reply, return good/bad news */
21556 api_session_rule_add_del (vat_main_t * vam)
21558 vl_api_session_rule_add_del_t *mp;
21559 unformat_input_t *i = vam->input;
21560 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21561 u32 appns_index = 0, scope = 0;
21562 ip4_address_t lcl_ip4, rmt_ip4;
21563 ip6_address_t lcl_ip6, rmt_ip6;
21564 u8 is_ip4 = 1, conn_set = 0;
21568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21570 if (unformat (i, "del"))
21572 else if (unformat (i, "add"))
21574 else if (unformat (i, "proto tcp"))
21576 else if (unformat (i, "proto udp"))
21578 else if (unformat (i, "appns %d", &appns_index))
21580 else if (unformat (i, "scope %d", &scope))
21584 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21585 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21593 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21594 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21600 else if (unformat (i, "action %d", &action))
21605 if (proto == ~0 || !conn_set || action == ~0)
21607 errmsg ("transport proto, connection and action must be set");
21613 errmsg ("scope should be 0-3");
21617 M (SESSION_RULE_ADD_DEL, mp);
21619 mp->is_ip4 = is_ip4;
21620 mp->transport_proto = proto;
21621 mp->lcl_plen = clib_host_to_net_u16 (lcl_plen);
21622 mp->rmt_plen = clib_host_to_net_u16 (rmt_plen);
21623 mp->action_index = clib_host_to_net_u32 (action);
21624 mp->appns_index = clib_host_to_net_u32 (appns_index);
21626 mp->is_add = is_add;
21629 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21630 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21634 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21635 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21644 q_or_quit (vat_main_t * vam)
21646 #if VPP_API_TEST_BUILTIN == 0
21647 longjmp (vam->jump_buf, 1);
21649 return 0; /* not so much */
21653 q (vat_main_t * vam)
21655 return q_or_quit (vam);
21659 quit (vat_main_t * vam)
21661 return q_or_quit (vam);
21665 comment (vat_main_t * vam)
21671 cmd_cmp (void *a1, void *a2)
21676 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21680 help (vat_main_t * vam)
21685 unformat_input_t *i = vam->input;
21688 if (unformat (i, "%s", &name))
21692 vec_add1 (name, 0);
21694 hs = hash_get_mem (vam->help_by_name, name);
21696 print (vam->ofp, "usage: %s %s", name, hs[0]);
21698 print (vam->ofp, "No such msg / command '%s'", name);
21703 print (vam->ofp, "Help is available for the following:");
21706 hash_foreach_pair (p, vam->function_by_name,
21708 vec_add1 (cmds, (u8 *)(p->key));
21712 vec_sort_with_function (cmds, cmd_cmp);
21714 for (j = 0; j < vec_len (cmds); j++)
21715 print (vam->ofp, "%s", cmds[j]);
21722 set (vat_main_t * vam)
21724 u8 *name = 0, *value = 0;
21725 unformat_input_t *i = vam->input;
21727 if (unformat (i, "%s", &name))
21729 /* The input buffer is a vector, not a string. */
21730 value = vec_dup (i->buffer);
21731 vec_delete (value, i->index, 0);
21732 /* Almost certainly has a trailing newline */
21733 if (value[vec_len (value) - 1] == '\n')
21734 value[vec_len (value) - 1] = 0;
21735 /* Make sure it's a proper string, one way or the other */
21736 vec_add1 (value, 0);
21737 (void) clib_macro_set_value (&vam->macro_main,
21738 (char *) name, (char *) value);
21741 errmsg ("usage: set <name> <value>");
21749 unset (vat_main_t * vam)
21753 if (unformat (vam->input, "%s", &name))
21754 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21755 errmsg ("unset: %s wasn't set", name);
21768 macro_sort_cmp (void *a1, void *a2)
21770 macro_sort_t *s1 = a1;
21771 macro_sort_t *s2 = a2;
21773 return strcmp ((char *) (s1->name), (char *) (s2->name));
21777 dump_macro_table (vat_main_t * vam)
21779 macro_sort_t *sort_me = 0, *sm;
21784 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21786 vec_add2 (sort_me, sm, 1);
21787 sm->name = (u8 *)(p->key);
21788 sm->value = (u8 *) (p->value[0]);
21792 vec_sort_with_function (sort_me, macro_sort_cmp);
21794 if (vec_len (sort_me))
21795 print (vam->ofp, "%-15s%s", "Name", "Value");
21797 print (vam->ofp, "The macro table is empty...");
21799 for (i = 0; i < vec_len (sort_me); i++)
21800 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21805 dump_node_table (vat_main_t * vam)
21808 vlib_node_t *node, *next_node;
21810 if (vec_len (vam->graph_nodes) == 0)
21812 print (vam->ofp, "Node table empty, issue get_node_graph...");
21816 for (i = 0; i < vec_len (vam->graph_nodes); i++)
21818 node = vam->graph_nodes[i];
21819 print (vam->ofp, "[%d] %s", i, node->name);
21820 for (j = 0; j < vec_len (node->next_nodes); j++)
21822 if (node->next_nodes[j] != ~0)
21824 next_node = vam->graph_nodes[node->next_nodes[j]];
21825 print (vam->ofp, " [%d] %s", j, next_node->name);
21833 value_sort_cmp (void *a1, void *a2)
21835 name_sort_t *n1 = a1;
21836 name_sort_t *n2 = a2;
21838 if (n1->value < n2->value)
21840 if (n1->value > n2->value)
21847 dump_msg_api_table (vat_main_t * vam)
21849 api_main_t *am = &api_main;
21850 name_sort_t *nses = 0, *ns;
21855 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21857 vec_add2 (nses, ns, 1);
21858 ns->name = (u8 *)(hp->key);
21859 ns->value = (u32) hp->value[0];
21863 vec_sort_with_function (nses, value_sort_cmp);
21865 for (i = 0; i < vec_len (nses); i++)
21866 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21872 get_msg_id (vat_main_t * vam)
21877 if (unformat (vam->input, "%s", &name_and_crc))
21879 message_index = vl_api_get_msg_index (name_and_crc);
21880 if (message_index == ~0)
21882 print (vam->ofp, " '%s' not found", name_and_crc);
21885 print (vam->ofp, " '%s' has message index %d",
21886 name_and_crc, message_index);
21889 errmsg ("name_and_crc required...");
21894 search_node_table (vat_main_t * vam)
21896 unformat_input_t *line_input = vam->input;
21899 vlib_node_t *node, *next_node;
21902 if (vam->graph_node_index_by_name == 0)
21904 print (vam->ofp, "Node table empty, issue get_node_graph...");
21908 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21910 if (unformat (line_input, "%s", &node_to_find))
21912 vec_add1 (node_to_find, 0);
21913 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21916 print (vam->ofp, "%s not found...", node_to_find);
21919 node = vam->graph_nodes[p[0]];
21920 print (vam->ofp, "[%d] %s", p[0], node->name);
21921 for (j = 0; j < vec_len (node->next_nodes); j++)
21923 if (node->next_nodes[j] != ~0)
21925 next_node = vam->graph_nodes[node->next_nodes[j]];
21926 print (vam->ofp, " [%d] %s", j, next_node->name);
21933 clib_warning ("parse error '%U'", format_unformat_error,
21939 vec_free (node_to_find);
21948 script (vat_main_t * vam)
21950 #if (VPP_API_TEST_BUILTIN==0)
21952 char *save_current_file;
21953 unformat_input_t save_input;
21954 jmp_buf save_jump_buf;
21955 u32 save_line_number;
21957 FILE *new_fp, *save_ifp;
21959 if (unformat (vam->input, "%s", &s))
21961 new_fp = fopen ((char *) s, "r");
21964 errmsg ("Couldn't open script file %s", s);
21971 errmsg ("Missing script name");
21975 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21976 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21977 save_ifp = vam->ifp;
21978 save_line_number = vam->input_line_number;
21979 save_current_file = (char *) vam->current_file;
21981 vam->input_line_number = 0;
21983 vam->current_file = s;
21986 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
21987 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21988 vam->ifp = save_ifp;
21989 vam->input_line_number = save_line_number;
21990 vam->current_file = (u8 *) save_current_file;
21995 clib_warning ("use the exec command...");
22001 echo (vat_main_t * vam)
22003 print (vam->ofp, "%v", vam->input->buffer);
22007 /* List of API message constructors, CLI names map to api_xxx */
22008 #define foreach_vpe_api_msg \
22009 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22010 _(sw_interface_dump,"") \
22011 _(sw_interface_set_flags, \
22012 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22013 _(sw_interface_add_del_address, \
22014 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22015 _(sw_interface_set_rx_mode, \
22016 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22017 _(sw_interface_set_table, \
22018 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22019 _(sw_interface_set_mpls_enable, \
22020 "<intfc> | sw_if_index [disable | dis]") \
22021 _(sw_interface_set_vpath, \
22022 "<intfc> | sw_if_index <id> enable | disable") \
22023 _(sw_interface_set_vxlan_bypass, \
22024 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22025 _(sw_interface_set_geneve_bypass, \
22026 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22027 _(sw_interface_set_l2_xconnect, \
22028 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22029 "enable | disable") \
22030 _(sw_interface_set_l2_bridge, \
22031 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22032 "[shg <split-horizon-group>] [bvi]\n" \
22033 "enable | disable") \
22034 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22035 _(bridge_domain_add_del, \
22036 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [mac-age 0-255] [bd-tag <tag>] [del]\n") \
22037 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22039 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22040 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22041 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22043 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22045 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22047 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22049 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22051 "<vpp-if-name> | sw_if_index <id>") \
22052 _(sw_interface_tap_dump, "") \
22053 _(ip_table_add_del, \
22054 "table-id <n> [ipv6]\n") \
22055 _(ip_add_del_route, \
22056 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22057 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22058 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22059 "[multipath] [count <n>]") \
22060 _(ip_mroute_add_del, \
22061 "<src> <grp>/<mask> [table-id <n>]\n" \
22062 "[<intfc> | sw_if_index <id>] [local] [del]") \
22063 _(mpls_table_add_del, \
22064 "table-id <n>\n") \
22065 _(mpls_route_add_del, \
22066 "<label> <eos> via <addr> [table-id <n>]\n" \
22067 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22068 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22069 "[multipath] [count <n>]") \
22070 _(mpls_ip_bind_unbind, \
22071 "<label> <addr/len>") \
22072 _(mpls_tunnel_add_del, \
22073 " via <addr> [table-id <n>]\n" \
22074 "sw_if_index <id>] [l2] [del]") \
22075 _(proxy_arp_add_del, \
22076 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22077 _(proxy_arp_intfc_enable_disable, \
22078 "<intfc> | sw_if_index <id> enable | disable") \
22079 _(sw_interface_set_unnumbered, \
22080 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22081 _(ip_neighbor_add_del, \
22082 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22083 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22084 _(reset_vrf, "vrf <id> [ipv6]") \
22085 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22086 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22087 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22088 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22089 "[outer_vlan_id_any][inner_vlan_id_any]") \
22090 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22091 _(reset_fib, "vrf <n> [ipv6]") \
22092 _(dhcp_proxy_config, \
22093 "svr <v46-address> src <v46-address>\n" \
22094 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22095 _(dhcp_proxy_set_vss, \
22096 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
22097 _(dhcp_proxy_dump, "ip6") \
22098 _(dhcp_client_config, \
22099 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22100 _(set_ip_flow_hash, \
22101 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22102 _(sw_interface_ip6_enable_disable, \
22103 "<intfc> | sw_if_index <id> enable | disable") \
22104 _(sw_interface_ip6_set_link_local_address, \
22105 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22106 _(ip6nd_proxy_add_del, \
22107 "<intfc> | sw_if_index <id> <ip6-address>") \
22108 _(ip6nd_proxy_dump, "") \
22109 _(sw_interface_ip6nd_ra_prefix, \
22110 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22111 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22112 "[nolink] [isno]") \
22113 _(sw_interface_ip6nd_ra_config, \
22114 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22115 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22116 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22117 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22118 _(l2_patch_add_del, \
22119 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22120 "enable | disable") \
22121 _(sr_localsid_add_del, \
22122 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22123 "fib-table <num> (end.psp) sw_if_index <num>") \
22124 _(classify_add_del_table, \
22125 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22126 " [del] [del-chain] mask <mask-value>\n" \
22127 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22128 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22129 _(classify_add_del_session, \
22130 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22131 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22132 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22133 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22134 _(classify_set_interface_ip_table, \
22135 "<intfc> | sw_if_index <nn> table <nn>") \
22136 _(classify_set_interface_l2_tables, \
22137 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22138 " [other-table <nn>]") \
22139 _(get_node_index, "node <node-name") \
22140 _(add_node_next, "node <node-name> next <next-node-name>") \
22141 _(l2tpv3_create_tunnel, \
22142 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22143 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22144 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22145 _(l2tpv3_set_tunnel_cookies, \
22146 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22147 "[new_remote_cookie <nn>]\n") \
22148 _(l2tpv3_interface_enable_disable, \
22149 "<intfc> | sw_if_index <nn> enable | disable") \
22150 _(l2tpv3_set_lookup_key, \
22151 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22152 _(sw_if_l2tpv3_tunnel_dump, "") \
22153 _(vxlan_add_del_tunnel, \
22154 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22155 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22156 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22157 _(geneve_add_del_tunnel, \
22158 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22159 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22160 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22161 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22162 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22163 _(gre_add_del_tunnel, \
22164 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22165 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22166 _(l2_fib_clear_table, "") \
22167 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22168 _(l2_interface_vlan_tag_rewrite, \
22169 "<intfc> | sw_if_index <nn> \n" \
22170 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22171 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22172 _(create_vhost_user_if, \
22173 "socket <filename> [server] [renumber <dev_instance>] " \
22174 "[mac <mac_address>]") \
22175 _(modify_vhost_user_if, \
22176 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22177 "[server] [renumber <dev_instance>]") \
22178 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22179 _(sw_interface_vhost_user_dump, "") \
22180 _(show_version, "") \
22181 _(vxlan_gpe_add_del_tunnel, \
22182 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22183 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22184 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22185 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22186 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22187 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22188 _(interface_name_renumber, \
22189 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22190 _(input_acl_set_interface, \
22191 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22192 " [l2-table <nn>] [del]") \
22193 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22194 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22195 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22196 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22197 _(ip_dump, "ipv4 | ipv6") \
22198 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22199 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22201 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22202 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22203 " integ_alg <alg> integ_key <hex>") \
22204 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22205 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22206 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22207 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22208 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22209 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22210 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22211 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22212 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22213 _(ipsec_sa_dump, "[sa_id <n>]") \
22214 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22215 " <alg> <hex>\n") \
22216 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22217 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22218 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22219 "(auth_data 0x<data> | auth_data <data>)") \
22220 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22221 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22222 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22223 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22224 "(local|remote)") \
22225 _(ikev2_set_local_key, "file <absolute_file_path>") \
22226 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22227 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22228 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22229 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22230 _(ikev2_initiate_sa_init, "<profile_name>") \
22231 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22232 _(ikev2_initiate_del_child_sa, "<ispi>") \
22233 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22234 _(delete_loopback,"sw_if_index <nn>") \
22235 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22236 _(map_add_domain, \
22237 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22238 "ip6-src <ip6addr> " \
22239 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22240 _(map_del_domain, "index <n>") \
22241 _(map_add_del_rule, \
22242 "index <n> psid <n> dst <ip6addr> [del]") \
22243 _(map_domain_dump, "") \
22244 _(map_rule_dump, "index <map-domain>") \
22245 _(want_interface_events, "enable|disable") \
22246 _(want_stats,"enable|disable") \
22247 _(get_first_msg_id, "client <name>") \
22248 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22249 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22250 "fib-id <nn> [ip4][ip6][default]") \
22251 _(get_node_graph, " ") \
22252 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22253 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22254 _(ioam_disable, "") \
22255 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22256 " sw_if_index <sw_if_index> p <priority> " \
22257 "w <weight>] [del]") \
22258 _(one_add_del_locator, "locator-set <locator_name> " \
22259 "iface <intf> | sw_if_index <sw_if_index> " \
22260 "p <priority> w <weight> [del]") \
22261 _(one_add_del_local_eid,"vni <vni> eid " \
22262 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22263 "locator-set <locator_name> [del]" \
22264 "[key-id sha1|sha256 secret-key <secret-key>]")\
22265 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22266 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22267 _(one_enable_disable, "enable|disable") \
22268 _(one_map_register_enable_disable, "enable|disable") \
22269 _(one_map_register_fallback_threshold, "<value>") \
22270 _(one_rloc_probe_enable_disable, "enable|disable") \
22271 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22273 "rloc <locator> p <prio> " \
22274 "w <weight> [rloc <loc> ... ] " \
22275 "action <action> [del-all]") \
22276 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22278 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22279 _(one_use_petr, "ip-address> | disable") \
22280 _(one_map_request_mode, "src-dst|dst-only") \
22281 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22282 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22283 _(one_locator_set_dump, "[local | remote]") \
22284 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22285 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22286 "[local] | [remote]") \
22287 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22288 _(one_ndp_bd_get, "") \
22289 _(one_ndp_entries_get, "bd <bridge-domain>") \
22290 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22291 _(one_l2_arp_bd_get, "") \
22292 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22293 _(one_stats_enable_disable, "enable|disalbe") \
22294 _(show_one_stats_enable_disable, "") \
22295 _(one_eid_table_vni_dump, "") \
22296 _(one_eid_table_map_dump, "l2|l3") \
22297 _(one_map_resolver_dump, "") \
22298 _(one_map_server_dump, "") \
22299 _(one_adjacencies_get, "vni <vni>") \
22300 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22301 _(show_one_rloc_probe_state, "") \
22302 _(show_one_map_register_state, "") \
22303 _(show_one_status, "") \
22304 _(one_stats_dump, "") \
22305 _(one_stats_flush, "") \
22306 _(one_get_map_request_itr_rlocs, "") \
22307 _(one_map_register_set_ttl, "<ttl>") \
22308 _(one_set_transport_protocol, "udp|api") \
22309 _(one_get_transport_protocol, "") \
22310 _(one_enable_disable_xtr_mode, "enable|disable") \
22311 _(one_show_xtr_mode, "") \
22312 _(one_enable_disable_pitr_mode, "enable|disable") \
22313 _(one_show_pitr_mode, "") \
22314 _(one_enable_disable_petr_mode, "enable|disable") \
22315 _(one_show_petr_mode, "") \
22316 _(show_one_nsh_mapping, "") \
22317 _(show_one_pitr, "") \
22318 _(show_one_use_petr, "") \
22319 _(show_one_map_request_mode, "") \
22320 _(show_one_map_register_ttl, "") \
22321 _(show_one_map_register_fallback_threshold, "") \
22322 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22323 " sw_if_index <sw_if_index> p <priority> " \
22324 "w <weight>] [del]") \
22325 _(lisp_add_del_locator, "locator-set <locator_name> " \
22326 "iface <intf> | sw_if_index <sw_if_index> " \
22327 "p <priority> w <weight> [del]") \
22328 _(lisp_add_del_local_eid,"vni <vni> eid " \
22329 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22330 "locator-set <locator_name> [del]" \
22331 "[key-id sha1|sha256 secret-key <secret-key>]") \
22332 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22333 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22334 _(lisp_enable_disable, "enable|disable") \
22335 _(lisp_map_register_enable_disable, "enable|disable") \
22336 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22337 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22339 "rloc <locator> p <prio> " \
22340 "w <weight> [rloc <loc> ... ] " \
22341 "action <action> [del-all]") \
22342 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22344 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22345 _(lisp_use_petr, "<ip-address> | disable") \
22346 _(lisp_map_request_mode, "src-dst|dst-only") \
22347 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22348 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22349 _(lisp_locator_set_dump, "[local | remote]") \
22350 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22351 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22352 "[local] | [remote]") \
22353 _(lisp_eid_table_vni_dump, "") \
22354 _(lisp_eid_table_map_dump, "l2|l3") \
22355 _(lisp_map_resolver_dump, "") \
22356 _(lisp_map_server_dump, "") \
22357 _(lisp_adjacencies_get, "vni <vni>") \
22358 _(gpe_fwd_entry_vnis_get, "") \
22359 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22360 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22361 "[table <table-id>]") \
22362 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22363 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22364 _(gpe_set_encap_mode, "lisp|vxlan") \
22365 _(gpe_get_encap_mode, "") \
22366 _(lisp_gpe_add_del_iface, "up|down") \
22367 _(lisp_gpe_enable_disable, "enable|disable") \
22368 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22369 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22370 _(show_lisp_rloc_probe_state, "") \
22371 _(show_lisp_map_register_state, "") \
22372 _(show_lisp_status, "") \
22373 _(lisp_get_map_request_itr_rlocs, "") \
22374 _(show_lisp_pitr, "") \
22375 _(show_lisp_use_petr, "") \
22376 _(show_lisp_map_request_mode, "") \
22377 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22378 _(af_packet_delete, "name <host interface name>") \
22379 _(policer_add_del, "name <policer name> <params> [del]") \
22380 _(policer_dump, "[name <policer name>]") \
22381 _(policer_classify_set_interface, \
22382 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22383 " [l2-table <nn>] [del]") \
22384 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22385 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22386 "[master|slave]") \
22387 _(netmap_delete, "name <interface name>") \
22388 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22389 _(mpls_fib_dump, "") \
22390 _(classify_table_ids, "") \
22391 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22392 _(classify_table_info, "table_id <nn>") \
22393 _(classify_session_dump, "table_id <nn>") \
22394 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22395 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22396 "[template_interval <nn>] [udp_checksum]") \
22397 _(ipfix_exporter_dump, "") \
22398 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22399 _(ipfix_classify_stream_dump, "") \
22400 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22401 _(ipfix_classify_table_dump, "") \
22402 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22403 _(sw_interface_span_dump, "[l2]") \
22404 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22405 _(pg_create_interface, "if_id <nn>") \
22406 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22407 _(pg_enable_disable, "[stream <id>] disable") \
22408 _(ip_source_and_port_range_check_add_del, \
22409 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22410 _(ip_source_and_port_range_check_interface_add_del, \
22411 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22412 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22413 _(ipsec_gre_add_del_tunnel, \
22414 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22415 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22416 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22417 _(l2_interface_pbb_tag_rewrite, \
22418 "<intfc> | sw_if_index <nn> \n" \
22419 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22420 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22421 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22422 _(flow_classify_set_interface, \
22423 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22424 _(flow_classify_dump, "type [ip4|ip6]") \
22425 _(ip_fib_dump, "") \
22426 _(ip_mfib_dump, "") \
22427 _(ip6_fib_dump, "") \
22428 _(ip6_mfib_dump, "") \
22429 _(feature_enable_disable, "arc_name <arc_name> " \
22430 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22431 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22433 _(l2_xconnect_dump, "") \
22434 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
22435 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22436 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22437 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22438 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22439 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22440 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22441 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22442 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22443 _(memfd_segment_create,"size <nnn>") \
22444 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22445 _(dns_enable_disable, "[enable][disable]") \
22446 _(dns_name_server_add_del, "<ip-address> [del]") \
22447 _(dns_resolve_name, "<hostname>") \
22448 _(dns_resolve_ip, "<ip4|ip6>") \
22449 _(dns_name_server_add_del, "<ip-address> [del]") \
22450 _(dns_resolve_name, "<hostname>") \
22451 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22452 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22454 /* List of command functions, CLI names map directly to functions */
22455 #define foreach_cli_function \
22456 _(comment, "usage: comment <ignore-rest-of-line>") \
22457 _(dump_interface_table, "usage: dump_interface_table") \
22458 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22459 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22460 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22461 _(dump_stats_table, "usage: dump_stats_table") \
22462 _(dump_macro_table, "usage: dump_macro_table ") \
22463 _(dump_node_table, "usage: dump_node_table") \
22464 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22465 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22466 _(echo, "usage: echo <message>") \
22467 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22468 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22469 _(help, "usage: help") \
22470 _(q, "usage: quit") \
22471 _(quit, "usage: quit") \
22472 _(search_node_table, "usage: search_node_table <name>...") \
22473 _(set, "usage: set <variable-name> <value>") \
22474 _(script, "usage: script <file-name>") \
22475 _(unset, "usage: unset <variable-name>")
22477 static void vl_api_##n##_t_handler_uni \
22478 (vl_api_##n##_t * mp) \
22480 vat_main_t * vam = &vat_main; \
22481 if (vam->json_output) { \
22482 vl_api_##n##_t_handler_json(mp); \
22484 vl_api_##n##_t_handler(mp); \
22487 foreach_vpe_api_reply_msg;
22488 #if VPP_API_TEST_BUILTIN == 0
22489 foreach_standalone_reply_msg;
22494 vat_api_hookup (vat_main_t * vam)
22497 vl_msg_api_set_handlers(VL_API_##N, #n, \
22498 vl_api_##n##_t_handler_uni, \
22500 vl_api_##n##_t_endian, \
22501 vl_api_##n##_t_print, \
22502 sizeof(vl_api_##n##_t), 1);
22503 foreach_vpe_api_reply_msg;
22504 #if VPP_API_TEST_BUILTIN == 0
22505 foreach_standalone_reply_msg;
22509 #if (VPP_API_TEST_BUILTIN==0)
22510 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22512 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22514 vam->function_by_name = hash_create_string (0, sizeof (uword));
22516 vam->help_by_name = hash_create_string (0, sizeof (uword));
22519 /* API messages we can send */
22520 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22521 foreach_vpe_api_msg;
22525 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22526 foreach_vpe_api_msg;
22529 /* CLI functions */
22530 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22531 foreach_cli_function;
22535 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22536 foreach_cli_function;
22540 #if VPP_API_TEST_BUILTIN
22541 static clib_error_t *
22542 vat_api_hookup_shim (vlib_main_t * vm)
22544 vat_api_hookup (&vat_main);
22548 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22552 * fd.io coding-style-patch-verification: ON
22555 * eval: (c-set-style "gnu")