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 _(bier_route_add_del_reply) \
5184 _(bier_table_add_del_reply) \
5185 _(proxy_arp_add_del_reply) \
5186 _(proxy_arp_intfc_enable_disable_reply) \
5187 _(sw_interface_set_unnumbered_reply) \
5188 _(ip_neighbor_add_del_reply) \
5189 _(reset_vrf_reply) \
5190 _(oam_add_del_reply) \
5191 _(reset_fib_reply) \
5192 _(dhcp_proxy_config_reply) \
5193 _(dhcp_proxy_set_vss_reply) \
5194 _(dhcp_client_config_reply) \
5195 _(set_ip_flow_hash_reply) \
5196 _(sw_interface_ip6_enable_disable_reply) \
5197 _(sw_interface_ip6_set_link_local_address_reply) \
5198 _(ip6nd_proxy_add_del_reply) \
5199 _(sw_interface_ip6nd_ra_prefix_reply) \
5200 _(sw_interface_ip6nd_ra_config_reply) \
5201 _(set_arp_neighbor_limit_reply) \
5202 _(l2_patch_add_del_reply) \
5203 _(sr_policy_add_reply) \
5204 _(sr_policy_mod_reply) \
5205 _(sr_policy_del_reply) \
5206 _(sr_localsid_add_del_reply) \
5207 _(sr_steering_add_del_reply) \
5208 _(classify_add_del_session_reply) \
5209 _(classify_set_interface_ip_table_reply) \
5210 _(classify_set_interface_l2_tables_reply) \
5211 _(l2tpv3_set_tunnel_cookies_reply) \
5212 _(l2tpv3_interface_enable_disable_reply) \
5213 _(l2tpv3_set_lookup_key_reply) \
5214 _(l2_fib_clear_table_reply) \
5215 _(l2_interface_efp_filter_reply) \
5216 _(l2_interface_vlan_tag_rewrite_reply) \
5217 _(modify_vhost_user_if_reply) \
5218 _(delete_vhost_user_if_reply) \
5219 _(want_ip4_arp_events_reply) \
5220 _(want_ip6_nd_events_reply) \
5221 _(want_l2_macs_events_reply) \
5222 _(input_acl_set_interface_reply) \
5223 _(ipsec_spd_add_del_reply) \
5224 _(ipsec_interface_add_del_spd_reply) \
5225 _(ipsec_spd_add_del_entry_reply) \
5226 _(ipsec_sad_add_del_entry_reply) \
5227 _(ipsec_sa_set_key_reply) \
5228 _(ipsec_tunnel_if_add_del_reply) \
5229 _(ipsec_tunnel_if_set_key_reply) \
5230 _(ipsec_tunnel_if_set_sa_reply) \
5231 _(ikev2_profile_add_del_reply) \
5232 _(ikev2_profile_set_auth_reply) \
5233 _(ikev2_profile_set_id_reply) \
5234 _(ikev2_profile_set_ts_reply) \
5235 _(ikev2_set_local_key_reply) \
5236 _(ikev2_set_responder_reply) \
5237 _(ikev2_set_ike_transforms_reply) \
5238 _(ikev2_set_esp_transforms_reply) \
5239 _(ikev2_set_sa_lifetime_reply) \
5240 _(ikev2_initiate_sa_init_reply) \
5241 _(ikev2_initiate_del_ike_sa_reply) \
5242 _(ikev2_initiate_del_child_sa_reply) \
5243 _(ikev2_initiate_rekey_child_sa_reply) \
5244 _(delete_loopback_reply) \
5245 _(bd_ip_mac_add_del_reply) \
5246 _(map_del_domain_reply) \
5247 _(map_add_del_rule_reply) \
5248 _(want_interface_events_reply) \
5249 _(want_stats_reply) \
5250 _(cop_interface_enable_disable_reply) \
5251 _(cop_whitelist_enable_disable_reply) \
5252 _(sw_interface_clear_stats_reply) \
5253 _(ioam_enable_reply) \
5254 _(ioam_disable_reply) \
5255 _(one_add_del_locator_reply) \
5256 _(one_add_del_local_eid_reply) \
5257 _(one_add_del_remote_mapping_reply) \
5258 _(one_add_del_adjacency_reply) \
5259 _(one_add_del_map_resolver_reply) \
5260 _(one_add_del_map_server_reply) \
5261 _(one_enable_disable_reply) \
5262 _(one_rloc_probe_enable_disable_reply) \
5263 _(one_map_register_enable_disable_reply) \
5264 _(one_map_register_set_ttl_reply) \
5265 _(one_set_transport_protocol_reply) \
5266 _(one_map_register_fallback_threshold_reply) \
5267 _(one_pitr_set_locator_set_reply) \
5268 _(one_map_request_mode_reply) \
5269 _(one_add_del_map_request_itr_rlocs_reply) \
5270 _(one_eid_table_add_del_map_reply) \
5271 _(one_use_petr_reply) \
5272 _(one_stats_enable_disable_reply) \
5273 _(one_add_del_l2_arp_entry_reply) \
5274 _(one_add_del_ndp_entry_reply) \
5275 _(one_stats_flush_reply) \
5276 _(one_enable_disable_xtr_mode_reply) \
5277 _(one_enable_disable_pitr_mode_reply) \
5278 _(one_enable_disable_petr_mode_reply) \
5279 _(gpe_enable_disable_reply) \
5280 _(gpe_set_encap_mode_reply) \
5281 _(gpe_add_del_iface_reply) \
5282 _(gpe_add_del_native_fwd_rpath_reply) \
5283 _(af_packet_delete_reply) \
5284 _(policer_classify_set_interface_reply) \
5285 _(netmap_create_reply) \
5286 _(netmap_delete_reply) \
5287 _(set_ipfix_exporter_reply) \
5288 _(set_ipfix_classify_stream_reply) \
5289 _(ipfix_classify_table_add_del_reply) \
5290 _(flow_classify_set_interface_reply) \
5291 _(sw_interface_span_enable_disable_reply) \
5292 _(pg_capture_reply) \
5293 _(pg_enable_disable_reply) \
5294 _(ip_source_and_port_range_check_add_del_reply) \
5295 _(ip_source_and_port_range_check_interface_add_del_reply)\
5296 _(delete_subif_reply) \
5297 _(l2_interface_pbb_tag_rewrite_reply) \
5299 _(feature_enable_disable_reply) \
5300 _(sw_interface_tag_add_del_reply) \
5301 _(sw_interface_set_mtu_reply) \
5302 _(p2p_ethernet_add_reply) \
5303 _(p2p_ethernet_del_reply) \
5304 _(lldp_config_reply) \
5305 _(sw_interface_set_lldp_reply) \
5306 _(tcp_configure_src_addresses_reply) \
5307 _(app_namespace_add_del_reply) \
5308 _(dns_enable_disable_reply) \
5309 _(dns_name_server_add_del_reply) \
5310 _(session_rule_add_del_reply) \
5311 _(ip_container_proxy_add_del_reply)
5314 static void vl_api_##n##_t_handler \
5315 (vl_api_##n##_t * mp) \
5317 vat_main_t * vam = &vat_main; \
5318 i32 retval = ntohl(mp->retval); \
5319 if (vam->async_mode) { \
5320 vam->async_errors += (retval < 0); \
5322 vam->retval = retval; \
5323 vam->result_ready = 1; \
5326 foreach_standard_reply_retval_handler;
5330 static void vl_api_##n##_t_handler_json \
5331 (vl_api_##n##_t * mp) \
5333 vat_main_t * vam = &vat_main; \
5334 vat_json_node_t node; \
5335 vat_json_init_object(&node); \
5336 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5337 vat_json_print(vam->ofp, &node); \
5338 vam->retval = ntohl(mp->retval); \
5339 vam->result_ready = 1; \
5341 foreach_standard_reply_retval_handler;
5345 * Table of message reply handlers, must include boilerplate handlers
5349 #define foreach_vpe_api_reply_msg \
5350 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5351 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5352 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5353 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5354 _(CONTROL_PING_REPLY, control_ping_reply) \
5355 _(CLI_REPLY, cli_reply) \
5356 _(CLI_INBAND_REPLY, cli_inband_reply) \
5357 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5358 sw_interface_add_del_address_reply) \
5359 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5360 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5361 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5362 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5363 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5364 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5365 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5366 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5367 sw_interface_set_l2_xconnect_reply) \
5368 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5369 sw_interface_set_l2_bridge_reply) \
5370 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5371 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5372 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5373 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5374 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5375 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5376 _(L2_FLAGS_REPLY, l2_flags_reply) \
5377 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5378 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5379 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5380 _(TAP_DELETE_REPLY, tap_delete_reply) \
5381 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5382 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5383 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5384 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5385 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5386 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5387 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5388 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5389 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5390 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5391 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5392 proxy_arp_intfc_enable_disable_reply) \
5393 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5394 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5395 sw_interface_set_unnumbered_reply) \
5396 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5397 _(RESET_VRF_REPLY, reset_vrf_reply) \
5398 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5399 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5400 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5401 _(RESET_FIB_REPLY, reset_fib_reply) \
5402 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5403 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5404 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5405 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5406 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5407 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5408 sw_interface_ip6_enable_disable_reply) \
5409 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5410 sw_interface_ip6_set_link_local_address_reply) \
5411 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5412 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5413 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5414 sw_interface_ip6nd_ra_prefix_reply) \
5415 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5416 sw_interface_ip6nd_ra_config_reply) \
5417 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5418 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5419 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5420 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5421 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5422 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5423 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5424 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5425 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5426 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5427 classify_set_interface_ip_table_reply) \
5428 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5429 classify_set_interface_l2_tables_reply) \
5430 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5431 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5432 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5433 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5434 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5435 l2tpv3_interface_enable_disable_reply) \
5436 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5437 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5438 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5439 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5440 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5441 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5442 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5443 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5444 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5445 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5446 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5447 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5448 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5449 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5450 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5451 _(SHOW_VERSION_REPLY, show_version_reply) \
5452 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5453 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5454 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5455 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5456 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5457 _(IP4_ARP_EVENT, ip4_arp_event) \
5458 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5459 _(IP6_ND_EVENT, ip6_nd_event) \
5460 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5461 _(L2_MACS_EVENT, l2_macs_event) \
5462 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5463 _(IP_ADDRESS_DETAILS, ip_address_details) \
5464 _(IP_DETAILS, ip_details) \
5465 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5466 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5467 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5468 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5469 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5470 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5471 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5472 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5473 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5474 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5475 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5476 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5477 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5478 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5479 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5480 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5481 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5482 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5483 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5484 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5485 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5486 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5487 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5488 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5489 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5490 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5491 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5492 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5493 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5494 _(MAP_RULE_DETAILS, map_rule_details) \
5495 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5496 _(WANT_STATS_REPLY, want_stats_reply) \
5497 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5498 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5499 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5500 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5501 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5502 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5503 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5504 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5505 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5506 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5507 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5508 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5509 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5510 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5511 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5512 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5513 one_map_register_enable_disable_reply) \
5514 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5515 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5516 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5517 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5518 one_map_register_fallback_threshold_reply) \
5519 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5520 one_rloc_probe_enable_disable_reply) \
5521 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5522 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5523 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5524 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5525 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5526 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5527 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5528 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5529 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5530 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5531 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5532 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5533 _(ONE_STATS_DETAILS, one_stats_details) \
5534 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5535 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5536 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5537 show_one_stats_enable_disable_reply) \
5538 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5539 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5540 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5541 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5542 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5543 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5544 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5545 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5546 one_enable_disable_pitr_mode_reply) \
5547 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5548 one_enable_disable_petr_mode_reply) \
5549 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5550 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5551 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5552 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5553 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5554 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5555 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5556 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5557 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5558 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5559 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5560 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5561 gpe_add_del_native_fwd_rpath_reply) \
5562 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5563 gpe_fwd_entry_path_details) \
5564 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5565 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5566 one_add_del_map_request_itr_rlocs_reply) \
5567 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5568 one_get_map_request_itr_rlocs_reply) \
5569 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5570 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5571 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5572 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5573 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5574 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5575 show_one_map_register_state_reply) \
5576 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5577 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5578 show_one_map_register_fallback_threshold_reply) \
5579 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5580 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5581 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5582 _(POLICER_DETAILS, policer_details) \
5583 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5584 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5585 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5586 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5587 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5588 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5589 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5590 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5591 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5592 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5593 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5594 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5595 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5596 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5597 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5598 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5599 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5600 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5601 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5602 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5603 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5604 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5605 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5606 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5607 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5608 ip_source_and_port_range_check_add_del_reply) \
5609 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5610 ip_source_and_port_range_check_interface_add_del_reply) \
5611 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5612 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5613 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5614 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5615 _(PUNT_REPLY, punt_reply) \
5616 _(IP_FIB_DETAILS, ip_fib_details) \
5617 _(IP6_FIB_DETAILS, ip6_fib_details) \
5618 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5619 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5620 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5621 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5622 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5623 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5624 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5625 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5626 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5627 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5628 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5629 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5630 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5631 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5632 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5633 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5634 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5635 _(SESSION_RULES_DETAILS, session_rules_details) \
5636 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5638 #define foreach_standalone_reply_msg \
5639 _(SW_INTERFACE_EVENT, sw_interface_event) \
5640 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5641 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5642 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5643 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5644 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5645 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
5646 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
5655 #define STR_VTR_OP_CASE(op) \
5656 case L2_VTR_ ## op: \
5660 str_vtr_op (u32 vtr_op)
5664 STR_VTR_OP_CASE (DISABLED);
5665 STR_VTR_OP_CASE (PUSH_1);
5666 STR_VTR_OP_CASE (PUSH_2);
5667 STR_VTR_OP_CASE (POP_1);
5668 STR_VTR_OP_CASE (POP_2);
5669 STR_VTR_OP_CASE (TRANSLATE_1_1);
5670 STR_VTR_OP_CASE (TRANSLATE_1_2);
5671 STR_VTR_OP_CASE (TRANSLATE_2_1);
5672 STR_VTR_OP_CASE (TRANSLATE_2_2);
5679 dump_sub_interface_table (vat_main_t * vam)
5681 const sw_interface_subif_t *sub = NULL;
5683 if (vam->json_output)
5686 ("JSON output supported only for VPE API calls and dump_stats_table");
5691 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5692 "Interface", "sw_if_index",
5693 "sub id", "dot1ad", "tags", "outer id",
5694 "inner id", "exact", "default", "outer any", "inner any");
5696 vec_foreach (sub, vam->sw_if_subif_table)
5699 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5700 sub->interface_name,
5702 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5703 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5704 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5705 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5706 if (sub->vtr_op != L2_VTR_DISABLED)
5709 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5710 "tag1: %d tag2: %d ]",
5711 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5712 sub->vtr_tag1, sub->vtr_tag2);
5720 name_sort_cmp (void *a1, void *a2)
5722 name_sort_t *n1 = a1;
5723 name_sort_t *n2 = a2;
5725 return strcmp ((char *) n1->name, (char *) n2->name);
5729 dump_interface_table (vat_main_t * vam)
5732 name_sort_t *nses = 0, *ns;
5734 if (vam->json_output)
5737 ("JSON output supported only for VPE API calls and dump_stats_table");
5742 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5744 vec_add2 (nses, ns, 1);
5745 ns->name = (u8 *)(p->key);
5746 ns->value = (u32) p->value[0];
5750 vec_sort_with_function (nses, name_sort_cmp);
5752 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5753 vec_foreach (ns, nses)
5755 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5762 dump_ip_table (vat_main_t * vam, int is_ipv6)
5764 const ip_details_t *det = NULL;
5765 const ip_address_details_t *address = NULL;
5768 print (vam->ofp, "%-12s", "sw_if_index");
5770 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5777 print (vam->ofp, "%-12d", i);
5778 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5783 vec_foreach (address, det->addr)
5787 is_ipv6 ? format_ip6_address : format_ip4_address,
5788 address->ip, address->prefix_length);
5796 dump_ipv4_table (vat_main_t * vam)
5798 if (vam->json_output)
5801 ("JSON output supported only for VPE API calls and dump_stats_table");
5805 return dump_ip_table (vam, 0);
5809 dump_ipv6_table (vat_main_t * vam)
5811 if (vam->json_output)
5814 ("JSON output supported only for VPE API calls and dump_stats_table");
5818 return dump_ip_table (vam, 1);
5822 counter_type_to_str (u8 counter_type, u8 is_combined)
5826 switch (counter_type)
5828 case VNET_INTERFACE_COUNTER_DROP:
5830 case VNET_INTERFACE_COUNTER_PUNT:
5832 case VNET_INTERFACE_COUNTER_IP4:
5834 case VNET_INTERFACE_COUNTER_IP6:
5836 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5838 case VNET_INTERFACE_COUNTER_RX_MISS:
5840 case VNET_INTERFACE_COUNTER_RX_ERROR:
5842 case VNET_INTERFACE_COUNTER_TX_ERROR:
5845 return "INVALID-COUNTER-TYPE";
5850 switch (counter_type)
5852 case VNET_INTERFACE_COUNTER_RX:
5854 case VNET_INTERFACE_COUNTER_TX:
5857 return "INVALID-COUNTER-TYPE";
5863 dump_stats_table (vat_main_t * vam)
5865 vat_json_node_t node;
5866 vat_json_node_t *msg_array;
5867 vat_json_node_t *msg;
5868 vat_json_node_t *counter_array;
5869 vat_json_node_t *counter;
5870 interface_counter_t c;
5872 ip4_fib_counter_t *c4;
5873 ip6_fib_counter_t *c6;
5874 ip4_nbr_counter_t *n4;
5875 ip6_nbr_counter_t *n6;
5878 if (!vam->json_output)
5880 clib_warning ("dump_stats_table supported only in JSON format");
5884 vat_json_init_object (&node);
5886 /* interface counters */
5887 msg_array = vat_json_object_add (&node, "interface_counters");
5888 vat_json_init_array (msg_array);
5889 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5891 msg = vat_json_array_add (msg_array);
5892 vat_json_init_object (msg);
5893 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5894 (u8 *) counter_type_to_str (i, 0));
5895 vat_json_object_add_int (msg, "is_combined", 0);
5896 counter_array = vat_json_object_add (msg, "data");
5897 vat_json_init_array (counter_array);
5898 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5900 packets = vam->simple_interface_counters[i][j];
5901 vat_json_array_add_uint (counter_array, packets);
5904 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5906 msg = vat_json_array_add (msg_array);
5907 vat_json_init_object (msg);
5908 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5909 (u8 *) counter_type_to_str (i, 1));
5910 vat_json_object_add_int (msg, "is_combined", 1);
5911 counter_array = vat_json_object_add (msg, "data");
5912 vat_json_init_array (counter_array);
5913 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5915 c = vam->combined_interface_counters[i][j];
5916 counter = vat_json_array_add (counter_array);
5917 vat_json_init_object (counter);
5918 vat_json_object_add_uint (counter, "packets", c.packets);
5919 vat_json_object_add_uint (counter, "bytes", c.bytes);
5923 /* ip4 fib counters */
5924 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5925 vat_json_init_array (msg_array);
5926 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5928 msg = vat_json_array_add (msg_array);
5929 vat_json_init_object (msg);
5930 vat_json_object_add_uint (msg, "vrf_id",
5931 vam->ip4_fib_counters_vrf_id_by_index[i]);
5932 counter_array = vat_json_object_add (msg, "c");
5933 vat_json_init_array (counter_array);
5934 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
5936 counter = vat_json_array_add (counter_array);
5937 vat_json_init_object (counter);
5938 c4 = &vam->ip4_fib_counters[i][j];
5939 vat_json_object_add_ip4 (counter, "address", c4->address);
5940 vat_json_object_add_uint (counter, "address_length",
5941 c4->address_length);
5942 vat_json_object_add_uint (counter, "packets", c4->packets);
5943 vat_json_object_add_uint (counter, "bytes", c4->bytes);
5947 /* ip6 fib counters */
5948 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
5949 vat_json_init_array (msg_array);
5950 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
5952 msg = vat_json_array_add (msg_array);
5953 vat_json_init_object (msg);
5954 vat_json_object_add_uint (msg, "vrf_id",
5955 vam->ip6_fib_counters_vrf_id_by_index[i]);
5956 counter_array = vat_json_object_add (msg, "c");
5957 vat_json_init_array (counter_array);
5958 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
5960 counter = vat_json_array_add (counter_array);
5961 vat_json_init_object (counter);
5962 c6 = &vam->ip6_fib_counters[i][j];
5963 vat_json_object_add_ip6 (counter, "address", c6->address);
5964 vat_json_object_add_uint (counter, "address_length",
5965 c6->address_length);
5966 vat_json_object_add_uint (counter, "packets", c6->packets);
5967 vat_json_object_add_uint (counter, "bytes", c6->bytes);
5971 /* ip4 nbr counters */
5972 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
5973 vat_json_init_array (msg_array);
5974 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
5976 msg = vat_json_array_add (msg_array);
5977 vat_json_init_object (msg);
5978 vat_json_object_add_uint (msg, "sw_if_index", i);
5979 counter_array = vat_json_object_add (msg, "c");
5980 vat_json_init_array (counter_array);
5981 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
5983 counter = vat_json_array_add (counter_array);
5984 vat_json_init_object (counter);
5985 n4 = &vam->ip4_nbr_counters[i][j];
5986 vat_json_object_add_ip4 (counter, "address", n4->address);
5987 vat_json_object_add_uint (counter, "link-type", n4->linkt);
5988 vat_json_object_add_uint (counter, "packets", n4->packets);
5989 vat_json_object_add_uint (counter, "bytes", n4->bytes);
5993 /* ip6 nbr counters */
5994 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
5995 vat_json_init_array (msg_array);
5996 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
5998 msg = vat_json_array_add (msg_array);
5999 vat_json_init_object (msg);
6000 vat_json_object_add_uint (msg, "sw_if_index", i);
6001 counter_array = vat_json_object_add (msg, "c");
6002 vat_json_init_array (counter_array);
6003 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
6005 counter = vat_json_array_add (counter_array);
6006 vat_json_init_object (counter);
6007 n6 = &vam->ip6_nbr_counters[i][j];
6008 vat_json_object_add_ip6 (counter, "address", n6->address);
6009 vat_json_object_add_uint (counter, "packets", n6->packets);
6010 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6014 vat_json_print (vam->ofp, &node);
6015 vat_json_free (&node);
6021 * Pass CLI buffers directly in the CLI_INBAND API message,
6022 * instead of an additional shared memory area.
6025 exec_inband (vat_main_t * vam)
6027 vl_api_cli_inband_t *mp;
6028 unformat_input_t *i = vam->input;
6031 if (vec_len (i->buffer) == 0)
6034 if (vam->exec_mode == 0 && unformat (i, "mode"))
6039 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6046 * In order for the CLI command to work, it
6047 * must be a vector ending in \n, not a C-string ending
6050 u32 len = vec_len (vam->input->buffer);
6051 M2 (CLI_INBAND, mp, len);
6052 clib_memcpy (mp->cmd, vam->input->buffer, len);
6053 mp->length = htonl (len);
6057 /* json responses may or may not include a useful reply... */
6058 if (vec_len (vam->cmd_reply))
6059 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6064 exec (vat_main_t * vam)
6066 return exec_inband (vam);
6070 api_create_loopback (vat_main_t * vam)
6072 unformat_input_t *i = vam->input;
6073 vl_api_create_loopback_t *mp;
6074 vl_api_create_loopback_instance_t *mp_lbi;
6077 u8 is_specified = 0;
6078 u32 user_instance = 0;
6081 memset (mac_address, 0, sizeof (mac_address));
6083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6085 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6087 if (unformat (i, "instance %d", &user_instance))
6095 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6096 mp_lbi->is_specified = is_specified;
6098 mp_lbi->user_instance = htonl (user_instance);
6100 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6105 /* Construct the API message */
6106 M (CREATE_LOOPBACK, mp);
6108 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6117 api_delete_loopback (vat_main_t * vam)
6119 unformat_input_t *i = vam->input;
6120 vl_api_delete_loopback_t *mp;
6121 u32 sw_if_index = ~0;
6124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6126 if (unformat (i, "sw_if_index %d", &sw_if_index))
6132 if (sw_if_index == ~0)
6134 errmsg ("missing sw_if_index");
6138 /* Construct the API message */
6139 M (DELETE_LOOPBACK, mp);
6140 mp->sw_if_index = ntohl (sw_if_index);
6148 api_want_stats (vat_main_t * vam)
6150 unformat_input_t *i = vam->input;
6151 vl_api_want_stats_t *mp;
6155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6157 if (unformat (i, "enable"))
6159 else if (unformat (i, "disable"))
6167 errmsg ("missing enable|disable");
6172 mp->enable_disable = enable;
6180 api_want_interface_events (vat_main_t * vam)
6182 unformat_input_t *i = vam->input;
6183 vl_api_want_interface_events_t *mp;
6187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6189 if (unformat (i, "enable"))
6191 else if (unformat (i, "disable"))
6199 errmsg ("missing enable|disable");
6203 M (WANT_INTERFACE_EVENTS, mp);
6204 mp->enable_disable = enable;
6206 vam->interface_event_display = enable;
6214 /* Note: non-static, called once to set up the initial intfc table */
6216 api_sw_interface_dump (vat_main_t * vam)
6218 vl_api_sw_interface_dump_t *mp;
6219 vl_api_control_ping_t *mp_ping;
6221 name_sort_t *nses = 0, *ns;
6222 sw_interface_subif_t *sub = NULL;
6225 /* Toss the old name table */
6227 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6229 vec_add2 (nses, ns, 1);
6230 ns->name = (u8 *)(p->key);
6231 ns->value = (u32) p->value[0];
6235 hash_free (vam->sw_if_index_by_interface_name);
6237 vec_foreach (ns, nses) vec_free (ns->name);
6241 vec_foreach (sub, vam->sw_if_subif_table)
6243 vec_free (sub->interface_name);
6245 vec_free (vam->sw_if_subif_table);
6247 /* recreate the interface name hash table */
6248 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6250 /* Get list of ethernets */
6251 M (SW_INTERFACE_DUMP, mp);
6252 mp->name_filter_valid = 1;
6253 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
6256 /* and local / loopback interfaces */
6257 M (SW_INTERFACE_DUMP, mp);
6258 mp->name_filter_valid = 1;
6259 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
6262 /* and packet-generator interfaces */
6263 M (SW_INTERFACE_DUMP, mp);
6264 mp->name_filter_valid = 1;
6265 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
6268 /* and vxlan-gpe tunnel interfaces */
6269 M (SW_INTERFACE_DUMP, mp);
6270 mp->name_filter_valid = 1;
6271 strncpy ((char *) mp->name_filter, "vxlan_gpe",
6272 sizeof (mp->name_filter) - 1);
6275 /* and vxlan tunnel interfaces */
6276 M (SW_INTERFACE_DUMP, mp);
6277 mp->name_filter_valid = 1;
6278 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
6281 /* and geneve tunnel interfaces */
6282 M (SW_INTERFACE_DUMP, mp);
6283 mp->name_filter_valid = 1;
6284 strncpy ((char *) mp->name_filter, "geneve", sizeof (mp->name_filter) - 1);
6287 /* and host (af_packet) interfaces */
6288 M (SW_INTERFACE_DUMP, mp);
6289 mp->name_filter_valid = 1;
6290 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
6293 /* and l2tpv3 tunnel interfaces */
6294 M (SW_INTERFACE_DUMP, mp);
6295 mp->name_filter_valid = 1;
6296 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
6297 sizeof (mp->name_filter) - 1);
6300 /* and GRE tunnel interfaces */
6301 M (SW_INTERFACE_DUMP, mp);
6302 mp->name_filter_valid = 1;
6303 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
6306 /* and LISP-GPE interfaces */
6307 M (SW_INTERFACE_DUMP, mp);
6308 mp->name_filter_valid = 1;
6309 strncpy ((char *) mp->name_filter, "lisp_gpe",
6310 sizeof (mp->name_filter) - 1);
6313 /* and IPSEC tunnel interfaces */
6314 M (SW_INTERFACE_DUMP, mp);
6315 mp->name_filter_valid = 1;
6316 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
6319 /* Use a control ping for synchronization */
6320 MPING (CONTROL_PING, mp_ping);
6328 api_sw_interface_set_flags (vat_main_t * vam)
6330 unformat_input_t *i = vam->input;
6331 vl_api_sw_interface_set_flags_t *mp;
6333 u8 sw_if_index_set = 0;
6337 /* Parse args required to build the message */
6338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6340 if (unformat (i, "admin-up"))
6342 else if (unformat (i, "admin-down"))
6345 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6346 sw_if_index_set = 1;
6347 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6348 sw_if_index_set = 1;
6353 if (sw_if_index_set == 0)
6355 errmsg ("missing interface name or sw_if_index");
6359 /* Construct the API message */
6360 M (SW_INTERFACE_SET_FLAGS, mp);
6361 mp->sw_if_index = ntohl (sw_if_index);
6362 mp->admin_up_down = admin_up;
6367 /* Wait for a reply, return the good/bad news... */
6373 api_sw_interface_set_rx_mode (vat_main_t * vam)
6375 unformat_input_t *i = vam->input;
6376 vl_api_sw_interface_set_rx_mode_t *mp;
6378 u8 sw_if_index_set = 0;
6380 u8 queue_id_valid = 0;
6382 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6384 /* Parse args required to build the message */
6385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6387 if (unformat (i, "queue %d", &queue_id))
6389 else if (unformat (i, "polling"))
6390 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6391 else if (unformat (i, "interrupt"))
6392 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6393 else if (unformat (i, "adaptive"))
6394 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6396 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6397 sw_if_index_set = 1;
6398 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6399 sw_if_index_set = 1;
6404 if (sw_if_index_set == 0)
6406 errmsg ("missing interface name or sw_if_index");
6409 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6411 errmsg ("missing rx-mode");
6415 /* Construct the API message */
6416 M (SW_INTERFACE_SET_RX_MODE, mp);
6417 mp->sw_if_index = ntohl (sw_if_index);
6419 mp->queue_id_valid = queue_id_valid;
6420 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6425 /* Wait for a reply, return the good/bad news... */
6431 api_sw_interface_clear_stats (vat_main_t * vam)
6433 unformat_input_t *i = vam->input;
6434 vl_api_sw_interface_clear_stats_t *mp;
6436 u8 sw_if_index_set = 0;
6439 /* Parse args required to build the message */
6440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6442 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6443 sw_if_index_set = 1;
6444 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6445 sw_if_index_set = 1;
6450 /* Construct the API message */
6451 M (SW_INTERFACE_CLEAR_STATS, mp);
6453 if (sw_if_index_set == 1)
6454 mp->sw_if_index = ntohl (sw_if_index);
6456 mp->sw_if_index = ~0;
6461 /* Wait for a reply, return the good/bad news... */
6467 api_sw_interface_add_del_address (vat_main_t * vam)
6469 unformat_input_t *i = vam->input;
6470 vl_api_sw_interface_add_del_address_t *mp;
6472 u8 sw_if_index_set = 0;
6473 u8 is_add = 1, del_all = 0;
6474 u32 address_length = 0;
6475 u8 v4_address_set = 0;
6476 u8 v6_address_set = 0;
6477 ip4_address_t v4address;
6478 ip6_address_t v6address;
6481 /* Parse args required to build the message */
6482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6484 if (unformat (i, "del-all"))
6486 else if (unformat (i, "del"))
6489 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6490 sw_if_index_set = 1;
6491 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6492 sw_if_index_set = 1;
6493 else if (unformat (i, "%U/%d",
6494 unformat_ip4_address, &v4address, &address_length))
6496 else if (unformat (i, "%U/%d",
6497 unformat_ip6_address, &v6address, &address_length))
6503 if (sw_if_index_set == 0)
6505 errmsg ("missing interface name or sw_if_index");
6508 if (v4_address_set && v6_address_set)
6510 errmsg ("both v4 and v6 addresses set");
6513 if (!v4_address_set && !v6_address_set && !del_all)
6515 errmsg ("no addresses set");
6519 /* Construct the API message */
6520 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6522 mp->sw_if_index = ntohl (sw_if_index);
6523 mp->is_add = is_add;
6524 mp->del_all = del_all;
6528 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6532 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6534 mp->address_length = address_length;
6539 /* Wait for a reply, return good/bad news */
6545 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6547 unformat_input_t *i = vam->input;
6548 vl_api_sw_interface_set_mpls_enable_t *mp;
6550 u8 sw_if_index_set = 0;
6554 /* Parse args required to build the message */
6555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6557 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6558 sw_if_index_set = 1;
6559 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6560 sw_if_index_set = 1;
6561 else if (unformat (i, "disable"))
6563 else if (unformat (i, "dis"))
6569 if (sw_if_index_set == 0)
6571 errmsg ("missing interface name or sw_if_index");
6575 /* Construct the API message */
6576 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6578 mp->sw_if_index = ntohl (sw_if_index);
6579 mp->enable = enable;
6584 /* Wait for a reply... */
6590 api_sw_interface_set_table (vat_main_t * vam)
6592 unformat_input_t *i = vam->input;
6593 vl_api_sw_interface_set_table_t *mp;
6594 u32 sw_if_index, vrf_id = 0;
6595 u8 sw_if_index_set = 0;
6599 /* Parse args required to build the message */
6600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6602 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6603 sw_if_index_set = 1;
6604 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6605 sw_if_index_set = 1;
6606 else if (unformat (i, "vrf %d", &vrf_id))
6608 else if (unformat (i, "ipv6"))
6614 if (sw_if_index_set == 0)
6616 errmsg ("missing interface name or sw_if_index");
6620 /* Construct the API message */
6621 M (SW_INTERFACE_SET_TABLE, mp);
6623 mp->sw_if_index = ntohl (sw_if_index);
6624 mp->is_ipv6 = is_ipv6;
6625 mp->vrf_id = ntohl (vrf_id);
6630 /* Wait for a reply... */
6635 static void vl_api_sw_interface_get_table_reply_t_handler
6636 (vl_api_sw_interface_get_table_reply_t * mp)
6638 vat_main_t *vam = &vat_main;
6640 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6642 vam->retval = ntohl (mp->retval);
6643 vam->result_ready = 1;
6647 static void vl_api_sw_interface_get_table_reply_t_handler_json
6648 (vl_api_sw_interface_get_table_reply_t * mp)
6650 vat_main_t *vam = &vat_main;
6651 vat_json_node_t node;
6653 vat_json_init_object (&node);
6654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6655 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6657 vat_json_print (vam->ofp, &node);
6658 vat_json_free (&node);
6660 vam->retval = ntohl (mp->retval);
6661 vam->result_ready = 1;
6665 api_sw_interface_get_table (vat_main_t * vam)
6667 unformat_input_t *i = vam->input;
6668 vl_api_sw_interface_get_table_t *mp;
6670 u8 sw_if_index_set = 0;
6674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6676 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6677 sw_if_index_set = 1;
6678 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6679 sw_if_index_set = 1;
6680 else if (unformat (i, "ipv6"))
6686 if (sw_if_index_set == 0)
6688 errmsg ("missing interface name or sw_if_index");
6692 M (SW_INTERFACE_GET_TABLE, mp);
6693 mp->sw_if_index = htonl (sw_if_index);
6694 mp->is_ipv6 = is_ipv6;
6702 api_sw_interface_set_vpath (vat_main_t * vam)
6704 unformat_input_t *i = vam->input;
6705 vl_api_sw_interface_set_vpath_t *mp;
6706 u32 sw_if_index = 0;
6707 u8 sw_if_index_set = 0;
6711 /* Parse args required to build the message */
6712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6714 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6715 sw_if_index_set = 1;
6716 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6717 sw_if_index_set = 1;
6718 else if (unformat (i, "enable"))
6720 else if (unformat (i, "disable"))
6726 if (sw_if_index_set == 0)
6728 errmsg ("missing interface name or sw_if_index");
6732 /* Construct the API message */
6733 M (SW_INTERFACE_SET_VPATH, mp);
6735 mp->sw_if_index = ntohl (sw_if_index);
6736 mp->enable = is_enable;
6741 /* Wait for a reply... */
6747 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6749 unformat_input_t *i = vam->input;
6750 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6751 u32 sw_if_index = 0;
6752 u8 sw_if_index_set = 0;
6757 /* Parse args required to build the message */
6758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6760 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6761 sw_if_index_set = 1;
6762 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6763 sw_if_index_set = 1;
6764 else if (unformat (i, "enable"))
6766 else if (unformat (i, "disable"))
6768 else if (unformat (i, "ip4"))
6770 else if (unformat (i, "ip6"))
6776 if (sw_if_index_set == 0)
6778 errmsg ("missing interface name or sw_if_index");
6782 /* Construct the API message */
6783 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6785 mp->sw_if_index = ntohl (sw_if_index);
6786 mp->enable = is_enable;
6787 mp->is_ipv6 = is_ipv6;
6792 /* Wait for a reply... */
6798 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6800 unformat_input_t *i = vam->input;
6801 vl_api_sw_interface_set_geneve_bypass_t *mp;
6802 u32 sw_if_index = 0;
6803 u8 sw_if_index_set = 0;
6808 /* Parse args required to build the message */
6809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6812 sw_if_index_set = 1;
6813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6814 sw_if_index_set = 1;
6815 else if (unformat (i, "enable"))
6817 else if (unformat (i, "disable"))
6819 else if (unformat (i, "ip4"))
6821 else if (unformat (i, "ip6"))
6827 if (sw_if_index_set == 0)
6829 errmsg ("missing interface name or sw_if_index");
6833 /* Construct the API message */
6834 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6836 mp->sw_if_index = ntohl (sw_if_index);
6837 mp->enable = is_enable;
6838 mp->is_ipv6 = is_ipv6;
6843 /* Wait for a reply... */
6849 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6851 unformat_input_t *i = vam->input;
6852 vl_api_sw_interface_set_l2_xconnect_t *mp;
6854 u8 rx_sw_if_index_set = 0;
6856 u8 tx_sw_if_index_set = 0;
6860 /* Parse args required to build the message */
6861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6863 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6864 rx_sw_if_index_set = 1;
6865 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6866 tx_sw_if_index_set = 1;
6867 else if (unformat (i, "rx"))
6869 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6871 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6873 rx_sw_if_index_set = 1;
6878 else if (unformat (i, "tx"))
6880 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6882 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6884 tx_sw_if_index_set = 1;
6889 else if (unformat (i, "enable"))
6891 else if (unformat (i, "disable"))
6897 if (rx_sw_if_index_set == 0)
6899 errmsg ("missing rx interface name or rx_sw_if_index");
6903 if (enable && (tx_sw_if_index_set == 0))
6905 errmsg ("missing tx interface name or tx_sw_if_index");
6909 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6911 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6912 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6913 mp->enable = enable;
6921 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6923 unformat_input_t *i = vam->input;
6924 vl_api_sw_interface_set_l2_bridge_t *mp;
6926 u8 rx_sw_if_index_set = 0;
6934 /* Parse args required to build the message */
6935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6937 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6938 rx_sw_if_index_set = 1;
6939 else if (unformat (i, "bd_id %d", &bd_id))
6943 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6944 rx_sw_if_index_set = 1;
6945 else if (unformat (i, "shg %d", &shg))
6947 else if (unformat (i, "bvi"))
6949 else if (unformat (i, "enable"))
6951 else if (unformat (i, "disable"))
6957 if (rx_sw_if_index_set == 0)
6959 errmsg ("missing rx interface name or sw_if_index");
6963 if (enable && (bd_id_set == 0))
6965 errmsg ("missing bridge domain");
6969 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6971 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6972 mp->bd_id = ntohl (bd_id);
6975 mp->enable = enable;
6983 api_bridge_domain_dump (vat_main_t * vam)
6985 unformat_input_t *i = vam->input;
6986 vl_api_bridge_domain_dump_t *mp;
6987 vl_api_control_ping_t *mp_ping;
6991 /* Parse args required to build the message */
6992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6994 if (unformat (i, "bd_id %d", &bd_id))
7000 M (BRIDGE_DOMAIN_DUMP, mp);
7001 mp->bd_id = ntohl (bd_id);
7004 /* Use a control ping for synchronization */
7005 MPING (CONTROL_PING, mp_ping);
7013 api_bridge_domain_add_del (vat_main_t * vam)
7015 unformat_input_t *i = vam->input;
7016 vl_api_bridge_domain_add_del_t *mp;
7019 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7024 /* Parse args required to build the message */
7025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7027 if (unformat (i, "bd_id %d", &bd_id))
7029 else if (unformat (i, "flood %d", &flood))
7031 else if (unformat (i, "uu-flood %d", &uu_flood))
7033 else if (unformat (i, "forward %d", &forward))
7035 else if (unformat (i, "learn %d", &learn))
7037 else if (unformat (i, "arp-term %d", &arp_term))
7039 else if (unformat (i, "mac-age %d", &mac_age))
7041 else if (unformat (i, "bd-tag %s", &bd_tag))
7043 else if (unformat (i, "del"))
7046 flood = uu_flood = forward = learn = 0;
7054 errmsg ("missing bridge domain");
7061 errmsg ("mac age must be less than 256 ");
7066 if ((bd_tag) && (strlen ((char *) bd_tag) > 63))
7068 errmsg ("bd-tag cannot be longer than 63");
7073 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7075 mp->bd_id = ntohl (bd_id);
7077 mp->uu_flood = uu_flood;
7078 mp->forward = forward;
7080 mp->arp_term = arp_term;
7081 mp->is_add = is_add;
7082 mp->mac_age = (u8) mac_age;
7084 strcpy ((char *) mp->bd_tag, (char *) bd_tag);
7095 api_l2fib_flush_bd (vat_main_t * vam)
7097 unformat_input_t *i = vam->input;
7098 vl_api_l2fib_flush_bd_t *mp;
7102 /* Parse args required to build the message */
7103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7105 if (unformat (i, "bd_id %d", &bd_id));
7112 errmsg ("missing bridge domain");
7116 M (L2FIB_FLUSH_BD, mp);
7118 mp->bd_id = htonl (bd_id);
7126 api_l2fib_flush_int (vat_main_t * vam)
7128 unformat_input_t *i = vam->input;
7129 vl_api_l2fib_flush_int_t *mp;
7130 u32 sw_if_index = ~0;
7133 /* Parse args required to build the message */
7134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7136 if (unformat (i, "sw_if_index %d", &sw_if_index));
7138 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7143 if (sw_if_index == ~0)
7145 errmsg ("missing interface name or sw_if_index");
7149 M (L2FIB_FLUSH_INT, mp);
7151 mp->sw_if_index = ntohl (sw_if_index);
7159 api_l2fib_add_del (vat_main_t * vam)
7161 unformat_input_t *i = vam->input;
7162 vl_api_l2fib_add_del_t *mp;
7168 u32 sw_if_index = ~0;
7169 u8 sw_if_index_set = 0;
7178 /* Parse args required to build the message */
7179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7181 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7183 else if (unformat (i, "bd_id %d", &bd_id))
7185 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7186 sw_if_index_set = 1;
7187 else if (unformat (i, "sw_if"))
7189 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7192 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7193 sw_if_index_set = 1;
7198 else if (unformat (i, "static"))
7200 else if (unformat (i, "filter"))
7205 else if (unformat (i, "bvi"))
7210 else if (unformat (i, "del"))
7212 else if (unformat (i, "count %d", &count))
7220 errmsg ("missing mac address");
7226 errmsg ("missing bridge domain");
7230 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7232 errmsg ("missing interface name or sw_if_index");
7238 /* Turn on async mode */
7239 vam->async_mode = 1;
7240 vam->async_errors = 0;
7241 before = vat_time_now (vam);
7244 for (j = 0; j < count; j++)
7246 M (L2FIB_ADD_DEL, mp);
7248 clib_memcpy (mp->mac, mac, 6);
7249 mp->bd_id = ntohl (bd_id);
7250 mp->is_add = is_add;
7254 mp->sw_if_index = ntohl (sw_if_index);
7255 mp->static_mac = static_mac;
7256 mp->filter_mac = filter_mac;
7257 mp->bvi_mac = bvi_mac;
7259 increment_mac_address (mac);
7266 vl_api_control_ping_t *mp_ping;
7269 /* Shut off async mode */
7270 vam->async_mode = 0;
7272 MPING (CONTROL_PING, mp_ping);
7275 timeout = vat_time_now (vam) + 1.0;
7276 while (vat_time_now (vam) < timeout)
7277 if (vam->result_ready == 1)
7282 if (vam->retval == -99)
7285 if (vam->async_errors > 0)
7287 errmsg ("%d asynchronous errors", vam->async_errors);
7290 vam->async_errors = 0;
7291 after = vat_time_now (vam);
7293 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7294 count, after - before, count / (after - before));
7300 /* Wait for a reply... */
7304 /* Return the good/bad news */
7305 return (vam->retval);
7309 api_bridge_domain_set_mac_age (vat_main_t * vam)
7311 unformat_input_t *i = vam->input;
7312 vl_api_bridge_domain_set_mac_age_t *mp;
7317 /* Parse args required to build the message */
7318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7320 if (unformat (i, "bd_id %d", &bd_id));
7321 else if (unformat (i, "mac-age %d", &mac_age));
7328 errmsg ("missing bridge domain");
7334 errmsg ("mac age must be less than 256 ");
7338 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7340 mp->bd_id = htonl (bd_id);
7341 mp->mac_age = (u8) mac_age;
7349 api_l2_flags (vat_main_t * vam)
7351 unformat_input_t *i = vam->input;
7352 vl_api_l2_flags_t *mp;
7355 u8 sw_if_index_set = 0;
7359 /* Parse args required to build the message */
7360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7362 if (unformat (i, "sw_if_index %d", &sw_if_index))
7363 sw_if_index_set = 1;
7364 else if (unformat (i, "sw_if"))
7366 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7369 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7370 sw_if_index_set = 1;
7375 else if (unformat (i, "learn"))
7377 else if (unformat (i, "forward"))
7379 else if (unformat (i, "flood"))
7381 else if (unformat (i, "uu-flood"))
7382 flags |= L2_UU_FLOOD;
7383 else if (unformat (i, "arp-term"))
7384 flags |= L2_ARP_TERM;
7385 else if (unformat (i, "off"))
7387 else if (unformat (i, "disable"))
7393 if (sw_if_index_set == 0)
7395 errmsg ("missing interface name or sw_if_index");
7401 mp->sw_if_index = ntohl (sw_if_index);
7402 mp->feature_bitmap = ntohl (flags);
7403 mp->is_set = is_set;
7411 api_bridge_flags (vat_main_t * vam)
7413 unformat_input_t *i = vam->input;
7414 vl_api_bridge_flags_t *mp;
7421 /* Parse args required to build the message */
7422 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7424 if (unformat (i, "bd_id %d", &bd_id))
7426 else if (unformat (i, "learn"))
7428 else if (unformat (i, "forward"))
7430 else if (unformat (i, "flood"))
7432 else if (unformat (i, "uu-flood"))
7433 flags |= L2_UU_FLOOD;
7434 else if (unformat (i, "arp-term"))
7435 flags |= L2_ARP_TERM;
7436 else if (unformat (i, "off"))
7438 else if (unformat (i, "disable"))
7446 errmsg ("missing bridge domain");
7450 M (BRIDGE_FLAGS, mp);
7452 mp->bd_id = ntohl (bd_id);
7453 mp->feature_bitmap = ntohl (flags);
7454 mp->is_set = is_set;
7462 api_bd_ip_mac_add_del (vat_main_t * vam)
7464 unformat_input_t *i = vam->input;
7465 vl_api_bd_ip_mac_add_del_t *mp;
7472 ip4_address_t v4addr;
7473 ip6_address_t v6addr;
7478 /* Parse args required to build the message */
7479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7481 if (unformat (i, "bd_id %d", &bd_id))
7485 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7489 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7494 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7498 else if (unformat (i, "del"))
7506 errmsg ("missing bridge domain");
7509 else if (ip_set == 0)
7511 errmsg ("missing IP address");
7514 else if (mac_set == 0)
7516 errmsg ("missing MAC address");
7520 M (BD_IP_MAC_ADD_DEL, mp);
7522 mp->bd_id = ntohl (bd_id);
7523 mp->is_ipv6 = is_ipv6;
7524 mp->is_add = is_add;
7526 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7528 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7529 clib_memcpy (mp->mac_address, macaddr, 6);
7536 api_tap_connect (vat_main_t * vam)
7538 unformat_input_t *i = vam->input;
7539 vl_api_tap_connect_t *mp;
7545 ip4_address_t ip4_address;
7547 int ip4_address_set = 0;
7548 ip6_address_t ip6_address;
7550 int ip6_address_set = 0;
7553 memset (mac_address, 0, sizeof (mac_address));
7555 /* Parse args required to build the message */
7556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7558 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7562 else if (unformat (i, "random-mac"))
7564 else if (unformat (i, "tapname %s", &tap_name))
7566 else if (unformat (i, "tag %s", &tag))
7568 else if (unformat (i, "address %U/%d",
7569 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7570 ip4_address_set = 1;
7571 else if (unformat (i, "address %U/%d",
7572 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7573 ip6_address_set = 1;
7580 errmsg ("missing tap name");
7583 if (vec_len (tap_name) > 63)
7585 errmsg ("tap name too long");
7588 vec_add1 (tap_name, 0);
7590 if (vec_len (tag) > 63)
7592 errmsg ("tag too long");
7596 /* Construct the API message */
7597 M (TAP_CONNECT, mp);
7599 mp->use_random_mac = random_mac;
7600 clib_memcpy (mp->mac_address, mac_address, 6);
7601 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7603 clib_memcpy (mp->tag, tag, vec_len (tag));
7605 if (ip4_address_set)
7607 mp->ip4_address_set = 1;
7608 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7609 mp->ip4_mask_width = ip4_mask_width;
7611 if (ip6_address_set)
7613 mp->ip6_address_set = 1;
7614 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7615 mp->ip6_mask_width = ip6_mask_width;
7618 vec_free (tap_name);
7624 /* Wait for a reply... */
7630 api_tap_modify (vat_main_t * vam)
7632 unformat_input_t *i = vam->input;
7633 vl_api_tap_modify_t *mp;
7638 u32 sw_if_index = ~0;
7639 u8 sw_if_index_set = 0;
7642 memset (mac_address, 0, sizeof (mac_address));
7644 /* Parse args required to build the message */
7645 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7647 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7648 sw_if_index_set = 1;
7649 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7650 sw_if_index_set = 1;
7651 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7655 else if (unformat (i, "random-mac"))
7657 else if (unformat (i, "tapname %s", &tap_name))
7663 if (sw_if_index_set == 0)
7665 errmsg ("missing vpp interface name");
7670 errmsg ("missing tap name");
7673 if (vec_len (tap_name) > 63)
7675 errmsg ("tap name too long");
7677 vec_add1 (tap_name, 0);
7679 /* Construct the API message */
7682 mp->use_random_mac = random_mac;
7683 mp->sw_if_index = ntohl (sw_if_index);
7684 clib_memcpy (mp->mac_address, mac_address, 6);
7685 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7686 vec_free (tap_name);
7691 /* Wait for a reply... */
7697 api_tap_delete (vat_main_t * vam)
7699 unformat_input_t *i = vam->input;
7700 vl_api_tap_delete_t *mp;
7701 u32 sw_if_index = ~0;
7702 u8 sw_if_index_set = 0;
7705 /* Parse args required to build the message */
7706 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7708 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7709 sw_if_index_set = 1;
7710 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7711 sw_if_index_set = 1;
7716 if (sw_if_index_set == 0)
7718 errmsg ("missing vpp interface name");
7722 /* Construct the API message */
7725 mp->sw_if_index = ntohl (sw_if_index);
7730 /* Wait for a reply... */
7736 api_ip_table_add_del (vat_main_t * vam)
7738 unformat_input_t *i = vam->input;
7739 vl_api_ip_table_add_del_t *mp;
7745 /* Parse args required to build the message */
7746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7748 if (unformat (i, "ipv6"))
7750 else if (unformat (i, "del"))
7752 else if (unformat (i, "add"))
7754 else if (unformat (i, "table %d", &table_id))
7758 clib_warning ("parse error '%U'", format_unformat_error, i);
7765 errmsg ("missing table-ID");
7769 /* Construct the API message */
7770 M (IP_TABLE_ADD_DEL, mp);
7772 mp->table_id = ntohl (table_id);
7773 mp->is_ipv6 = is_ipv6;
7774 mp->is_add = is_add;
7779 /* Wait for a reply... */
7786 api_ip_add_del_route (vat_main_t * vam)
7788 unformat_input_t *i = vam->input;
7789 vl_api_ip_add_del_route_t *mp;
7790 u32 sw_if_index = ~0, vrf_id = 0;
7792 u8 is_local = 0, is_drop = 0;
7793 u8 is_unreach = 0, is_prohibit = 0;
7794 u8 create_vrf_if_needed = 0;
7796 u32 next_hop_weight = 1;
7797 u8 is_multipath = 0;
7799 u8 address_length_set = 0;
7800 u32 next_hop_table_id = 0;
7801 u32 resolve_attempts = 0;
7802 u32 dst_address_length = 0;
7803 u8 next_hop_set = 0;
7804 ip4_address_t v4_dst_address, v4_next_hop_address;
7805 ip6_address_t v6_dst_address, v6_next_hop_address;
7809 u32 random_add_del = 0;
7810 u32 *random_vector = 0;
7812 u32 random_seed = 0xdeaddabe;
7813 u32 classify_table_index = ~0;
7815 u8 resolve_host = 0, resolve_attached = 0;
7816 mpls_label_t *next_hop_out_label_stack = NULL;
7817 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7818 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7820 /* Parse args required to build the message */
7821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7823 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7825 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7827 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
7832 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
7837 else if (unformat (i, "/%d", &dst_address_length))
7839 address_length_set = 1;
7842 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
7843 &v4_next_hop_address))
7847 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
7848 &v6_next_hop_address))
7852 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
7854 else if (unformat (i, "weight %d", &next_hop_weight))
7856 else if (unformat (i, "drop"))
7860 else if (unformat (i, "null-send-unreach"))
7864 else if (unformat (i, "null-send-prohibit"))
7868 else if (unformat (i, "local"))
7872 else if (unformat (i, "classify %d", &classify_table_index))
7876 else if (unformat (i, "del"))
7878 else if (unformat (i, "add"))
7880 else if (unformat (i, "resolve-via-host"))
7882 else if (unformat (i, "resolve-via-attached"))
7883 resolve_attached = 1;
7884 else if (unformat (i, "multipath"))
7886 else if (unformat (i, "vrf %d", &vrf_id))
7888 else if (unformat (i, "create-vrf"))
7889 create_vrf_if_needed = 1;
7890 else if (unformat (i, "count %d", &count))
7892 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
7894 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7896 else if (unformat (i, "out-label %d", &next_hop_out_label))
7897 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7898 else if (unformat (i, "via-label %d", &next_hop_via_label))
7900 else if (unformat (i, "random"))
7902 else if (unformat (i, "seed %d", &random_seed))
7906 clib_warning ("parse error '%U'", format_unformat_error, i);
7911 if (!next_hop_set && !is_drop && !is_local &&
7912 !is_classify && !is_unreach && !is_prohibit &&
7913 MPLS_LABEL_INVALID == next_hop_via_label)
7916 ("next hop / local / drop / unreach / prohibit / classify not set");
7920 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
7922 errmsg ("next hop and next-hop via label set");
7925 if (address_set == 0)
7927 errmsg ("missing addresses");
7931 if (address_length_set == 0)
7933 errmsg ("missing address length");
7937 /* Generate a pile of unique, random routes */
7940 u32 this_random_address;
7941 random_hash = hash_create (count, sizeof (uword));
7943 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
7944 for (j = 0; j <= count; j++)
7948 this_random_address = random_u32 (&random_seed);
7949 this_random_address =
7950 clib_host_to_net_u32 (this_random_address);
7952 while (hash_get (random_hash, this_random_address));
7953 vec_add1 (random_vector, this_random_address);
7954 hash_set (random_hash, this_random_address, 1);
7956 hash_free (random_hash);
7957 v4_dst_address.as_u32 = random_vector[0];
7962 /* Turn on async mode */
7963 vam->async_mode = 1;
7964 vam->async_errors = 0;
7965 before = vat_time_now (vam);
7968 for (j = 0; j < count; j++)
7970 /* Construct the API message */
7971 M2 (IP_ADD_DEL_ROUTE, mp,
7972 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7974 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7975 mp->table_id = ntohl (vrf_id);
7976 mp->create_vrf_if_needed = create_vrf_if_needed;
7978 mp->is_add = is_add;
7979 mp->is_drop = is_drop;
7980 mp->is_unreach = is_unreach;
7981 mp->is_prohibit = is_prohibit;
7982 mp->is_ipv6 = is_ipv6;
7983 mp->is_local = is_local;
7984 mp->is_classify = is_classify;
7985 mp->is_multipath = is_multipath;
7986 mp->is_resolve_host = resolve_host;
7987 mp->is_resolve_attached = resolve_attached;
7988 mp->next_hop_weight = next_hop_weight;
7989 mp->dst_address_length = dst_address_length;
7990 mp->next_hop_table_id = ntohl (next_hop_table_id);
7991 mp->classify_table_index = ntohl (classify_table_index);
7992 mp->next_hop_via_label = ntohl (next_hop_via_label);
7993 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7994 if (0 != mp->next_hop_n_out_labels)
7996 memcpy (mp->next_hop_out_label_stack,
7997 next_hop_out_label_stack,
7998 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7999 vec_free (next_hop_out_label_stack);
8004 clib_memcpy (mp->dst_address, &v6_dst_address,
8005 sizeof (v6_dst_address));
8007 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8008 sizeof (v6_next_hop_address));
8009 increment_v6_address (&v6_dst_address);
8013 clib_memcpy (mp->dst_address, &v4_dst_address,
8014 sizeof (v4_dst_address));
8016 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8017 sizeof (v4_next_hop_address));
8019 v4_dst_address.as_u32 = random_vector[j + 1];
8021 increment_v4_address (&v4_dst_address);
8025 /* If we receive SIGTERM, stop now... */
8030 /* When testing multiple add/del ops, use a control-ping to sync */
8033 vl_api_control_ping_t *mp_ping;
8037 /* Shut off async mode */
8038 vam->async_mode = 0;
8040 MPING (CONTROL_PING, mp_ping);
8043 timeout = vat_time_now (vam) + 1.0;
8044 while (vat_time_now (vam) < timeout)
8045 if (vam->result_ready == 1)
8050 if (vam->retval == -99)
8053 if (vam->async_errors > 0)
8055 errmsg ("%d asynchronous errors", vam->async_errors);
8058 vam->async_errors = 0;
8059 after = vat_time_now (vam);
8061 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8065 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8066 count, after - before, count / (after - before));
8072 /* Wait for a reply... */
8077 /* Return the good/bad news */
8078 return (vam->retval);
8082 api_ip_mroute_add_del (vat_main_t * vam)
8084 unformat_input_t *i = vam->input;
8085 vl_api_ip_mroute_add_del_t *mp;
8086 u32 sw_if_index = ~0, vrf_id = 0;
8089 u8 create_vrf_if_needed = 0;
8092 u32 grp_address_length = 0;
8093 ip4_address_t v4_grp_address, v4_src_address;
8094 ip6_address_t v6_grp_address, v6_src_address;
8095 mfib_itf_flags_t iflags = 0;
8096 mfib_entry_flags_t eflags = 0;
8099 /* Parse args required to build the message */
8100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8102 if (unformat (i, "sw_if_index %d", &sw_if_index))
8104 else if (unformat (i, "%U %U",
8105 unformat_ip4_address, &v4_src_address,
8106 unformat_ip4_address, &v4_grp_address))
8108 grp_address_length = 64;
8112 else if (unformat (i, "%U %U",
8113 unformat_ip6_address, &v6_src_address,
8114 unformat_ip6_address, &v6_grp_address))
8116 grp_address_length = 256;
8120 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8122 memset (&v4_src_address, 0, sizeof (v4_src_address));
8123 grp_address_length = 32;
8127 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8129 memset (&v6_src_address, 0, sizeof (v6_src_address));
8130 grp_address_length = 128;
8134 else if (unformat (i, "/%d", &grp_address_length))
8136 else if (unformat (i, "local"))
8140 else if (unformat (i, "del"))
8142 else if (unformat (i, "add"))
8144 else if (unformat (i, "vrf %d", &vrf_id))
8146 else if (unformat (i, "create-vrf"))
8147 create_vrf_if_needed = 1;
8148 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8150 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8154 clib_warning ("parse error '%U'", format_unformat_error, i);
8159 if (address_set == 0)
8161 errmsg ("missing addresses\n");
8165 /* Construct the API message */
8166 M (IP_MROUTE_ADD_DEL, mp);
8168 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8169 mp->table_id = ntohl (vrf_id);
8170 mp->create_vrf_if_needed = create_vrf_if_needed;
8172 mp->is_add = is_add;
8173 mp->is_ipv6 = is_ipv6;
8174 mp->is_local = is_local;
8175 mp->itf_flags = ntohl (iflags);
8176 mp->entry_flags = ntohl (eflags);
8177 mp->grp_address_length = grp_address_length;
8178 mp->grp_address_length = ntohs (mp->grp_address_length);
8182 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8183 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8187 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8188 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8194 /* Wait for a reply... */
8200 api_mpls_table_add_del (vat_main_t * vam)
8202 unformat_input_t *i = vam->input;
8203 vl_api_mpls_table_add_del_t *mp;
8208 /* Parse args required to build the message */
8209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8211 if (unformat (i, "table %d", &table_id))
8213 else if (unformat (i, "del"))
8215 else if (unformat (i, "add"))
8219 clib_warning ("parse error '%U'", format_unformat_error, i);
8226 errmsg ("missing table-ID");
8230 /* Construct the API message */
8231 M (MPLS_TABLE_ADD_DEL, mp);
8233 mp->mt_table_id = ntohl (table_id);
8234 mp->mt_is_add = is_add;
8239 /* Wait for a reply... */
8246 api_mpls_route_add_del (vat_main_t * vam)
8248 unformat_input_t *i = vam->input;
8249 vl_api_mpls_route_add_del_t *mp;
8250 u32 sw_if_index = ~0, table_id = 0;
8251 u8 create_table_if_needed = 0;
8253 u32 next_hop_weight = 1;
8254 u8 is_multipath = 0;
8255 u32 next_hop_table_id = 0;
8256 u8 next_hop_set = 0;
8257 ip4_address_t v4_next_hop_address = {
8260 ip6_address_t v6_next_hop_address = { {0} };
8264 u32 classify_table_index = ~0;
8266 u8 resolve_host = 0, resolve_attached = 0;
8267 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8268 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8269 mpls_label_t *next_hop_out_label_stack = NULL;
8270 mpls_label_t local_label = MPLS_LABEL_INVALID;
8272 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8274 /* Parse args required to build the message */
8275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8277 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8279 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8281 else if (unformat (i, "%d", &local_label))
8283 else if (unformat (i, "eos"))
8285 else if (unformat (i, "non-eos"))
8287 else if (unformat (i, "via %U", unformat_ip4_address,
8288 &v4_next_hop_address))
8291 next_hop_proto = DPO_PROTO_IP4;
8293 else if (unformat (i, "via %U", unformat_ip6_address,
8294 &v6_next_hop_address))
8297 next_hop_proto = DPO_PROTO_IP6;
8299 else if (unformat (i, "weight %d", &next_hop_weight))
8301 else if (unformat (i, "create-table"))
8302 create_table_if_needed = 1;
8303 else if (unformat (i, "classify %d", &classify_table_index))
8307 else if (unformat (i, "del"))
8309 else if (unformat (i, "add"))
8311 else if (unformat (i, "resolve-via-host"))
8313 else if (unformat (i, "resolve-via-attached"))
8314 resolve_attached = 1;
8315 else if (unformat (i, "multipath"))
8317 else if (unformat (i, "count %d", &count))
8319 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8322 next_hop_proto = DPO_PROTO_IP4;
8324 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8327 next_hop_proto = DPO_PROTO_IP6;
8329 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8331 else if (unformat (i, "via-label %d", &next_hop_via_label))
8333 else if (unformat (i, "out-label %d", &next_hop_out_label))
8334 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8337 clib_warning ("parse error '%U'", format_unformat_error, i);
8342 if (!next_hop_set && !is_classify)
8344 errmsg ("next hop / classify not set");
8348 if (MPLS_LABEL_INVALID == local_label)
8350 errmsg ("missing label");
8356 /* Turn on async mode */
8357 vam->async_mode = 1;
8358 vam->async_errors = 0;
8359 before = vat_time_now (vam);
8362 for (j = 0; j < count; j++)
8364 /* Construct the API message */
8365 M2 (MPLS_ROUTE_ADD_DEL, mp,
8366 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8368 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8369 mp->mr_table_id = ntohl (table_id);
8370 mp->mr_create_table_if_needed = create_table_if_needed;
8372 mp->mr_is_add = is_add;
8373 mp->mr_next_hop_proto = next_hop_proto;
8374 mp->mr_is_classify = is_classify;
8375 mp->mr_is_multipath = is_multipath;
8376 mp->mr_is_resolve_host = resolve_host;
8377 mp->mr_is_resolve_attached = resolve_attached;
8378 mp->mr_next_hop_weight = next_hop_weight;
8379 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8380 mp->mr_classify_table_index = ntohl (classify_table_index);
8381 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8382 mp->mr_label = ntohl (local_label);
8383 mp->mr_eos = is_eos;
8385 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8386 if (0 != mp->mr_next_hop_n_out_labels)
8388 memcpy (mp->mr_next_hop_out_label_stack,
8389 next_hop_out_label_stack,
8390 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8391 vec_free (next_hop_out_label_stack);
8396 if (DPO_PROTO_IP4 == next_hop_proto)
8398 clib_memcpy (mp->mr_next_hop,
8399 &v4_next_hop_address,
8400 sizeof (v4_next_hop_address));
8402 else if (DPO_PROTO_IP6 == next_hop_proto)
8405 clib_memcpy (mp->mr_next_hop,
8406 &v6_next_hop_address,
8407 sizeof (v6_next_hop_address));
8414 /* If we receive SIGTERM, stop now... */
8419 /* When testing multiple add/del ops, use a control-ping to sync */
8422 vl_api_control_ping_t *mp_ping;
8426 /* Shut off async mode */
8427 vam->async_mode = 0;
8429 MPING (CONTROL_PING, mp_ping);
8432 timeout = vat_time_now (vam) + 1.0;
8433 while (vat_time_now (vam) < timeout)
8434 if (vam->result_ready == 1)
8439 if (vam->retval == -99)
8442 if (vam->async_errors > 0)
8444 errmsg ("%d asynchronous errors", vam->async_errors);
8447 vam->async_errors = 0;
8448 after = vat_time_now (vam);
8450 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8454 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8455 count, after - before, count / (after - before));
8461 /* Wait for a reply... */
8466 /* Return the good/bad news */
8467 return (vam->retval);
8471 api_mpls_ip_bind_unbind (vat_main_t * vam)
8473 unformat_input_t *i = vam->input;
8474 vl_api_mpls_ip_bind_unbind_t *mp;
8475 u32 ip_table_id = 0;
8476 u8 create_table_if_needed = 0;
8479 ip4_address_t v4_address;
8480 ip6_address_t v6_address;
8483 mpls_label_t local_label = MPLS_LABEL_INVALID;
8486 /* Parse args required to build the message */
8487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8489 if (unformat (i, "%U/%d", unformat_ip4_address,
8490 &v4_address, &address_length))
8495 else if (unformat (i, "%U/%d", unformat_ip6_address,
8496 &v6_address, &address_length))
8501 else if (unformat (i, "%d", &local_label))
8503 else if (unformat (i, "create-table"))
8504 create_table_if_needed = 1;
8505 else if (unformat (i, "table-id %d", &ip_table_id))
8507 else if (unformat (i, "unbind"))
8509 else if (unformat (i, "bind"))
8513 clib_warning ("parse error '%U'", format_unformat_error, i);
8520 errmsg ("IP addres not set");
8524 if (MPLS_LABEL_INVALID == local_label)
8526 errmsg ("missing label");
8530 /* Construct the API message */
8531 M (MPLS_IP_BIND_UNBIND, mp);
8533 mp->mb_create_table_if_needed = create_table_if_needed;
8534 mp->mb_is_bind = is_bind;
8535 mp->mb_is_ip4 = is_ip4;
8536 mp->mb_ip_table_id = ntohl (ip_table_id);
8537 mp->mb_mpls_table_id = 0;
8538 mp->mb_label = ntohl (local_label);
8539 mp->mb_address_length = address_length;
8542 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8544 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8549 /* Wait for a reply... */
8555 api_bier_table_add_del (vat_main_t * vam)
8557 unformat_input_t *i = vam->input;
8558 vl_api_bier_table_add_del_t *mp;
8560 u32 set = 0, sub_domain = 0, hdr_len = 3;
8561 mpls_label_t local_label = MPLS_LABEL_INVALID;
8564 /* Parse args required to build the message */
8565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8567 if (unformat (i, "sub-domain %d", &sub_domain))
8569 else if (unformat (i, "set %d", &set))
8571 else if (unformat (i, "label %d", &local_label))
8573 else if (unformat (i, "hdr-len %d", &hdr_len))
8575 else if (unformat (i, "add"))
8577 else if (unformat (i, "del"))
8581 clib_warning ("parse error '%U'", format_unformat_error, i);
8586 if (MPLS_LABEL_INVALID == local_label)
8588 errmsg ("missing label\n");
8592 /* Construct the API message */
8593 M (BIER_TABLE_ADD_DEL, mp);
8595 mp->bt_is_add = is_add;
8596 mp->bt_label = ntohl (local_label);
8597 mp->bt_tbl_id.bt_set = set;
8598 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8599 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8604 /* Wait for a reply... */
8611 api_bier_route_add_del (vat_main_t * vam)
8613 unformat_input_t *i = vam->input;
8614 vl_api_bier_route_add_del_t *mp;
8616 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8617 ip4_address_t v4_next_hop_address;
8618 ip6_address_t v6_next_hop_address;
8619 u8 next_hop_set = 0;
8620 u8 next_hop_proto_is_ip4 = 1;
8621 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8624 /* Parse args required to build the message */
8625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8627 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8629 next_hop_proto_is_ip4 = 1;
8632 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8634 next_hop_proto_is_ip4 = 0;
8637 if (unformat (i, "sub-domain %d", &sub_domain))
8639 else if (unformat (i, "set %d", &set))
8641 else if (unformat (i, "hdr-len %d", &hdr_len))
8643 else if (unformat (i, "bp %d", &bp))
8645 else if (unformat (i, "add"))
8647 else if (unformat (i, "del"))
8649 else if (unformat (i, "out-label %d", &next_hop_out_label))
8653 clib_warning ("parse error '%U'", format_unformat_error, i);
8658 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8660 errmsg ("next hop / label set\n");
8665 errmsg ("bit=position not set\n");
8669 /* Construct the API message */
8670 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8672 mp->br_is_add = is_add;
8673 mp->br_tbl_id.bt_set = set;
8674 mp->br_tbl_id.bt_sub_domain = sub_domain;
8675 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8676 mp->br_bp = ntohs (bp);
8678 mp->br_paths[0].n_labels = 1;
8679 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8680 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8682 if (next_hop_proto_is_ip4)
8684 clib_memcpy (mp->br_paths[0].next_hop,
8685 &v4_next_hop_address, sizeof (v4_next_hop_address));
8689 clib_memcpy (mp->br_paths[0].next_hop,
8690 &v6_next_hop_address, sizeof (v6_next_hop_address));
8696 /* Wait for a reply... */
8703 api_proxy_arp_add_del (vat_main_t * vam)
8705 unformat_input_t *i = vam->input;
8706 vl_api_proxy_arp_add_del_t *mp;
8709 ip4_address_t lo, hi;
8713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8715 if (unformat (i, "vrf %d", &vrf_id))
8717 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8718 unformat_ip4_address, &hi))
8720 else if (unformat (i, "del"))
8724 clib_warning ("parse error '%U'", format_unformat_error, i);
8731 errmsg ("address range not set");
8735 M (PROXY_ARP_ADD_DEL, mp);
8737 mp->vrf_id = ntohl (vrf_id);
8738 mp->is_add = is_add;
8739 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8740 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8748 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8750 unformat_input_t *i = vam->input;
8751 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8754 u8 sw_if_index_set = 0;
8757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8759 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8760 sw_if_index_set = 1;
8761 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8762 sw_if_index_set = 1;
8763 else if (unformat (i, "enable"))
8765 else if (unformat (i, "disable"))
8769 clib_warning ("parse error '%U'", format_unformat_error, i);
8774 if (sw_if_index_set == 0)
8776 errmsg ("missing interface name or sw_if_index");
8780 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8782 mp->sw_if_index = ntohl (sw_if_index);
8783 mp->enable_disable = enable;
8791 api_mpls_tunnel_add_del (vat_main_t * vam)
8793 unformat_input_t *i = vam->input;
8794 vl_api_mpls_tunnel_add_del_t *mp;
8798 u32 sw_if_index = ~0;
8799 u32 next_hop_sw_if_index = ~0;
8800 u32 next_hop_proto_is_ip4 = 1;
8802 u32 next_hop_table_id = 0;
8803 ip4_address_t v4_next_hop_address = {
8806 ip6_address_t v6_next_hop_address = { {0} };
8807 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
8810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8812 if (unformat (i, "add"))
8814 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8816 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
8818 else if (unformat (i, "via %U",
8819 unformat_ip4_address, &v4_next_hop_address))
8821 next_hop_proto_is_ip4 = 1;
8823 else if (unformat (i, "via %U",
8824 unformat_ip6_address, &v6_next_hop_address))
8826 next_hop_proto_is_ip4 = 0;
8828 else if (unformat (i, "l2-only"))
8830 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8832 else if (unformat (i, "out-label %d", &next_hop_out_label))
8833 vec_add1 (labels, ntohl (next_hop_out_label));
8836 clib_warning ("parse error '%U'", format_unformat_error, i);
8841 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
8843 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
8844 mp->mt_sw_if_index = ntohl (sw_if_index);
8845 mp->mt_is_add = is_add;
8846 mp->mt_l2_only = l2_only;
8847 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
8848 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
8850 mp->mt_next_hop_n_out_labels = vec_len (labels);
8852 if (0 != mp->mt_next_hop_n_out_labels)
8854 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
8855 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
8859 if (next_hop_proto_is_ip4)
8861 clib_memcpy (mp->mt_next_hop,
8862 &v4_next_hop_address, sizeof (v4_next_hop_address));
8866 clib_memcpy (mp->mt_next_hop,
8867 &v6_next_hop_address, sizeof (v6_next_hop_address));
8876 api_sw_interface_set_unnumbered (vat_main_t * vam)
8878 unformat_input_t *i = vam->input;
8879 vl_api_sw_interface_set_unnumbered_t *mp;
8881 u32 unnum_sw_index = ~0;
8883 u8 sw_if_index_set = 0;
8886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8888 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8889 sw_if_index_set = 1;
8890 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8891 sw_if_index_set = 1;
8892 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8894 else if (unformat (i, "del"))
8898 clib_warning ("parse error '%U'", format_unformat_error, i);
8903 if (sw_if_index_set == 0)
8905 errmsg ("missing interface name or sw_if_index");
8909 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8911 mp->sw_if_index = ntohl (sw_if_index);
8912 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8913 mp->is_add = is_add;
8921 api_ip_neighbor_add_del (vat_main_t * vam)
8923 unformat_input_t *i = vam->input;
8924 vl_api_ip_neighbor_add_del_t *mp;
8926 u8 sw_if_index_set = 0;
8929 u8 is_no_fib_entry = 0;
8932 u8 v4_address_set = 0;
8933 u8 v6_address_set = 0;
8934 ip4_address_t v4address;
8935 ip6_address_t v6address;
8938 memset (mac_address, 0, sizeof (mac_address));
8940 /* Parse args required to build the message */
8941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8943 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8947 else if (unformat (i, "del"))
8950 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8951 sw_if_index_set = 1;
8952 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8953 sw_if_index_set = 1;
8954 else if (unformat (i, "is_static"))
8956 else if (unformat (i, "no-fib-entry"))
8957 is_no_fib_entry = 1;
8958 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
8960 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
8964 clib_warning ("parse error '%U'", format_unformat_error, i);
8969 if (sw_if_index_set == 0)
8971 errmsg ("missing interface name or sw_if_index");
8974 if (v4_address_set && v6_address_set)
8976 errmsg ("both v4 and v6 addresses set");
8979 if (!v4_address_set && !v6_address_set)
8981 errmsg ("no address set");
8985 /* Construct the API message */
8986 M (IP_NEIGHBOR_ADD_DEL, mp);
8988 mp->sw_if_index = ntohl (sw_if_index);
8989 mp->is_add = is_add;
8990 mp->is_static = is_static;
8991 mp->is_no_adj_fib = is_no_fib_entry;
8993 clib_memcpy (mp->mac_address, mac_address, 6);
8997 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9001 /* mp->is_ipv6 = 0; via memset in M macro above */
9002 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9008 /* Wait for a reply, return good/bad news */
9014 api_reset_vrf (vat_main_t * vam)
9016 unformat_input_t *i = vam->input;
9017 vl_api_reset_vrf_t *mp;
9023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9025 if (unformat (i, "vrf %d", &vrf_id))
9027 else if (unformat (i, "ipv6"))
9031 clib_warning ("parse error '%U'", format_unformat_error, i);
9036 if (vrf_id_set == 0)
9038 errmsg ("missing vrf id");
9044 mp->vrf_id = ntohl (vrf_id);
9045 mp->is_ipv6 = is_ipv6;
9053 api_create_vlan_subif (vat_main_t * vam)
9055 unformat_input_t *i = vam->input;
9056 vl_api_create_vlan_subif_t *mp;
9058 u8 sw_if_index_set = 0;
9063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9065 if (unformat (i, "sw_if_index %d", &sw_if_index))
9066 sw_if_index_set = 1;
9068 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9069 sw_if_index_set = 1;
9070 else if (unformat (i, "vlan %d", &vlan_id))
9074 clib_warning ("parse error '%U'", format_unformat_error, i);
9079 if (sw_if_index_set == 0)
9081 errmsg ("missing interface name or sw_if_index");
9085 if (vlan_id_set == 0)
9087 errmsg ("missing vlan_id");
9090 M (CREATE_VLAN_SUBIF, mp);
9092 mp->sw_if_index = ntohl (sw_if_index);
9093 mp->vlan_id = ntohl (vlan_id);
9100 #define foreach_create_subif_bit \
9107 _(outer_vlan_id_any) \
9108 _(inner_vlan_id_any)
9111 api_create_subif (vat_main_t * vam)
9113 unformat_input_t *i = vam->input;
9114 vl_api_create_subif_t *mp;
9116 u8 sw_if_index_set = 0;
9123 u32 exact_match = 0;
9124 u32 default_sub = 0;
9125 u32 outer_vlan_id_any = 0;
9126 u32 inner_vlan_id_any = 0;
9128 u16 outer_vlan_id = 0;
9129 u16 inner_vlan_id = 0;
9132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9134 if (unformat (i, "sw_if_index %d", &sw_if_index))
9135 sw_if_index_set = 1;
9137 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9138 sw_if_index_set = 1;
9139 else if (unformat (i, "sub_id %d", &sub_id))
9141 else if (unformat (i, "outer_vlan_id %d", &tmp))
9142 outer_vlan_id = tmp;
9143 else if (unformat (i, "inner_vlan_id %d", &tmp))
9144 inner_vlan_id = tmp;
9146 #define _(a) else if (unformat (i, #a)) a = 1 ;
9147 foreach_create_subif_bit
9151 clib_warning ("parse error '%U'", format_unformat_error, i);
9156 if (sw_if_index_set == 0)
9158 errmsg ("missing interface name or sw_if_index");
9162 if (sub_id_set == 0)
9164 errmsg ("missing sub_id");
9167 M (CREATE_SUBIF, mp);
9169 mp->sw_if_index = ntohl (sw_if_index);
9170 mp->sub_id = ntohl (sub_id);
9172 #define _(a) mp->a = a;
9173 foreach_create_subif_bit;
9176 mp->outer_vlan_id = ntohs (outer_vlan_id);
9177 mp->inner_vlan_id = ntohs (inner_vlan_id);
9185 api_oam_add_del (vat_main_t * vam)
9187 unformat_input_t *i = vam->input;
9188 vl_api_oam_add_del_t *mp;
9191 ip4_address_t src, dst;
9196 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9198 if (unformat (i, "vrf %d", &vrf_id))
9200 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9202 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9204 else if (unformat (i, "del"))
9208 clib_warning ("parse error '%U'", format_unformat_error, i);
9215 errmsg ("missing src addr");
9221 errmsg ("missing dst addr");
9225 M (OAM_ADD_DEL, mp);
9227 mp->vrf_id = ntohl (vrf_id);
9228 mp->is_add = is_add;
9229 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9230 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9238 api_reset_fib (vat_main_t * vam)
9240 unformat_input_t *i = vam->input;
9241 vl_api_reset_fib_t *mp;
9247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9249 if (unformat (i, "vrf %d", &vrf_id))
9251 else if (unformat (i, "ipv6"))
9255 clib_warning ("parse error '%U'", format_unformat_error, i);
9260 if (vrf_id_set == 0)
9262 errmsg ("missing vrf id");
9268 mp->vrf_id = ntohl (vrf_id);
9269 mp->is_ipv6 = is_ipv6;
9277 api_dhcp_proxy_config (vat_main_t * vam)
9279 unformat_input_t *i = vam->input;
9280 vl_api_dhcp_proxy_config_t *mp;
9282 u32 server_vrf_id = 0;
9284 u8 v4_address_set = 0;
9285 u8 v6_address_set = 0;
9286 ip4_address_t v4address;
9287 ip6_address_t v6address;
9288 u8 v4_src_address_set = 0;
9289 u8 v6_src_address_set = 0;
9290 ip4_address_t v4srcaddress;
9291 ip6_address_t v6srcaddress;
9294 /* Parse args required to build the message */
9295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9297 if (unformat (i, "del"))
9299 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9301 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9303 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9305 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9307 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9308 v4_src_address_set = 1;
9309 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9310 v6_src_address_set = 1;
9315 if (v4_address_set && v6_address_set)
9317 errmsg ("both v4 and v6 server addresses set");
9320 if (!v4_address_set && !v6_address_set)
9322 errmsg ("no server addresses set");
9326 if (v4_src_address_set && v6_src_address_set)
9328 errmsg ("both v4 and v6 src addresses set");
9331 if (!v4_src_address_set && !v6_src_address_set)
9333 errmsg ("no src addresses set");
9337 if (!(v4_src_address_set && v4_address_set) &&
9338 !(v6_src_address_set && v6_address_set))
9340 errmsg ("no matching server and src addresses set");
9344 /* Construct the API message */
9345 M (DHCP_PROXY_CONFIG, mp);
9347 mp->is_add = is_add;
9348 mp->rx_vrf_id = ntohl (rx_vrf_id);
9349 mp->server_vrf_id = ntohl (server_vrf_id);
9353 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9354 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9358 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9359 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9365 /* Wait for a reply, return good/bad news */
9370 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9371 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9374 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9376 vat_main_t *vam = &vat_main;
9377 u32 i, count = mp->count;
9378 vl_api_dhcp_server_t *s;
9382 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9383 ntohl (mp->rx_vrf_id),
9384 format_ip6_address, mp->dhcp_src_address,
9385 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9388 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9389 ntohl (mp->rx_vrf_id),
9390 format_ip4_address, mp->dhcp_src_address,
9391 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9393 for (i = 0; i < count; i++)
9395 s = &mp->servers[i];
9399 " Server Table-ID %d, Server Address %U",
9400 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9403 " Server Table-ID %d, Server Address %U",
9404 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9408 static void vl_api_dhcp_proxy_details_t_handler_json
9409 (vl_api_dhcp_proxy_details_t * mp)
9411 vat_main_t *vam = &vat_main;
9412 vat_json_node_t *node = NULL;
9413 u32 i, count = mp->count;
9415 struct in6_addr ip6;
9416 vl_api_dhcp_server_t *s;
9418 if (VAT_JSON_ARRAY != vam->json_tree.type)
9420 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9421 vat_json_init_array (&vam->json_tree);
9423 node = vat_json_array_add (&vam->json_tree);
9425 vat_json_init_object (node);
9426 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9427 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9428 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9432 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9433 vat_json_object_add_ip6 (node, "src_address", ip6);
9437 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9438 vat_json_object_add_ip4 (node, "src_address", ip4);
9441 for (i = 0; i < count; i++)
9443 s = &mp->servers[i];
9445 vat_json_object_add_uint (node, "server-table-id",
9446 ntohl (s->server_vrf_id));
9450 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9451 vat_json_object_add_ip4 (node, "src_address", ip4);
9455 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9456 vat_json_object_add_ip6 (node, "server_address", ip6);
9462 api_dhcp_proxy_dump (vat_main_t * vam)
9464 unformat_input_t *i = vam->input;
9465 vl_api_control_ping_t *mp_ping;
9466 vl_api_dhcp_proxy_dump_t *mp;
9470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9472 if (unformat (i, "ipv6"))
9476 clib_warning ("parse error '%U'", format_unformat_error, i);
9481 M (DHCP_PROXY_DUMP, mp);
9483 mp->is_ip6 = is_ipv6;
9486 /* Use a control ping for synchronization */
9487 MPING (CONTROL_PING, mp_ping);
9495 api_dhcp_proxy_set_vss (vat_main_t * vam)
9497 unformat_input_t *i = vam->input;
9498 vl_api_dhcp_proxy_set_vss_t *mp;
9509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9511 if (unformat (i, "tbl_id %d", &tbl_id))
9513 if (unformat (i, "fib_id %d", &fib_id))
9515 if (unformat (i, "oui %d", &oui))
9517 else if (unformat (i, "ipv6"))
9519 else if (unformat (i, "del"))
9523 clib_warning ("parse error '%U'", format_unformat_error, i);
9528 if (tbl_id_set == 0)
9530 errmsg ("missing tbl id");
9534 if (fib_id_set == 0)
9536 errmsg ("missing fib id");
9541 errmsg ("missing oui");
9545 M (DHCP_PROXY_SET_VSS, mp);
9546 mp->tbl_id = ntohl (tbl_id);
9547 mp->fib_id = ntohl (fib_id);
9548 mp->oui = ntohl (oui);
9549 mp->is_ipv6 = is_ipv6;
9550 mp->is_add = is_add;
9558 api_dhcp_client_config (vat_main_t * vam)
9560 unformat_input_t *i = vam->input;
9561 vl_api_dhcp_client_config_t *mp;
9563 u8 sw_if_index_set = 0;
9566 u8 disable_event = 0;
9569 /* Parse args required to build the message */
9570 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9572 if (unformat (i, "del"))
9575 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9576 sw_if_index_set = 1;
9577 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9578 sw_if_index_set = 1;
9579 else if (unformat (i, "hostname %s", &hostname))
9581 else if (unformat (i, "disable_event"))
9587 if (sw_if_index_set == 0)
9589 errmsg ("missing interface name or sw_if_index");
9593 if (vec_len (hostname) > 63)
9595 errmsg ("hostname too long");
9597 vec_add1 (hostname, 0);
9599 /* Construct the API message */
9600 M (DHCP_CLIENT_CONFIG, mp);
9602 mp->sw_if_index = htonl (sw_if_index);
9603 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9604 vec_free (hostname);
9605 mp->is_add = is_add;
9606 mp->want_dhcp_event = disable_event ? 0 : 1;
9607 mp->pid = htonl (getpid ());
9612 /* Wait for a reply, return good/bad news */
9618 api_set_ip_flow_hash (vat_main_t * vam)
9620 unformat_input_t *i = vam->input;
9621 vl_api_set_ip_flow_hash_t *mp;
9633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9635 if (unformat (i, "vrf %d", &vrf_id))
9637 else if (unformat (i, "ipv6"))
9639 else if (unformat (i, "src"))
9641 else if (unformat (i, "dst"))
9643 else if (unformat (i, "sport"))
9645 else if (unformat (i, "dport"))
9647 else if (unformat (i, "proto"))
9649 else if (unformat (i, "reverse"))
9654 clib_warning ("parse error '%U'", format_unformat_error, i);
9659 if (vrf_id_set == 0)
9661 errmsg ("missing vrf id");
9665 M (SET_IP_FLOW_HASH, mp);
9671 mp->reverse = reverse;
9672 mp->vrf_id = ntohl (vrf_id);
9673 mp->is_ipv6 = is_ipv6;
9681 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9683 unformat_input_t *i = vam->input;
9684 vl_api_sw_interface_ip6_enable_disable_t *mp;
9686 u8 sw_if_index_set = 0;
9690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9692 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9693 sw_if_index_set = 1;
9694 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9695 sw_if_index_set = 1;
9696 else if (unformat (i, "enable"))
9698 else if (unformat (i, "disable"))
9702 clib_warning ("parse error '%U'", format_unformat_error, i);
9707 if (sw_if_index_set == 0)
9709 errmsg ("missing interface name or sw_if_index");
9713 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9715 mp->sw_if_index = ntohl (sw_if_index);
9716 mp->enable = enable;
9724 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9726 unformat_input_t *i = vam->input;
9727 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9729 u8 sw_if_index_set = 0;
9730 u8 v6_address_set = 0;
9731 ip6_address_t v6address;
9734 /* Parse args required to build the message */
9735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9737 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9738 sw_if_index_set = 1;
9739 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9740 sw_if_index_set = 1;
9741 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9747 if (sw_if_index_set == 0)
9749 errmsg ("missing interface name or sw_if_index");
9752 if (!v6_address_set)
9754 errmsg ("no address set");
9758 /* Construct the API message */
9759 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9761 mp->sw_if_index = ntohl (sw_if_index);
9762 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9767 /* Wait for a reply, return good/bad news */
9773 api_ip6nd_proxy_add_del (vat_main_t * vam)
9775 unformat_input_t *i = vam->input;
9776 vl_api_ip6nd_proxy_add_del_t *mp;
9777 u32 sw_if_index = ~0;
9778 u8 v6_address_set = 0;
9779 ip6_address_t v6address;
9783 /* Parse args required to build the message */
9784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9786 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9788 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9790 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9792 if (unformat (i, "del"))
9796 clib_warning ("parse error '%U'", format_unformat_error, i);
9801 if (sw_if_index == ~0)
9803 errmsg ("missing interface name or sw_if_index");
9806 if (!v6_address_set)
9808 errmsg ("no address set");
9812 /* Construct the API message */
9813 M (IP6ND_PROXY_ADD_DEL, mp);
9815 mp->is_del = is_del;
9816 mp->sw_if_index = ntohl (sw_if_index);
9817 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9822 /* Wait for a reply, return good/bad news */
9828 api_ip6nd_proxy_dump (vat_main_t * vam)
9830 vl_api_ip6nd_proxy_dump_t *mp;
9831 vl_api_control_ping_t *mp_ping;
9834 M (IP6ND_PROXY_DUMP, mp);
9838 /* Use a control ping for synchronization */
9839 MPING (CONTROL_PING, mp_ping);
9846 static void vl_api_ip6nd_proxy_details_t_handler
9847 (vl_api_ip6nd_proxy_details_t * mp)
9849 vat_main_t *vam = &vat_main;
9851 print (vam->ofp, "host %U sw_if_index %d",
9852 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
9855 static void vl_api_ip6nd_proxy_details_t_handler_json
9856 (vl_api_ip6nd_proxy_details_t * mp)
9858 vat_main_t *vam = &vat_main;
9859 struct in6_addr ip6;
9860 vat_json_node_t *node = NULL;
9862 if (VAT_JSON_ARRAY != vam->json_tree.type)
9864 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9865 vat_json_init_array (&vam->json_tree);
9867 node = vat_json_array_add (&vam->json_tree);
9869 vat_json_init_object (node);
9870 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9872 clib_memcpy (&ip6, mp->address, sizeof (ip6));
9873 vat_json_object_add_ip6 (node, "host", ip6);
9877 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9879 unformat_input_t *i = vam->input;
9880 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9882 u8 sw_if_index_set = 0;
9883 u32 address_length = 0;
9884 u8 v6_address_set = 0;
9885 ip6_address_t v6address;
9887 u8 no_advertise = 0;
9889 u8 no_autoconfig = 0;
9892 u32 val_lifetime = 0;
9893 u32 pref_lifetime = 0;
9896 /* Parse args required to build the message */
9897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9899 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9902 sw_if_index_set = 1;
9903 else if (unformat (i, "%U/%d",
9904 unformat_ip6_address, &v6address, &address_length))
9906 else if (unformat (i, "val_life %d", &val_lifetime))
9908 else if (unformat (i, "pref_life %d", &pref_lifetime))
9910 else if (unformat (i, "def"))
9912 else if (unformat (i, "noadv"))
9914 else if (unformat (i, "offl"))
9916 else if (unformat (i, "noauto"))
9918 else if (unformat (i, "nolink"))
9920 else if (unformat (i, "isno"))
9924 clib_warning ("parse error '%U'", format_unformat_error, i);
9929 if (sw_if_index_set == 0)
9931 errmsg ("missing interface name or sw_if_index");
9934 if (!v6_address_set)
9936 errmsg ("no address set");
9940 /* Construct the API message */
9941 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9943 mp->sw_if_index = ntohl (sw_if_index);
9944 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9945 mp->address_length = address_length;
9946 mp->use_default = use_default;
9947 mp->no_advertise = no_advertise;
9948 mp->off_link = off_link;
9949 mp->no_autoconfig = no_autoconfig;
9950 mp->no_onlink = no_onlink;
9952 mp->val_lifetime = ntohl (val_lifetime);
9953 mp->pref_lifetime = ntohl (pref_lifetime);
9958 /* Wait for a reply, return good/bad news */
9964 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9966 unformat_input_t *i = vam->input;
9967 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9969 u8 sw_if_index_set = 0;
9974 u8 send_unicast = 0;
9977 u8 default_router = 0;
9978 u32 max_interval = 0;
9979 u32 min_interval = 0;
9981 u32 initial_count = 0;
9982 u32 initial_interval = 0;
9986 /* Parse args required to build the message */
9987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9989 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9990 sw_if_index_set = 1;
9991 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9992 sw_if_index_set = 1;
9993 else if (unformat (i, "maxint %d", &max_interval))
9995 else if (unformat (i, "minint %d", &min_interval))
9997 else if (unformat (i, "life %d", &lifetime))
9999 else if (unformat (i, "count %d", &initial_count))
10001 else if (unformat (i, "interval %d", &initial_interval))
10003 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10005 else if (unformat (i, "managed"))
10007 else if (unformat (i, "other"))
10009 else if (unformat (i, "ll"))
10011 else if (unformat (i, "send"))
10013 else if (unformat (i, "cease"))
10015 else if (unformat (i, "isno"))
10017 else if (unformat (i, "def"))
10018 default_router = 1;
10021 clib_warning ("parse error '%U'", format_unformat_error, i);
10026 if (sw_if_index_set == 0)
10028 errmsg ("missing interface name or sw_if_index");
10032 /* Construct the API message */
10033 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10035 mp->sw_if_index = ntohl (sw_if_index);
10036 mp->max_interval = ntohl (max_interval);
10037 mp->min_interval = ntohl (min_interval);
10038 mp->lifetime = ntohl (lifetime);
10039 mp->initial_count = ntohl (initial_count);
10040 mp->initial_interval = ntohl (initial_interval);
10041 mp->suppress = suppress;
10042 mp->managed = managed;
10044 mp->ll_option = ll_option;
10045 mp->send_unicast = send_unicast;
10048 mp->default_router = default_router;
10053 /* Wait for a reply, return good/bad news */
10059 api_set_arp_neighbor_limit (vat_main_t * vam)
10061 unformat_input_t *i = vam->input;
10062 vl_api_set_arp_neighbor_limit_t *mp;
10068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10070 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10072 else if (unformat (i, "ipv6"))
10076 clib_warning ("parse error '%U'", format_unformat_error, i);
10081 if (limit_set == 0)
10083 errmsg ("missing limit value");
10087 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10089 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10090 mp->is_ipv6 = is_ipv6;
10098 api_l2_patch_add_del (vat_main_t * vam)
10100 unformat_input_t *i = vam->input;
10101 vl_api_l2_patch_add_del_t *mp;
10102 u32 rx_sw_if_index;
10103 u8 rx_sw_if_index_set = 0;
10104 u32 tx_sw_if_index;
10105 u8 tx_sw_if_index_set = 0;
10109 /* Parse args required to build the message */
10110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10112 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10113 rx_sw_if_index_set = 1;
10114 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10115 tx_sw_if_index_set = 1;
10116 else if (unformat (i, "rx"))
10118 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10120 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10122 rx_sw_if_index_set = 1;
10127 else if (unformat (i, "tx"))
10129 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10131 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10133 tx_sw_if_index_set = 1;
10138 else if (unformat (i, "del"))
10144 if (rx_sw_if_index_set == 0)
10146 errmsg ("missing rx interface name or rx_sw_if_index");
10150 if (tx_sw_if_index_set == 0)
10152 errmsg ("missing tx interface name or tx_sw_if_index");
10156 M (L2_PATCH_ADD_DEL, mp);
10158 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10159 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10160 mp->is_add = is_add;
10168 u8 localsid_addr[16];
10177 api_sr_localsid_add_del (vat_main_t * vam)
10179 unformat_input_t *i = vam->input;
10180 vl_api_sr_localsid_add_del_t *mp;
10183 ip6_address_t localsid;
10187 u32 fib_table = ~(u32) 0;
10188 ip6_address_t next_hop;
10190 bool nexthop_set = 0;
10194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10196 if (unformat (i, "del"))
10198 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10199 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10201 else if (unformat (i, "behavior %u", &behavior));
10202 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10203 else if (unformat (i, "fib-table %u", &fib_table));
10204 else if (unformat (i, "end.psp %u", &behavior));
10209 M (SR_LOCALSID_ADD_DEL, mp);
10211 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10213 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10214 mp->behavior = behavior;
10215 mp->sw_if_index = ntohl (sw_if_index);
10216 mp->fib_table = ntohl (fib_table);
10217 mp->end_psp = end_psp;
10218 mp->is_del = is_del;
10226 api_ioam_enable (vat_main_t * vam)
10228 unformat_input_t *input = vam->input;
10229 vl_api_ioam_enable_t *mp;
10231 int has_trace_option = 0;
10232 int has_pot_option = 0;
10233 int has_seqno_option = 0;
10234 int has_analyse_option = 0;
10237 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10239 if (unformat (input, "trace"))
10240 has_trace_option = 1;
10241 else if (unformat (input, "pot"))
10242 has_pot_option = 1;
10243 else if (unformat (input, "seqno"))
10244 has_seqno_option = 1;
10245 else if (unformat (input, "analyse"))
10246 has_analyse_option = 1;
10250 M (IOAM_ENABLE, mp);
10251 mp->id = htons (id);
10252 mp->seqno = has_seqno_option;
10253 mp->analyse = has_analyse_option;
10254 mp->pot_enable = has_pot_option;
10255 mp->trace_enable = has_trace_option;
10264 api_ioam_disable (vat_main_t * vam)
10266 vl_api_ioam_disable_t *mp;
10269 M (IOAM_DISABLE, mp);
10275 #define foreach_tcp_proto_field \
10279 #define foreach_udp_proto_field \
10283 #define foreach_ip4_proto_field \
10295 u16 src_port, dst_port;
10298 #if VPP_API_TEST_BUILTIN == 0
10300 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10302 u8 **maskp = va_arg (*args, u8 **);
10304 u8 found_something = 0;
10307 #define _(a) u8 a=0;
10308 foreach_tcp_proto_field;
10311 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10314 #define _(a) else if (unformat (input, #a)) a=1;
10315 foreach_tcp_proto_field
10321 #define _(a) found_something += a;
10322 foreach_tcp_proto_field;
10325 if (found_something == 0)
10328 vec_validate (mask, sizeof (*tcp) - 1);
10330 tcp = (tcp_header_t *) mask;
10332 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10333 foreach_tcp_proto_field;
10341 unformat_udp_mask (unformat_input_t * input, va_list * args)
10343 u8 **maskp = va_arg (*args, u8 **);
10345 u8 found_something = 0;
10348 #define _(a) u8 a=0;
10349 foreach_udp_proto_field;
10352 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10355 #define _(a) else if (unformat (input, #a)) a=1;
10356 foreach_udp_proto_field
10362 #define _(a) found_something += a;
10363 foreach_udp_proto_field;
10366 if (found_something == 0)
10369 vec_validate (mask, sizeof (*udp) - 1);
10371 udp = (udp_header_t *) mask;
10373 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10374 foreach_udp_proto_field;
10382 unformat_l4_mask (unformat_input_t * input, va_list * args)
10384 u8 **maskp = va_arg (*args, u8 **);
10385 u16 src_port = 0, dst_port = 0;
10386 tcpudp_header_t *tcpudp;
10388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10390 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10392 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10394 else if (unformat (input, "src_port"))
10396 else if (unformat (input, "dst_port"))
10402 if (!src_port && !dst_port)
10406 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10408 tcpudp = (tcpudp_header_t *) mask;
10409 tcpudp->src_port = src_port;
10410 tcpudp->dst_port = dst_port;
10418 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10420 u8 **maskp = va_arg (*args, u8 **);
10422 u8 found_something = 0;
10425 #define _(a) u8 a=0;
10426 foreach_ip4_proto_field;
10432 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10434 if (unformat (input, "version"))
10436 else if (unformat (input, "hdr_length"))
10438 else if (unformat (input, "src"))
10440 else if (unformat (input, "dst"))
10442 else if (unformat (input, "proto"))
10445 #define _(a) else if (unformat (input, #a)) a=1;
10446 foreach_ip4_proto_field
10452 #define _(a) found_something += a;
10453 foreach_ip4_proto_field;
10456 if (found_something == 0)
10459 vec_validate (mask, sizeof (*ip) - 1);
10461 ip = (ip4_header_t *) mask;
10463 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10464 foreach_ip4_proto_field;
10467 ip->ip_version_and_header_length = 0;
10470 ip->ip_version_and_header_length |= 0xF0;
10473 ip->ip_version_and_header_length |= 0x0F;
10479 #define foreach_ip6_proto_field \
10482 _(payload_length) \
10487 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10489 u8 **maskp = va_arg (*args, u8 **);
10491 u8 found_something = 0;
10493 u32 ip_version_traffic_class_and_flow_label;
10495 #define _(a) u8 a=0;
10496 foreach_ip6_proto_field;
10499 u8 traffic_class = 0;
10502 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10504 if (unformat (input, "version"))
10506 else if (unformat (input, "traffic-class"))
10508 else if (unformat (input, "flow-label"))
10510 else if (unformat (input, "src"))
10512 else if (unformat (input, "dst"))
10514 else if (unformat (input, "proto"))
10517 #define _(a) else if (unformat (input, #a)) a=1;
10518 foreach_ip6_proto_field
10524 #define _(a) found_something += a;
10525 foreach_ip6_proto_field;
10528 if (found_something == 0)
10531 vec_validate (mask, sizeof (*ip) - 1);
10533 ip = (ip6_header_t *) mask;
10535 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10536 foreach_ip6_proto_field;
10539 ip_version_traffic_class_and_flow_label = 0;
10542 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10545 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10548 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10550 ip->ip_version_traffic_class_and_flow_label =
10551 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10558 unformat_l3_mask (unformat_input_t * input, va_list * args)
10560 u8 **maskp = va_arg (*args, u8 **);
10562 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10564 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10566 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10575 unformat_l2_mask (unformat_input_t * input, va_list * args)
10577 u8 **maskp = va_arg (*args, u8 **);
10584 u8 ignore_tag1 = 0;
10585 u8 ignore_tag2 = 0;
10592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10594 if (unformat (input, "src"))
10596 else if (unformat (input, "dst"))
10598 else if (unformat (input, "proto"))
10600 else if (unformat (input, "tag1"))
10602 else if (unformat (input, "tag2"))
10604 else if (unformat (input, "ignore-tag1"))
10606 else if (unformat (input, "ignore-tag2"))
10608 else if (unformat (input, "cos1"))
10610 else if (unformat (input, "cos2"))
10612 else if (unformat (input, "dot1q"))
10614 else if (unformat (input, "dot1ad"))
10619 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10620 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10623 if (tag1 || ignore_tag1 || cos1 || dot1q)
10625 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10628 vec_validate (mask, len - 1);
10631 memset (mask, 0xff, 6);
10634 memset (mask + 6, 0xff, 6);
10636 if (tag2 || dot1ad)
10638 /* inner vlan tag */
10647 mask[21] = mask[20] = 0xff;
10668 mask[16] = mask[17] = 0xff;
10678 mask[12] = mask[13] = 0xff;
10685 unformat_classify_mask (unformat_input_t * input, va_list * args)
10687 u8 **maskp = va_arg (*args, u8 **);
10688 u32 *skipp = va_arg (*args, u32 *);
10689 u32 *matchp = va_arg (*args, u32 *);
10697 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10699 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10701 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10703 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10705 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10719 if (mask || l2 || l3 || l4)
10721 if (l2 || l3 || l4)
10723 /* "With a free Ethernet header in every package" */
10725 vec_validate (l2, 13);
10729 vec_append (mask, l3);
10734 vec_append (mask, l4);
10739 /* Scan forward looking for the first significant mask octet */
10740 for (i = 0; i < vec_len (mask); i++)
10744 /* compute (skip, match) params */
10745 *skipp = i / sizeof (u32x4);
10746 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10748 /* Pad mask to an even multiple of the vector size */
10749 while (vec_len (mask) % sizeof (u32x4))
10750 vec_add1 (mask, 0);
10752 match = vec_len (mask) / sizeof (u32x4);
10754 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10756 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10757 if (*tmp || *(tmp + 1))
10762 clib_warning ("BUG: match 0");
10764 _vec_len (mask) = match * sizeof (u32x4);
10774 #endif /* VPP_API_TEST_BUILTIN */
10776 #define foreach_l2_next \
10778 _(ethernet, ETHERNET_INPUT) \
10779 _(ip4, IP4_INPUT) \
10783 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10785 u32 *miss_next_indexp = va_arg (*args, u32 *);
10786 u32 next_index = 0;
10790 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10794 if (unformat (input, "%d", &tmp))
10803 *miss_next_indexp = next_index;
10807 #define foreach_ip_next \
10810 _(rewrite, REWRITE)
10813 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10815 u32 *miss_next_indexp = va_arg (*args, u32 *);
10816 u32 next_index = 0;
10820 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10824 if (unformat (input, "%d", &tmp))
10833 *miss_next_indexp = next_index;
10837 #define foreach_acl_next \
10841 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10843 u32 *miss_next_indexp = va_arg (*args, u32 *);
10844 u32 next_index = 0;
10848 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10852 if (unformat (input, "permit"))
10857 else if (unformat (input, "%d", &tmp))
10866 *miss_next_indexp = next_index;
10871 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10873 u32 *r = va_arg (*args, u32 *);
10875 if (unformat (input, "conform-color"))
10876 *r = POLICE_CONFORM;
10877 else if (unformat (input, "exceed-color"))
10878 *r = POLICE_EXCEED;
10886 api_classify_add_del_table (vat_main_t * vam)
10888 unformat_input_t *i = vam->input;
10889 vl_api_classify_add_del_table_t *mp;
10896 u32 table_index = ~0;
10897 u32 next_table_index = ~0;
10898 u32 miss_next_index = ~0;
10899 u32 memory_size = 32 << 20;
10901 u32 current_data_flag = 0;
10902 int current_data_offset = 0;
10905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10907 if (unformat (i, "del"))
10909 else if (unformat (i, "del-chain"))
10914 else if (unformat (i, "buckets %d", &nbuckets))
10916 else if (unformat (i, "memory_size %d", &memory_size))
10918 else if (unformat (i, "skip %d", &skip))
10920 else if (unformat (i, "match %d", &match))
10922 else if (unformat (i, "table %d", &table_index))
10924 else if (unformat (i, "mask %U", unformat_classify_mask,
10925 &mask, &skip, &match))
10927 else if (unformat (i, "next-table %d", &next_table_index))
10929 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10932 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10935 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10938 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10940 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10946 if (is_add && mask == 0)
10948 errmsg ("Mask required");
10952 if (is_add && skip == ~0)
10954 errmsg ("skip count required");
10958 if (is_add && match == ~0)
10960 errmsg ("match count required");
10964 if (!is_add && table_index == ~0)
10966 errmsg ("table index required for delete");
10970 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10972 mp->is_add = is_add;
10973 mp->del_chain = del_chain;
10974 mp->table_index = ntohl (table_index);
10975 mp->nbuckets = ntohl (nbuckets);
10976 mp->memory_size = ntohl (memory_size);
10977 mp->skip_n_vectors = ntohl (skip);
10978 mp->match_n_vectors = ntohl (match);
10979 mp->next_table_index = ntohl (next_table_index);
10980 mp->miss_next_index = ntohl (miss_next_index);
10981 mp->current_data_flag = ntohl (current_data_flag);
10982 mp->current_data_offset = ntohl (current_data_offset);
10983 clib_memcpy (mp->mask, mask, vec_len (mask));
10992 #if VPP_API_TEST_BUILTIN == 0
10994 unformat_l4_match (unformat_input_t * input, va_list * args)
10996 u8 **matchp = va_arg (*args, u8 **);
10998 u8 *proto_header = 0;
11004 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11006 if (unformat (input, "src_port %d", &src_port))
11008 else if (unformat (input, "dst_port %d", &dst_port))
11014 h.src_port = clib_host_to_net_u16 (src_port);
11015 h.dst_port = clib_host_to_net_u16 (dst_port);
11016 vec_validate (proto_header, sizeof (h) - 1);
11017 memcpy (proto_header, &h, sizeof (h));
11019 *matchp = proto_header;
11025 unformat_ip4_match (unformat_input_t * input, va_list * args)
11027 u8 **matchp = va_arg (*args, u8 **);
11032 int hdr_length = 0;
11033 u32 hdr_length_val;
11034 int src = 0, dst = 0;
11035 ip4_address_t src_val, dst_val;
11042 int fragment_id = 0;
11043 u32 fragment_id_val;
11049 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11051 if (unformat (input, "version %d", &version_val))
11053 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11055 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11057 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11059 else if (unformat (input, "proto %d", &proto_val))
11061 else if (unformat (input, "tos %d", &tos_val))
11063 else if (unformat (input, "length %d", &length_val))
11065 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11067 else if (unformat (input, "ttl %d", &ttl_val))
11069 else if (unformat (input, "checksum %d", &checksum_val))
11075 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11076 + ttl + checksum == 0)
11080 * Aligned because we use the real comparison functions
11082 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11084 ip = (ip4_header_t *) match;
11086 /* These are realistically matched in practice */
11088 ip->src_address.as_u32 = src_val.as_u32;
11091 ip->dst_address.as_u32 = dst_val.as_u32;
11094 ip->protocol = proto_val;
11097 /* These are not, but they're included for completeness */
11099 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11102 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11108 ip->length = clib_host_to_net_u16 (length_val);
11114 ip->checksum = clib_host_to_net_u16 (checksum_val);
11121 unformat_ip6_match (unformat_input_t * input, va_list * args)
11123 u8 **matchp = va_arg (*args, u8 **);
11128 u8 traffic_class = 0;
11129 u32 traffic_class_val = 0;
11132 int src = 0, dst = 0;
11133 ip6_address_t src_val, dst_val;
11136 int payload_length = 0;
11137 u32 payload_length_val;
11140 u32 ip_version_traffic_class_and_flow_label;
11142 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11144 if (unformat (input, "version %d", &version_val))
11146 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11148 else if (unformat (input, "flow_label %d", &flow_label_val))
11150 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11152 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11154 else if (unformat (input, "proto %d", &proto_val))
11156 else if (unformat (input, "payload_length %d", &payload_length_val))
11157 payload_length = 1;
11158 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11164 if (version + traffic_class + flow_label + src + dst + proto +
11165 payload_length + hop_limit == 0)
11169 * Aligned because we use the real comparison functions
11171 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11173 ip = (ip6_header_t *) match;
11176 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11179 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11182 ip->protocol = proto_val;
11184 ip_version_traffic_class_and_flow_label = 0;
11187 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11190 ip_version_traffic_class_and_flow_label |=
11191 (traffic_class_val & 0xFF) << 20;
11194 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11196 ip->ip_version_traffic_class_and_flow_label =
11197 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11199 if (payload_length)
11200 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11203 ip->hop_limit = hop_limit_val;
11210 unformat_l3_match (unformat_input_t * input, va_list * args)
11212 u8 **matchp = va_arg (*args, u8 **);
11214 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11216 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11218 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11227 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11229 u8 *tagp = va_arg (*args, u8 *);
11232 if (unformat (input, "%d", &tag))
11234 tagp[0] = (tag >> 8) & 0x0F;
11235 tagp[1] = tag & 0xFF;
11243 unformat_l2_match (unformat_input_t * input, va_list * args)
11245 u8 **matchp = va_arg (*args, u8 **);
11258 u8 ignore_tag1 = 0;
11259 u8 ignore_tag2 = 0;
11265 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11267 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11270 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11272 else if (unformat (input, "proto %U",
11273 unformat_ethernet_type_host_byte_order, &proto_val))
11275 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11277 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11279 else if (unformat (input, "ignore-tag1"))
11281 else if (unformat (input, "ignore-tag2"))
11283 else if (unformat (input, "cos1 %d", &cos1_val))
11285 else if (unformat (input, "cos2 %d", &cos2_val))
11290 if ((src + dst + proto + tag1 + tag2 +
11291 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11294 if (tag1 || ignore_tag1 || cos1)
11296 if (tag2 || ignore_tag2 || cos2)
11299 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11302 clib_memcpy (match, dst_val, 6);
11305 clib_memcpy (match + 6, src_val, 6);
11309 /* inner vlan tag */
11310 match[19] = tag2_val[1];
11311 match[18] = tag2_val[0];
11313 match[18] |= (cos2_val & 0x7) << 5;
11316 match[21] = proto_val & 0xff;
11317 match[20] = proto_val >> 8;
11321 match[15] = tag1_val[1];
11322 match[14] = tag1_val[0];
11325 match[14] |= (cos1_val & 0x7) << 5;
11331 match[15] = tag1_val[1];
11332 match[14] = tag1_val[0];
11335 match[17] = proto_val & 0xff;
11336 match[16] = proto_val >> 8;
11339 match[14] |= (cos1_val & 0x7) << 5;
11345 match[18] |= (cos2_val & 0x7) << 5;
11347 match[14] |= (cos1_val & 0x7) << 5;
11350 match[13] = proto_val & 0xff;
11351 match[12] = proto_val >> 8;
11360 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11362 u8 **matchp = va_arg (*args, u8 **);
11363 u32 skip_n_vectors = va_arg (*args, u32);
11364 u32 match_n_vectors = va_arg (*args, u32);
11371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11373 if (unformat (input, "hex %U", unformat_hex_string, &match))
11375 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11377 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11379 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11393 if (match || l2 || l3 || l4)
11395 if (l2 || l3 || l4)
11397 /* "Win a free Ethernet header in every packet" */
11399 vec_validate_aligned (l2, 13, sizeof (u32x4));
11403 vec_append_aligned (match, l3, sizeof (u32x4));
11408 vec_append_aligned (match, l4, sizeof (u32x4));
11413 /* Make sure the vector is big enough even if key is all 0's */
11414 vec_validate_aligned
11415 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11418 /* Set size, include skipped vectors */
11419 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11430 api_classify_add_del_session (vat_main_t * vam)
11432 unformat_input_t *i = vam->input;
11433 vl_api_classify_add_del_session_t *mp;
11435 u32 table_index = ~0;
11436 u32 hit_next_index = ~0;
11437 u32 opaque_index = ~0;
11440 u32 skip_n_vectors = 0;
11441 u32 match_n_vectors = 0;
11447 * Warning: you have to supply skip_n and match_n
11448 * because the API client cant simply look at the classify
11452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11454 if (unformat (i, "del"))
11456 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11459 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11462 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11465 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11467 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11469 else if (unformat (i, "opaque-index %d", &opaque_index))
11471 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11473 else if (unformat (i, "match_n %d", &match_n_vectors))
11475 else if (unformat (i, "match %U", api_unformat_classify_match,
11476 &match, skip_n_vectors, match_n_vectors))
11478 else if (unformat (i, "advance %d", &advance))
11480 else if (unformat (i, "table-index %d", &table_index))
11482 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11484 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11486 else if (unformat (i, "action %d", &action))
11488 else if (unformat (i, "metadata %d", &metadata))
11494 if (table_index == ~0)
11496 errmsg ("Table index required");
11500 if (is_add && match == 0)
11502 errmsg ("Match value required");
11506 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11508 mp->is_add = is_add;
11509 mp->table_index = ntohl (table_index);
11510 mp->hit_next_index = ntohl (hit_next_index);
11511 mp->opaque_index = ntohl (opaque_index);
11512 mp->advance = ntohl (advance);
11513 mp->action = action;
11514 mp->metadata = ntohl (metadata);
11515 clib_memcpy (mp->match, match, vec_len (match));
11524 api_classify_set_interface_ip_table (vat_main_t * vam)
11526 unformat_input_t *i = vam->input;
11527 vl_api_classify_set_interface_ip_table_t *mp;
11529 int sw_if_index_set;
11530 u32 table_index = ~0;
11534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11536 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11537 sw_if_index_set = 1;
11538 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11539 sw_if_index_set = 1;
11540 else if (unformat (i, "table %d", &table_index))
11544 clib_warning ("parse error '%U'", format_unformat_error, i);
11549 if (sw_if_index_set == 0)
11551 errmsg ("missing interface name or sw_if_index");
11556 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11558 mp->sw_if_index = ntohl (sw_if_index);
11559 mp->table_index = ntohl (table_index);
11560 mp->is_ipv6 = is_ipv6;
11568 api_classify_set_interface_l2_tables (vat_main_t * vam)
11570 unformat_input_t *i = vam->input;
11571 vl_api_classify_set_interface_l2_tables_t *mp;
11573 int sw_if_index_set;
11574 u32 ip4_table_index = ~0;
11575 u32 ip6_table_index = ~0;
11576 u32 other_table_index = ~0;
11580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11582 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11583 sw_if_index_set = 1;
11584 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11585 sw_if_index_set = 1;
11586 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11588 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11590 else if (unformat (i, "other-table %d", &other_table_index))
11592 else if (unformat (i, "is-input %d", &is_input))
11596 clib_warning ("parse error '%U'", format_unformat_error, i);
11601 if (sw_if_index_set == 0)
11603 errmsg ("missing interface name or sw_if_index");
11608 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11610 mp->sw_if_index = ntohl (sw_if_index);
11611 mp->ip4_table_index = ntohl (ip4_table_index);
11612 mp->ip6_table_index = ntohl (ip6_table_index);
11613 mp->other_table_index = ntohl (other_table_index);
11614 mp->is_input = (u8) is_input;
11622 api_set_ipfix_exporter (vat_main_t * vam)
11624 unformat_input_t *i = vam->input;
11625 vl_api_set_ipfix_exporter_t *mp;
11626 ip4_address_t collector_address;
11627 u8 collector_address_set = 0;
11628 u32 collector_port = ~0;
11629 ip4_address_t src_address;
11630 u8 src_address_set = 0;
11633 u32 template_interval = ~0;
11634 u8 udp_checksum = 0;
11637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11639 if (unformat (i, "collector_address %U", unformat_ip4_address,
11640 &collector_address))
11641 collector_address_set = 1;
11642 else if (unformat (i, "collector_port %d", &collector_port))
11644 else if (unformat (i, "src_address %U", unformat_ip4_address,
11646 src_address_set = 1;
11647 else if (unformat (i, "vrf_id %d", &vrf_id))
11649 else if (unformat (i, "path_mtu %d", &path_mtu))
11651 else if (unformat (i, "template_interval %d", &template_interval))
11653 else if (unformat (i, "udp_checksum"))
11659 if (collector_address_set == 0)
11661 errmsg ("collector_address required");
11665 if (src_address_set == 0)
11667 errmsg ("src_address required");
11671 M (SET_IPFIX_EXPORTER, mp);
11673 memcpy (mp->collector_address, collector_address.data,
11674 sizeof (collector_address.data));
11675 mp->collector_port = htons ((u16) collector_port);
11676 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11677 mp->vrf_id = htonl (vrf_id);
11678 mp->path_mtu = htonl (path_mtu);
11679 mp->template_interval = htonl (template_interval);
11680 mp->udp_checksum = udp_checksum;
11688 api_set_ipfix_classify_stream (vat_main_t * vam)
11690 unformat_input_t *i = vam->input;
11691 vl_api_set_ipfix_classify_stream_t *mp;
11693 u32 src_port = UDP_DST_PORT_ipfix;
11696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11698 if (unformat (i, "domain %d", &domain_id))
11700 else if (unformat (i, "src_port %d", &src_port))
11704 errmsg ("unknown input `%U'", format_unformat_error, i);
11709 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11711 mp->domain_id = htonl (domain_id);
11712 mp->src_port = htons ((u16) src_port);
11720 api_ipfix_classify_table_add_del (vat_main_t * vam)
11722 unformat_input_t *i = vam->input;
11723 vl_api_ipfix_classify_table_add_del_t *mp;
11725 u32 classify_table_index = ~0;
11727 u8 transport_protocol = 255;
11730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11732 if (unformat (i, "add"))
11734 else if (unformat (i, "del"))
11736 else if (unformat (i, "table %d", &classify_table_index))
11738 else if (unformat (i, "ip4"))
11740 else if (unformat (i, "ip6"))
11742 else if (unformat (i, "tcp"))
11743 transport_protocol = 6;
11744 else if (unformat (i, "udp"))
11745 transport_protocol = 17;
11748 errmsg ("unknown input `%U'", format_unformat_error, i);
11755 errmsg ("expecting: add|del");
11758 if (classify_table_index == ~0)
11760 errmsg ("classifier table not specified");
11763 if (ip_version == 0)
11765 errmsg ("IP version not specified");
11769 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11771 mp->is_add = is_add;
11772 mp->table_id = htonl (classify_table_index);
11773 mp->ip_version = ip_version;
11774 mp->transport_protocol = transport_protocol;
11782 api_get_node_index (vat_main_t * vam)
11784 unformat_input_t *i = vam->input;
11785 vl_api_get_node_index_t *mp;
11789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11791 if (unformat (i, "node %s", &name))
11798 errmsg ("node name required");
11801 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11803 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11807 M (GET_NODE_INDEX, mp);
11808 clib_memcpy (mp->node_name, name, vec_len (name));
11817 api_get_next_index (vat_main_t * vam)
11819 unformat_input_t *i = vam->input;
11820 vl_api_get_next_index_t *mp;
11821 u8 *node_name = 0, *next_node_name = 0;
11824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11826 if (unformat (i, "node-name %s", &node_name))
11828 else if (unformat (i, "next-node-name %s", &next_node_name))
11832 if (node_name == 0)
11834 errmsg ("node name required");
11837 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11839 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11843 if (next_node_name == 0)
11845 errmsg ("next node name required");
11848 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11850 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11854 M (GET_NEXT_INDEX, mp);
11855 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11856 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11857 vec_free (node_name);
11858 vec_free (next_node_name);
11866 api_add_node_next (vat_main_t * vam)
11868 unformat_input_t *i = vam->input;
11869 vl_api_add_node_next_t *mp;
11874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11876 if (unformat (i, "node %s", &name))
11878 else if (unformat (i, "next %s", &next))
11885 errmsg ("node name required");
11888 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11890 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11895 errmsg ("next node required");
11898 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11900 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11904 M (ADD_NODE_NEXT, mp);
11905 clib_memcpy (mp->node_name, name, vec_len (name));
11906 clib_memcpy (mp->next_name, next, vec_len (next));
11916 api_l2tpv3_create_tunnel (vat_main_t * vam)
11918 unformat_input_t *i = vam->input;
11919 ip6_address_t client_address, our_address;
11920 int client_address_set = 0;
11921 int our_address_set = 0;
11922 u32 local_session_id = 0;
11923 u32 remote_session_id = 0;
11924 u64 local_cookie = 0;
11925 u64 remote_cookie = 0;
11926 u8 l2_sublayer_present = 0;
11927 vl_api_l2tpv3_create_tunnel_t *mp;
11930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11932 if (unformat (i, "client_address %U", unformat_ip6_address,
11934 client_address_set = 1;
11935 else if (unformat (i, "our_address %U", unformat_ip6_address,
11937 our_address_set = 1;
11938 else if (unformat (i, "local_session_id %d", &local_session_id))
11940 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11942 else if (unformat (i, "local_cookie %lld", &local_cookie))
11944 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11946 else if (unformat (i, "l2-sublayer-present"))
11947 l2_sublayer_present = 1;
11952 if (client_address_set == 0)
11954 errmsg ("client_address required");
11958 if (our_address_set == 0)
11960 errmsg ("our_address required");
11964 M (L2TPV3_CREATE_TUNNEL, mp);
11966 clib_memcpy (mp->client_address, client_address.as_u8,
11967 sizeof (mp->client_address));
11969 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11971 mp->local_session_id = ntohl (local_session_id);
11972 mp->remote_session_id = ntohl (remote_session_id);
11973 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11974 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11975 mp->l2_sublayer_present = l2_sublayer_present;
11984 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11986 unformat_input_t *i = vam->input;
11988 u8 sw_if_index_set = 0;
11989 u64 new_local_cookie = 0;
11990 u64 new_remote_cookie = 0;
11991 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11996 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11997 sw_if_index_set = 1;
11998 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11999 sw_if_index_set = 1;
12000 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12002 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12008 if (sw_if_index_set == 0)
12010 errmsg ("missing interface name or sw_if_index");
12014 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12016 mp->sw_if_index = ntohl (sw_if_index);
12017 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12018 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12026 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12028 unformat_input_t *i = vam->input;
12029 vl_api_l2tpv3_interface_enable_disable_t *mp;
12031 u8 sw_if_index_set = 0;
12032 u8 enable_disable = 1;
12035 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12037 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12038 sw_if_index_set = 1;
12039 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12040 sw_if_index_set = 1;
12041 else if (unformat (i, "enable"))
12042 enable_disable = 1;
12043 else if (unformat (i, "disable"))
12044 enable_disable = 0;
12049 if (sw_if_index_set == 0)
12051 errmsg ("missing interface name or sw_if_index");
12055 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12057 mp->sw_if_index = ntohl (sw_if_index);
12058 mp->enable_disable = enable_disable;
12066 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12068 unformat_input_t *i = vam->input;
12069 vl_api_l2tpv3_set_lookup_key_t *mp;
12073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12075 if (unformat (i, "lookup_v6_src"))
12076 key = L2T_LOOKUP_SRC_ADDRESS;
12077 else if (unformat (i, "lookup_v6_dst"))
12078 key = L2T_LOOKUP_DST_ADDRESS;
12079 else if (unformat (i, "lookup_session_id"))
12080 key = L2T_LOOKUP_SESSION_ID;
12085 if (key == (u8) ~ 0)
12087 errmsg ("l2tp session lookup key unset");
12091 M (L2TPV3_SET_LOOKUP_KEY, mp);
12100 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12101 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12103 vat_main_t *vam = &vat_main;
12105 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12106 format_ip6_address, mp->our_address,
12107 format_ip6_address, mp->client_address,
12108 clib_net_to_host_u32 (mp->sw_if_index));
12111 " local cookies %016llx %016llx remote cookie %016llx",
12112 clib_net_to_host_u64 (mp->local_cookie[0]),
12113 clib_net_to_host_u64 (mp->local_cookie[1]),
12114 clib_net_to_host_u64 (mp->remote_cookie));
12116 print (vam->ofp, " local session-id %d remote session-id %d",
12117 clib_net_to_host_u32 (mp->local_session_id),
12118 clib_net_to_host_u32 (mp->remote_session_id));
12120 print (vam->ofp, " l2 specific sublayer %s\n",
12121 mp->l2_sublayer_present ? "preset" : "absent");
12125 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12126 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12128 vat_main_t *vam = &vat_main;
12129 vat_json_node_t *node = NULL;
12130 struct in6_addr addr;
12132 if (VAT_JSON_ARRAY != vam->json_tree.type)
12134 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12135 vat_json_init_array (&vam->json_tree);
12137 node = vat_json_array_add (&vam->json_tree);
12139 vat_json_init_object (node);
12141 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12142 vat_json_object_add_ip6 (node, "our_address", addr);
12143 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12144 vat_json_object_add_ip6 (node, "client_address", addr);
12146 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12147 vat_json_init_array (lc);
12148 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12149 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12150 vat_json_object_add_uint (node, "remote_cookie",
12151 clib_net_to_host_u64 (mp->remote_cookie));
12153 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12154 vat_json_object_add_uint (node, "local_session_id",
12155 clib_net_to_host_u32 (mp->local_session_id));
12156 vat_json_object_add_uint (node, "remote_session_id",
12157 clib_net_to_host_u32 (mp->remote_session_id));
12158 vat_json_object_add_string_copy (node, "l2_sublayer",
12159 mp->l2_sublayer_present ? (u8 *) "present"
12160 : (u8 *) "absent");
12164 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12166 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12167 vl_api_control_ping_t *mp_ping;
12170 /* Get list of l2tpv3-tunnel interfaces */
12171 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12174 /* Use a control ping for synchronization */
12175 MPING (CONTROL_PING, mp_ping);
12183 static void vl_api_sw_interface_tap_details_t_handler
12184 (vl_api_sw_interface_tap_details_t * mp)
12186 vat_main_t *vam = &vat_main;
12188 print (vam->ofp, "%-16s %d",
12189 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12192 static void vl_api_sw_interface_tap_details_t_handler_json
12193 (vl_api_sw_interface_tap_details_t * mp)
12195 vat_main_t *vam = &vat_main;
12196 vat_json_node_t *node = NULL;
12198 if (VAT_JSON_ARRAY != vam->json_tree.type)
12200 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12201 vat_json_init_array (&vam->json_tree);
12203 node = vat_json_array_add (&vam->json_tree);
12205 vat_json_init_object (node);
12206 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12207 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12211 api_sw_interface_tap_dump (vat_main_t * vam)
12213 vl_api_sw_interface_tap_dump_t *mp;
12214 vl_api_control_ping_t *mp_ping;
12217 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12218 /* Get list of tap interfaces */
12219 M (SW_INTERFACE_TAP_DUMP, mp);
12222 /* Use a control ping for synchronization */
12223 MPING (CONTROL_PING, mp_ping);
12230 static uword unformat_vxlan_decap_next
12231 (unformat_input_t * input, va_list * args)
12233 u32 *result = va_arg (*args, u32 *);
12236 if (unformat (input, "l2"))
12237 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12238 else if (unformat (input, "%d", &tmp))
12246 api_vxlan_add_del_tunnel (vat_main_t * vam)
12248 unformat_input_t *line_input = vam->input;
12249 vl_api_vxlan_add_del_tunnel_t *mp;
12250 ip46_address_t src, dst;
12252 u8 ipv4_set = 0, ipv6_set = 0;
12256 u32 mcast_sw_if_index = ~0;
12257 u32 encap_vrf_id = 0;
12258 u32 decap_next_index = ~0;
12262 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12263 memset (&src, 0, sizeof src);
12264 memset (&dst, 0, sizeof dst);
12266 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12268 if (unformat (line_input, "del"))
12271 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12277 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12283 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12289 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12294 else if (unformat (line_input, "group %U %U",
12295 unformat_ip4_address, &dst.ip4,
12296 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12298 grp_set = dst_set = 1;
12301 else if (unformat (line_input, "group %U",
12302 unformat_ip4_address, &dst.ip4))
12304 grp_set = dst_set = 1;
12307 else if (unformat (line_input, "group %U %U",
12308 unformat_ip6_address, &dst.ip6,
12309 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12311 grp_set = dst_set = 1;
12314 else if (unformat (line_input, "group %U",
12315 unformat_ip6_address, &dst.ip6))
12317 grp_set = dst_set = 1;
12321 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12323 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12325 else if (unformat (line_input, "decap-next %U",
12326 unformat_vxlan_decap_next, &decap_next_index))
12328 else if (unformat (line_input, "vni %d", &vni))
12332 errmsg ("parse error '%U'", format_unformat_error, line_input);
12339 errmsg ("tunnel src address not specified");
12344 errmsg ("tunnel dst address not specified");
12348 if (grp_set && !ip46_address_is_multicast (&dst))
12350 errmsg ("tunnel group address not multicast");
12353 if (grp_set && mcast_sw_if_index == ~0)
12355 errmsg ("tunnel nonexistent multicast device");
12358 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12360 errmsg ("tunnel dst address must be unicast");
12365 if (ipv4_set && ipv6_set)
12367 errmsg ("both IPv4 and IPv6 addresses specified");
12371 if ((vni == 0) || (vni >> 24))
12373 errmsg ("vni not specified or out of range");
12377 M (VXLAN_ADD_DEL_TUNNEL, mp);
12381 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12382 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12386 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12387 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12389 mp->encap_vrf_id = ntohl (encap_vrf_id);
12390 mp->decap_next_index = ntohl (decap_next_index);
12391 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12392 mp->vni = ntohl (vni);
12393 mp->is_add = is_add;
12394 mp->is_ipv6 = ipv6_set;
12401 static void vl_api_vxlan_tunnel_details_t_handler
12402 (vl_api_vxlan_tunnel_details_t * mp)
12404 vat_main_t *vam = &vat_main;
12405 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12406 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12408 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12409 ntohl (mp->sw_if_index),
12410 format_ip46_address, &src, IP46_TYPE_ANY,
12411 format_ip46_address, &dst, IP46_TYPE_ANY,
12412 ntohl (mp->encap_vrf_id),
12413 ntohl (mp->decap_next_index), ntohl (mp->vni),
12414 ntohl (mp->mcast_sw_if_index));
12417 static void vl_api_vxlan_tunnel_details_t_handler_json
12418 (vl_api_vxlan_tunnel_details_t * mp)
12420 vat_main_t *vam = &vat_main;
12421 vat_json_node_t *node = NULL;
12423 if (VAT_JSON_ARRAY != vam->json_tree.type)
12425 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12426 vat_json_init_array (&vam->json_tree);
12428 node = vat_json_array_add (&vam->json_tree);
12430 vat_json_init_object (node);
12431 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12434 struct in6_addr ip6;
12436 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12437 vat_json_object_add_ip6 (node, "src_address", ip6);
12438 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12439 vat_json_object_add_ip6 (node, "dst_address", ip6);
12443 struct in_addr ip4;
12445 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12446 vat_json_object_add_ip4 (node, "src_address", ip4);
12447 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12448 vat_json_object_add_ip4 (node, "dst_address", ip4);
12450 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12451 vat_json_object_add_uint (node, "decap_next_index",
12452 ntohl (mp->decap_next_index));
12453 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12454 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12455 vat_json_object_add_uint (node, "mcast_sw_if_index",
12456 ntohl (mp->mcast_sw_if_index));
12460 api_vxlan_tunnel_dump (vat_main_t * vam)
12462 unformat_input_t *i = vam->input;
12463 vl_api_vxlan_tunnel_dump_t *mp;
12464 vl_api_control_ping_t *mp_ping;
12466 u8 sw_if_index_set = 0;
12469 /* Parse args required to build the message */
12470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12472 if (unformat (i, "sw_if_index %d", &sw_if_index))
12473 sw_if_index_set = 1;
12478 if (sw_if_index_set == 0)
12483 if (!vam->json_output)
12485 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12486 "sw_if_index", "src_address", "dst_address",
12487 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12490 /* Get list of vxlan-tunnel interfaces */
12491 M (VXLAN_TUNNEL_DUMP, mp);
12493 mp->sw_if_index = htonl (sw_if_index);
12497 /* Use a control ping for synchronization */
12498 MPING (CONTROL_PING, mp_ping);
12505 static uword unformat_geneve_decap_next
12506 (unformat_input_t * input, va_list * args)
12508 u32 *result = va_arg (*args, u32 *);
12511 if (unformat (input, "l2"))
12512 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12513 else if (unformat (input, "%d", &tmp))
12521 api_geneve_add_del_tunnel (vat_main_t * vam)
12523 unformat_input_t *line_input = vam->input;
12524 vl_api_geneve_add_del_tunnel_t *mp;
12525 ip46_address_t src, dst;
12527 u8 ipv4_set = 0, ipv6_set = 0;
12531 u32 mcast_sw_if_index = ~0;
12532 u32 encap_vrf_id = 0;
12533 u32 decap_next_index = ~0;
12537 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12538 memset (&src, 0, sizeof src);
12539 memset (&dst, 0, sizeof dst);
12541 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12543 if (unformat (line_input, "del"))
12546 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12552 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12558 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12564 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12569 else if (unformat (line_input, "group %U %U",
12570 unformat_ip4_address, &dst.ip4,
12571 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12573 grp_set = dst_set = 1;
12576 else if (unformat (line_input, "group %U",
12577 unformat_ip4_address, &dst.ip4))
12579 grp_set = dst_set = 1;
12582 else if (unformat (line_input, "group %U %U",
12583 unformat_ip6_address, &dst.ip6,
12584 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12586 grp_set = dst_set = 1;
12589 else if (unformat (line_input, "group %U",
12590 unformat_ip6_address, &dst.ip6))
12592 grp_set = dst_set = 1;
12596 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12598 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12600 else if (unformat (line_input, "decap-next %U",
12601 unformat_geneve_decap_next, &decap_next_index))
12603 else if (unformat (line_input, "vni %d", &vni))
12607 errmsg ("parse error '%U'", format_unformat_error, line_input);
12614 errmsg ("tunnel src address not specified");
12619 errmsg ("tunnel dst address not specified");
12623 if (grp_set && !ip46_address_is_multicast (&dst))
12625 errmsg ("tunnel group address not multicast");
12628 if (grp_set && mcast_sw_if_index == ~0)
12630 errmsg ("tunnel nonexistent multicast device");
12633 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12635 errmsg ("tunnel dst address must be unicast");
12640 if (ipv4_set && ipv6_set)
12642 errmsg ("both IPv4 and IPv6 addresses specified");
12646 if ((vni == 0) || (vni >> 24))
12648 errmsg ("vni not specified or out of range");
12652 M (GENEVE_ADD_DEL_TUNNEL, mp);
12656 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12657 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12661 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12662 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12664 mp->encap_vrf_id = ntohl (encap_vrf_id);
12665 mp->decap_next_index = ntohl (decap_next_index);
12666 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12667 mp->vni = ntohl (vni);
12668 mp->is_add = is_add;
12669 mp->is_ipv6 = ipv6_set;
12676 static void vl_api_geneve_tunnel_details_t_handler
12677 (vl_api_geneve_tunnel_details_t * mp)
12679 vat_main_t *vam = &vat_main;
12680 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12681 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12683 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12684 ntohl (mp->sw_if_index),
12685 format_ip46_address, &src, IP46_TYPE_ANY,
12686 format_ip46_address, &dst, IP46_TYPE_ANY,
12687 ntohl (mp->encap_vrf_id),
12688 ntohl (mp->decap_next_index), ntohl (mp->vni),
12689 ntohl (mp->mcast_sw_if_index));
12692 static void vl_api_geneve_tunnel_details_t_handler_json
12693 (vl_api_geneve_tunnel_details_t * mp)
12695 vat_main_t *vam = &vat_main;
12696 vat_json_node_t *node = NULL;
12698 if (VAT_JSON_ARRAY != vam->json_tree.type)
12700 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12701 vat_json_init_array (&vam->json_tree);
12703 node = vat_json_array_add (&vam->json_tree);
12705 vat_json_init_object (node);
12706 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12709 struct in6_addr ip6;
12711 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12712 vat_json_object_add_ip6 (node, "src_address", ip6);
12713 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12714 vat_json_object_add_ip6 (node, "dst_address", ip6);
12718 struct in_addr ip4;
12720 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12721 vat_json_object_add_ip4 (node, "src_address", ip4);
12722 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12723 vat_json_object_add_ip4 (node, "dst_address", ip4);
12725 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12726 vat_json_object_add_uint (node, "decap_next_index",
12727 ntohl (mp->decap_next_index));
12728 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12729 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12730 vat_json_object_add_uint (node, "mcast_sw_if_index",
12731 ntohl (mp->mcast_sw_if_index));
12735 api_geneve_tunnel_dump (vat_main_t * vam)
12737 unformat_input_t *i = vam->input;
12738 vl_api_geneve_tunnel_dump_t *mp;
12739 vl_api_control_ping_t *mp_ping;
12741 u8 sw_if_index_set = 0;
12744 /* Parse args required to build the message */
12745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12747 if (unformat (i, "sw_if_index %d", &sw_if_index))
12748 sw_if_index_set = 1;
12753 if (sw_if_index_set == 0)
12758 if (!vam->json_output)
12760 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12761 "sw_if_index", "local_address", "remote_address",
12762 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12765 /* Get list of geneve-tunnel interfaces */
12766 M (GENEVE_TUNNEL_DUMP, mp);
12768 mp->sw_if_index = htonl (sw_if_index);
12772 /* Use a control ping for synchronization */
12773 M (CONTROL_PING, mp_ping);
12781 api_gre_add_del_tunnel (vat_main_t * vam)
12783 unformat_input_t *line_input = vam->input;
12784 vl_api_gre_add_del_tunnel_t *mp;
12785 ip4_address_t src4, dst4;
12786 ip6_address_t src6, dst6;
12793 u32 outer_fib_id = 0;
12796 memset (&src4, 0, sizeof src4);
12797 memset (&dst4, 0, sizeof dst4);
12798 memset (&src6, 0, sizeof src6);
12799 memset (&dst6, 0, sizeof dst6);
12801 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12803 if (unformat (line_input, "del"))
12805 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
12810 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
12815 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
12820 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
12825 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
12827 else if (unformat (line_input, "teb"))
12831 errmsg ("parse error '%U'", format_unformat_error, line_input);
12838 errmsg ("tunnel src address not specified");
12843 errmsg ("tunnel dst address not specified");
12846 if (ipv4_set && ipv6_set)
12848 errmsg ("both IPv4 and IPv6 addresses specified");
12853 M (GRE_ADD_DEL_TUNNEL, mp);
12857 clib_memcpy (&mp->src_address, &src4, 4);
12858 clib_memcpy (&mp->dst_address, &dst4, 4);
12862 clib_memcpy (&mp->src_address, &src6, 16);
12863 clib_memcpy (&mp->dst_address, &dst6, 16);
12865 mp->outer_fib_id = ntohl (outer_fib_id);
12866 mp->is_add = is_add;
12868 mp->is_ipv6 = ipv6_set;
12875 static void vl_api_gre_tunnel_details_t_handler
12876 (vl_api_gre_tunnel_details_t * mp)
12878 vat_main_t *vam = &vat_main;
12879 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
12880 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
12882 print (vam->ofp, "%11d%24U%24U%6d%14d",
12883 ntohl (mp->sw_if_index),
12884 format_ip46_address, &src, IP46_TYPE_ANY,
12885 format_ip46_address, &dst, IP46_TYPE_ANY,
12886 mp->teb, ntohl (mp->outer_fib_id));
12889 static void vl_api_gre_tunnel_details_t_handler_json
12890 (vl_api_gre_tunnel_details_t * mp)
12892 vat_main_t *vam = &vat_main;
12893 vat_json_node_t *node = NULL;
12894 struct in_addr ip4;
12895 struct in6_addr ip6;
12897 if (VAT_JSON_ARRAY != vam->json_tree.type)
12899 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12900 vat_json_init_array (&vam->json_tree);
12902 node = vat_json_array_add (&vam->json_tree);
12904 vat_json_init_object (node);
12905 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12908 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
12909 vat_json_object_add_ip4 (node, "src_address", ip4);
12910 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
12911 vat_json_object_add_ip4 (node, "dst_address", ip4);
12915 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
12916 vat_json_object_add_ip6 (node, "src_address", ip6);
12917 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
12918 vat_json_object_add_ip6 (node, "dst_address", ip6);
12920 vat_json_object_add_uint (node, "teb", mp->teb);
12921 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
12922 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
12926 api_gre_tunnel_dump (vat_main_t * vam)
12928 unformat_input_t *i = vam->input;
12929 vl_api_gre_tunnel_dump_t *mp;
12930 vl_api_control_ping_t *mp_ping;
12932 u8 sw_if_index_set = 0;
12935 /* Parse args required to build the message */
12936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12938 if (unformat (i, "sw_if_index %d", &sw_if_index))
12939 sw_if_index_set = 1;
12944 if (sw_if_index_set == 0)
12949 if (!vam->json_output)
12951 print (vam->ofp, "%11s%24s%24s%6s%14s",
12952 "sw_if_index", "src_address", "dst_address", "teb",
12956 /* Get list of gre-tunnel interfaces */
12957 M (GRE_TUNNEL_DUMP, mp);
12959 mp->sw_if_index = htonl (sw_if_index);
12963 /* Use a control ping for synchronization */
12964 MPING (CONTROL_PING, mp_ping);
12972 api_l2_fib_clear_table (vat_main_t * vam)
12974 // unformat_input_t * i = vam->input;
12975 vl_api_l2_fib_clear_table_t *mp;
12978 M (L2_FIB_CLEAR_TABLE, mp);
12986 api_l2_interface_efp_filter (vat_main_t * vam)
12988 unformat_input_t *i = vam->input;
12989 vl_api_l2_interface_efp_filter_t *mp;
12992 u8 sw_if_index_set = 0;
12995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12997 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12998 sw_if_index_set = 1;
12999 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13000 sw_if_index_set = 1;
13001 else if (unformat (i, "enable"))
13003 else if (unformat (i, "disable"))
13007 clib_warning ("parse error '%U'", format_unformat_error, i);
13012 if (sw_if_index_set == 0)
13014 errmsg ("missing sw_if_index");
13018 M (L2_INTERFACE_EFP_FILTER, mp);
13020 mp->sw_if_index = ntohl (sw_if_index);
13021 mp->enable_disable = enable;
13028 #define foreach_vtr_op \
13029 _("disable", L2_VTR_DISABLED) \
13030 _("push-1", L2_VTR_PUSH_1) \
13031 _("push-2", L2_VTR_PUSH_2) \
13032 _("pop-1", L2_VTR_POP_1) \
13033 _("pop-2", L2_VTR_POP_2) \
13034 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13035 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13036 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13037 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13040 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13042 unformat_input_t *i = vam->input;
13043 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13045 u8 sw_if_index_set = 0;
13048 u32 push_dot1q = 1;
13053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13055 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13056 sw_if_index_set = 1;
13057 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13058 sw_if_index_set = 1;
13059 else if (unformat (i, "vtr_op %d", &vtr_op))
13061 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13064 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13066 else if (unformat (i, "tag1 %d", &tag1))
13068 else if (unformat (i, "tag2 %d", &tag2))
13072 clib_warning ("parse error '%U'", format_unformat_error, i);
13077 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13079 errmsg ("missing vtr operation or sw_if_index");
13083 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13084 mp->sw_if_index = ntohl (sw_if_index);
13085 mp->vtr_op = ntohl (vtr_op);
13086 mp->push_dot1q = ntohl (push_dot1q);
13087 mp->tag1 = ntohl (tag1);
13088 mp->tag2 = ntohl (tag2);
13096 api_create_vhost_user_if (vat_main_t * vam)
13098 unformat_input_t *i = vam->input;
13099 vl_api_create_vhost_user_if_t *mp;
13102 u8 file_name_set = 0;
13103 u32 custom_dev_instance = ~0;
13105 u8 use_custom_mac = 0;
13109 /* Shut up coverity */
13110 memset (hwaddr, 0, sizeof (hwaddr));
13112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13114 if (unformat (i, "socket %s", &file_name))
13118 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13120 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13121 use_custom_mac = 1;
13122 else if (unformat (i, "server"))
13124 else if (unformat (i, "tag %s", &tag))
13130 if (file_name_set == 0)
13132 errmsg ("missing socket file name");
13136 if (vec_len (file_name) > 255)
13138 errmsg ("socket file name too long");
13141 vec_add1 (file_name, 0);
13143 M (CREATE_VHOST_USER_IF, mp);
13145 mp->is_server = is_server;
13146 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13147 vec_free (file_name);
13148 if (custom_dev_instance != ~0)
13151 mp->custom_dev_instance = ntohl (custom_dev_instance);
13153 mp->use_custom_mac = use_custom_mac;
13154 clib_memcpy (mp->mac_address, hwaddr, 6);
13156 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13165 api_modify_vhost_user_if (vat_main_t * vam)
13167 unformat_input_t *i = vam->input;
13168 vl_api_modify_vhost_user_if_t *mp;
13171 u8 file_name_set = 0;
13172 u32 custom_dev_instance = ~0;
13173 u8 sw_if_index_set = 0;
13174 u32 sw_if_index = (u32) ~ 0;
13177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13179 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13180 sw_if_index_set = 1;
13181 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13182 sw_if_index_set = 1;
13183 else if (unformat (i, "socket %s", &file_name))
13187 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13189 else if (unformat (i, "server"))
13195 if (sw_if_index_set == 0)
13197 errmsg ("missing sw_if_index or interface name");
13201 if (file_name_set == 0)
13203 errmsg ("missing socket file name");
13207 if (vec_len (file_name) > 255)
13209 errmsg ("socket file name too long");
13212 vec_add1 (file_name, 0);
13214 M (MODIFY_VHOST_USER_IF, mp);
13216 mp->sw_if_index = ntohl (sw_if_index);
13217 mp->is_server = is_server;
13218 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13219 vec_free (file_name);
13220 if (custom_dev_instance != ~0)
13223 mp->custom_dev_instance = ntohl (custom_dev_instance);
13232 api_delete_vhost_user_if (vat_main_t * vam)
13234 unformat_input_t *i = vam->input;
13235 vl_api_delete_vhost_user_if_t *mp;
13236 u32 sw_if_index = ~0;
13237 u8 sw_if_index_set = 0;
13240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13242 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13243 sw_if_index_set = 1;
13244 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13245 sw_if_index_set = 1;
13250 if (sw_if_index_set == 0)
13252 errmsg ("missing sw_if_index or interface name");
13257 M (DELETE_VHOST_USER_IF, mp);
13259 mp->sw_if_index = ntohl (sw_if_index);
13266 static void vl_api_sw_interface_vhost_user_details_t_handler
13267 (vl_api_sw_interface_vhost_user_details_t * mp)
13269 vat_main_t *vam = &vat_main;
13271 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13272 (char *) mp->interface_name,
13273 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13274 clib_net_to_host_u64 (mp->features), mp->is_server,
13275 ntohl (mp->num_regions), (char *) mp->sock_filename);
13276 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13279 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13280 (vl_api_sw_interface_vhost_user_details_t * mp)
13282 vat_main_t *vam = &vat_main;
13283 vat_json_node_t *node = NULL;
13285 if (VAT_JSON_ARRAY != vam->json_tree.type)
13287 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13288 vat_json_init_array (&vam->json_tree);
13290 node = vat_json_array_add (&vam->json_tree);
13292 vat_json_init_object (node);
13293 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13294 vat_json_object_add_string_copy (node, "interface_name",
13295 mp->interface_name);
13296 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13297 ntohl (mp->virtio_net_hdr_sz));
13298 vat_json_object_add_uint (node, "features",
13299 clib_net_to_host_u64 (mp->features));
13300 vat_json_object_add_uint (node, "is_server", mp->is_server);
13301 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13302 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13303 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13307 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13309 vl_api_sw_interface_vhost_user_dump_t *mp;
13310 vl_api_control_ping_t *mp_ping;
13313 "Interface name idx hdr_sz features server regions filename");
13315 /* Get list of vhost-user interfaces */
13316 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13319 /* Use a control ping for synchronization */
13320 MPING (CONTROL_PING, mp_ping);
13328 api_show_version (vat_main_t * vam)
13330 vl_api_show_version_t *mp;
13333 M (SHOW_VERSION, mp);
13342 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13344 unformat_input_t *line_input = vam->input;
13345 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13346 ip4_address_t local4, remote4;
13347 ip6_address_t local6, remote6;
13349 u8 ipv4_set = 0, ipv6_set = 0;
13353 u32 mcast_sw_if_index = ~0;
13354 u32 encap_vrf_id = 0;
13355 u32 decap_vrf_id = 0;
13361 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13362 memset (&local4, 0, sizeof local4);
13363 memset (&remote4, 0, sizeof remote4);
13364 memset (&local6, 0, sizeof local6);
13365 memset (&remote6, 0, sizeof remote6);
13367 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13369 if (unformat (line_input, "del"))
13371 else if (unformat (line_input, "local %U",
13372 unformat_ip4_address, &local4))
13377 else if (unformat (line_input, "remote %U",
13378 unformat_ip4_address, &remote4))
13383 else if (unformat (line_input, "local %U",
13384 unformat_ip6_address, &local6))
13389 else if (unformat (line_input, "remote %U",
13390 unformat_ip6_address, &remote6))
13395 else if (unformat (line_input, "group %U %U",
13396 unformat_ip4_address, &remote4,
13397 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13399 grp_set = remote_set = 1;
13402 else if (unformat (line_input, "group %U",
13403 unformat_ip4_address, &remote4))
13405 grp_set = remote_set = 1;
13408 else if (unformat (line_input, "group %U %U",
13409 unformat_ip6_address, &remote6,
13410 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13412 grp_set = remote_set = 1;
13415 else if (unformat (line_input, "group %U",
13416 unformat_ip6_address, &remote6))
13418 grp_set = remote_set = 1;
13422 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13424 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13426 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13428 else if (unformat (line_input, "vni %d", &vni))
13430 else if (unformat (line_input, "next-ip4"))
13432 else if (unformat (line_input, "next-ip6"))
13434 else if (unformat (line_input, "next-ethernet"))
13436 else if (unformat (line_input, "next-nsh"))
13440 errmsg ("parse error '%U'", format_unformat_error, line_input);
13445 if (local_set == 0)
13447 errmsg ("tunnel local address not specified");
13450 if (remote_set == 0)
13452 errmsg ("tunnel remote address not specified");
13455 if (grp_set && mcast_sw_if_index == ~0)
13457 errmsg ("tunnel nonexistent multicast device");
13460 if (ipv4_set && ipv6_set)
13462 errmsg ("both IPv4 and IPv6 addresses specified");
13468 errmsg ("vni not specified");
13472 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13477 clib_memcpy (&mp->local, &local6, sizeof (local6));
13478 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13482 clib_memcpy (&mp->local, &local4, sizeof (local4));
13483 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13486 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13487 mp->encap_vrf_id = ntohl (encap_vrf_id);
13488 mp->decap_vrf_id = ntohl (decap_vrf_id);
13489 mp->protocol = protocol;
13490 mp->vni = ntohl (vni);
13491 mp->is_add = is_add;
13492 mp->is_ipv6 = ipv6_set;
13499 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13500 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13502 vat_main_t *vam = &vat_main;
13503 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13504 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13506 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13507 ntohl (mp->sw_if_index),
13508 format_ip46_address, &local, IP46_TYPE_ANY,
13509 format_ip46_address, &remote, IP46_TYPE_ANY,
13510 ntohl (mp->vni), mp->protocol,
13511 ntohl (mp->mcast_sw_if_index),
13512 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13516 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13517 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13519 vat_main_t *vam = &vat_main;
13520 vat_json_node_t *node = NULL;
13521 struct in_addr ip4;
13522 struct in6_addr ip6;
13524 if (VAT_JSON_ARRAY != vam->json_tree.type)
13526 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13527 vat_json_init_array (&vam->json_tree);
13529 node = vat_json_array_add (&vam->json_tree);
13531 vat_json_init_object (node);
13532 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13535 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13536 vat_json_object_add_ip6 (node, "local", ip6);
13537 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13538 vat_json_object_add_ip6 (node, "remote", ip6);
13542 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13543 vat_json_object_add_ip4 (node, "local", ip4);
13544 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13545 vat_json_object_add_ip4 (node, "remote", ip4);
13547 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13548 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13549 vat_json_object_add_uint (node, "mcast_sw_if_index",
13550 ntohl (mp->mcast_sw_if_index));
13551 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13552 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13553 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13557 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13559 unformat_input_t *i = vam->input;
13560 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13561 vl_api_control_ping_t *mp_ping;
13563 u8 sw_if_index_set = 0;
13566 /* Parse args required to build the message */
13567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13569 if (unformat (i, "sw_if_index %d", &sw_if_index))
13570 sw_if_index_set = 1;
13575 if (sw_if_index_set == 0)
13580 if (!vam->json_output)
13582 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13583 "sw_if_index", "local", "remote", "vni",
13584 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13587 /* Get list of vxlan-tunnel interfaces */
13588 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13590 mp->sw_if_index = htonl (sw_if_index);
13594 /* Use a control ping for synchronization */
13595 MPING (CONTROL_PING, mp_ping);
13602 static void vl_api_l2_fib_table_details_t_handler
13603 (vl_api_l2_fib_table_details_t * mp)
13605 vat_main_t *vam = &vat_main;
13607 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13609 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13610 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13614 static void vl_api_l2_fib_table_details_t_handler_json
13615 (vl_api_l2_fib_table_details_t * mp)
13617 vat_main_t *vam = &vat_main;
13618 vat_json_node_t *node = NULL;
13620 if (VAT_JSON_ARRAY != vam->json_tree.type)
13622 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13623 vat_json_init_array (&vam->json_tree);
13625 node = vat_json_array_add (&vam->json_tree);
13627 vat_json_init_object (node);
13628 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13629 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13630 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13631 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13632 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13633 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13637 api_l2_fib_table_dump (vat_main_t * vam)
13639 unformat_input_t *i = vam->input;
13640 vl_api_l2_fib_table_dump_t *mp;
13641 vl_api_control_ping_t *mp_ping;
13646 /* Parse args required to build the message */
13647 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13649 if (unformat (i, "bd_id %d", &bd_id))
13655 if (bd_id_set == 0)
13657 errmsg ("missing bridge domain");
13661 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13663 /* Get list of l2 fib entries */
13664 M (L2_FIB_TABLE_DUMP, mp);
13666 mp->bd_id = ntohl (bd_id);
13669 /* Use a control ping for synchronization */
13670 MPING (CONTROL_PING, mp_ping);
13679 api_interface_name_renumber (vat_main_t * vam)
13681 unformat_input_t *line_input = vam->input;
13682 vl_api_interface_name_renumber_t *mp;
13683 u32 sw_if_index = ~0;
13684 u32 new_show_dev_instance = ~0;
13687 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13689 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13692 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13694 else if (unformat (line_input, "new_show_dev_instance %d",
13695 &new_show_dev_instance))
13701 if (sw_if_index == ~0)
13703 errmsg ("missing interface name or sw_if_index");
13707 if (new_show_dev_instance == ~0)
13709 errmsg ("missing new_show_dev_instance");
13713 M (INTERFACE_NAME_RENUMBER, mp);
13715 mp->sw_if_index = ntohl (sw_if_index);
13716 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13724 api_want_ip4_arp_events (vat_main_t * vam)
13726 unformat_input_t *line_input = vam->input;
13727 vl_api_want_ip4_arp_events_t *mp;
13728 ip4_address_t address;
13729 int address_set = 0;
13730 u32 enable_disable = 1;
13733 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13735 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13737 else if (unformat (line_input, "del"))
13738 enable_disable = 0;
13743 if (address_set == 0)
13745 errmsg ("missing addresses");
13749 M (WANT_IP4_ARP_EVENTS, mp);
13750 mp->enable_disable = enable_disable;
13751 mp->pid = htonl (getpid ());
13752 mp->address = address.as_u32;
13760 api_want_ip6_nd_events (vat_main_t * vam)
13762 unformat_input_t *line_input = vam->input;
13763 vl_api_want_ip6_nd_events_t *mp;
13764 ip6_address_t address;
13765 int address_set = 0;
13766 u32 enable_disable = 1;
13769 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13771 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
13773 else if (unformat (line_input, "del"))
13774 enable_disable = 0;
13779 if (address_set == 0)
13781 errmsg ("missing addresses");
13785 M (WANT_IP6_ND_EVENTS, mp);
13786 mp->enable_disable = enable_disable;
13787 mp->pid = htonl (getpid ());
13788 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
13796 api_want_l2_macs_events (vat_main_t * vam)
13798 unformat_input_t *line_input = vam->input;
13799 vl_api_want_l2_macs_events_t *mp;
13800 u8 enable_disable = 1;
13801 u32 scan_delay = 0;
13802 u32 max_macs_in_event = 0;
13803 u32 learn_limit = 0;
13806 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13808 if (unformat (line_input, "learn-limit %d", &learn_limit))
13810 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13812 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13814 else if (unformat (line_input, "disable"))
13815 enable_disable = 0;
13820 M (WANT_L2_MACS_EVENTS, mp);
13821 mp->enable_disable = enable_disable;
13822 mp->pid = htonl (getpid ());
13823 mp->learn_limit = htonl (learn_limit);
13824 mp->scan_delay = (u8) scan_delay;
13825 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13832 api_input_acl_set_interface (vat_main_t * vam)
13834 unformat_input_t *i = vam->input;
13835 vl_api_input_acl_set_interface_t *mp;
13837 int sw_if_index_set;
13838 u32 ip4_table_index = ~0;
13839 u32 ip6_table_index = ~0;
13840 u32 l2_table_index = ~0;
13844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13846 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13847 sw_if_index_set = 1;
13848 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13849 sw_if_index_set = 1;
13850 else if (unformat (i, "del"))
13852 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13854 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13856 else if (unformat (i, "l2-table %d", &l2_table_index))
13860 clib_warning ("parse error '%U'", format_unformat_error, i);
13865 if (sw_if_index_set == 0)
13867 errmsg ("missing interface name or sw_if_index");
13871 M (INPUT_ACL_SET_INTERFACE, mp);
13873 mp->sw_if_index = ntohl (sw_if_index);
13874 mp->ip4_table_index = ntohl (ip4_table_index);
13875 mp->ip6_table_index = ntohl (ip6_table_index);
13876 mp->l2_table_index = ntohl (l2_table_index);
13877 mp->is_add = is_add;
13885 api_ip_address_dump (vat_main_t * vam)
13887 unformat_input_t *i = vam->input;
13888 vl_api_ip_address_dump_t *mp;
13889 vl_api_control_ping_t *mp_ping;
13890 u32 sw_if_index = ~0;
13891 u8 sw_if_index_set = 0;
13896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13898 if (unformat (i, "sw_if_index %d", &sw_if_index))
13899 sw_if_index_set = 1;
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, "ipv4"))
13905 else if (unformat (i, "ipv6"))
13911 if (ipv4_set && ipv6_set)
13913 errmsg ("ipv4 and ipv6 flags cannot be both set");
13917 if ((!ipv4_set) && (!ipv6_set))
13919 errmsg ("no ipv4 nor ipv6 flag set");
13923 if (sw_if_index_set == 0)
13925 errmsg ("missing interface name or sw_if_index");
13929 vam->current_sw_if_index = sw_if_index;
13930 vam->is_ipv6 = ipv6_set;
13932 M (IP_ADDRESS_DUMP, mp);
13933 mp->sw_if_index = ntohl (sw_if_index);
13934 mp->is_ipv6 = ipv6_set;
13937 /* Use a control ping for synchronization */
13938 MPING (CONTROL_PING, mp_ping);
13946 api_ip_dump (vat_main_t * vam)
13948 vl_api_ip_dump_t *mp;
13949 vl_api_control_ping_t *mp_ping;
13950 unformat_input_t *in = vam->input;
13957 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13959 if (unformat (in, "ipv4"))
13961 else if (unformat (in, "ipv6"))
13967 if (ipv4_set && ipv6_set)
13969 errmsg ("ipv4 and ipv6 flags cannot be both set");
13973 if ((!ipv4_set) && (!ipv6_set))
13975 errmsg ("no ipv4 nor ipv6 flag set");
13979 is_ipv6 = ipv6_set;
13980 vam->is_ipv6 = is_ipv6;
13982 /* free old data */
13983 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13985 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13987 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13990 mp->is_ipv6 = ipv6_set;
13993 /* Use a control ping for synchronization */
13994 MPING (CONTROL_PING, mp_ping);
14002 api_ipsec_spd_add_del (vat_main_t * vam)
14004 unformat_input_t *i = vam->input;
14005 vl_api_ipsec_spd_add_del_t *mp;
14010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14012 if (unformat (i, "spd_id %d", &spd_id))
14014 else if (unformat (i, "del"))
14018 clib_warning ("parse error '%U'", format_unformat_error, i);
14024 errmsg ("spd_id must be set");
14028 M (IPSEC_SPD_ADD_DEL, mp);
14030 mp->spd_id = ntohl (spd_id);
14031 mp->is_add = is_add;
14039 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14041 unformat_input_t *i = vam->input;
14042 vl_api_ipsec_interface_add_del_spd_t *mp;
14044 u8 sw_if_index_set = 0;
14045 u32 spd_id = (u32) ~ 0;
14049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14051 if (unformat (i, "del"))
14053 else if (unformat (i, "spd_id %d", &spd_id))
14056 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14057 sw_if_index_set = 1;
14058 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14059 sw_if_index_set = 1;
14062 clib_warning ("parse error '%U'", format_unformat_error, i);
14068 if (spd_id == (u32) ~ 0)
14070 errmsg ("spd_id must be set");
14074 if (sw_if_index_set == 0)
14076 errmsg ("missing interface name or sw_if_index");
14080 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14082 mp->spd_id = ntohl (spd_id);
14083 mp->sw_if_index = ntohl (sw_if_index);
14084 mp->is_add = is_add;
14092 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14094 unformat_input_t *i = vam->input;
14095 vl_api_ipsec_spd_add_del_entry_t *mp;
14096 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14097 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14099 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14100 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14101 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14102 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14105 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14106 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14107 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14108 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14109 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14110 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14114 if (unformat (i, "del"))
14116 if (unformat (i, "outbound"))
14118 if (unformat (i, "inbound"))
14120 else if (unformat (i, "spd_id %d", &spd_id))
14122 else if (unformat (i, "sa_id %d", &sa_id))
14124 else if (unformat (i, "priority %d", &priority))
14126 else if (unformat (i, "protocol %d", &protocol))
14128 else if (unformat (i, "lport_start %d", &lport_start))
14130 else if (unformat (i, "lport_stop %d", &lport_stop))
14132 else if (unformat (i, "rport_start %d", &rport_start))
14134 else if (unformat (i, "rport_stop %d", &rport_stop))
14138 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14144 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14151 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14157 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14164 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14170 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14177 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14183 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14189 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14191 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14193 clib_warning ("unsupported action: 'resolve'");
14199 clib_warning ("parse error '%U'", format_unformat_error, i);
14205 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14207 mp->spd_id = ntohl (spd_id);
14208 mp->priority = ntohl (priority);
14209 mp->is_outbound = is_outbound;
14211 mp->is_ipv6 = is_ipv6;
14212 if (is_ipv6 || is_ip_any)
14214 clib_memcpy (mp->remote_address_start, &raddr6_start,
14215 sizeof (ip6_address_t));
14216 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14217 sizeof (ip6_address_t));
14218 clib_memcpy (mp->local_address_start, &laddr6_start,
14219 sizeof (ip6_address_t));
14220 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14221 sizeof (ip6_address_t));
14225 clib_memcpy (mp->remote_address_start, &raddr4_start,
14226 sizeof (ip4_address_t));
14227 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14228 sizeof (ip4_address_t));
14229 clib_memcpy (mp->local_address_start, &laddr4_start,
14230 sizeof (ip4_address_t));
14231 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14232 sizeof (ip4_address_t));
14234 mp->protocol = (u8) protocol;
14235 mp->local_port_start = ntohs ((u16) lport_start);
14236 mp->local_port_stop = ntohs ((u16) lport_stop);
14237 mp->remote_port_start = ntohs ((u16) rport_start);
14238 mp->remote_port_stop = ntohs ((u16) rport_stop);
14239 mp->policy = (u8) policy;
14240 mp->sa_id = ntohl (sa_id);
14241 mp->is_add = is_add;
14242 mp->is_ip_any = is_ip_any;
14249 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14251 unformat_input_t *i = vam->input;
14252 vl_api_ipsec_sad_add_del_entry_t *mp;
14253 u32 sad_id = 0, spi = 0;
14254 u8 *ck = 0, *ik = 0;
14257 u8 protocol = IPSEC_PROTOCOL_AH;
14258 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14259 u32 crypto_alg = 0, integ_alg = 0;
14260 ip4_address_t tun_src4;
14261 ip4_address_t tun_dst4;
14262 ip6_address_t tun_src6;
14263 ip6_address_t tun_dst6;
14266 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14268 if (unformat (i, "del"))
14270 else if (unformat (i, "sad_id %d", &sad_id))
14272 else if (unformat (i, "spi %d", &spi))
14274 else if (unformat (i, "esp"))
14275 protocol = IPSEC_PROTOCOL_ESP;
14276 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14279 is_tunnel_ipv6 = 0;
14281 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14284 is_tunnel_ipv6 = 0;
14286 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14289 is_tunnel_ipv6 = 1;
14291 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14294 is_tunnel_ipv6 = 1;
14298 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14300 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14301 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14303 clib_warning ("unsupported crypto-alg: '%U'",
14304 format_ipsec_crypto_alg, crypto_alg);
14308 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14312 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14314 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14315 integ_alg >= IPSEC_INTEG_N_ALG)
14317 clib_warning ("unsupported integ-alg: '%U'",
14318 format_ipsec_integ_alg, integ_alg);
14322 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14326 clib_warning ("parse error '%U'", format_unformat_error, i);
14332 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14334 mp->sad_id = ntohl (sad_id);
14335 mp->is_add = is_add;
14336 mp->protocol = protocol;
14337 mp->spi = ntohl (spi);
14338 mp->is_tunnel = is_tunnel;
14339 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14340 mp->crypto_algorithm = crypto_alg;
14341 mp->integrity_algorithm = integ_alg;
14342 mp->crypto_key_length = vec_len (ck);
14343 mp->integrity_key_length = vec_len (ik);
14345 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14346 mp->crypto_key_length = sizeof (mp->crypto_key);
14348 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14349 mp->integrity_key_length = sizeof (mp->integrity_key);
14352 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14354 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14358 if (is_tunnel_ipv6)
14360 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14361 sizeof (ip6_address_t));
14362 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14363 sizeof (ip6_address_t));
14367 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14368 sizeof (ip4_address_t));
14369 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14370 sizeof (ip4_address_t));
14380 api_ipsec_sa_set_key (vat_main_t * vam)
14382 unformat_input_t *i = vam->input;
14383 vl_api_ipsec_sa_set_key_t *mp;
14385 u8 *ck = 0, *ik = 0;
14388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14390 if (unformat (i, "sa_id %d", &sa_id))
14392 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14394 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14398 clib_warning ("parse error '%U'", format_unformat_error, i);
14403 M (IPSEC_SA_SET_KEY, mp);
14405 mp->sa_id = ntohl (sa_id);
14406 mp->crypto_key_length = vec_len (ck);
14407 mp->integrity_key_length = vec_len (ik);
14409 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14410 mp->crypto_key_length = sizeof (mp->crypto_key);
14412 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14413 mp->integrity_key_length = sizeof (mp->integrity_key);
14416 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14418 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14426 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14428 unformat_input_t *i = vam->input;
14429 vl_api_ipsec_tunnel_if_add_del_t *mp;
14430 u32 local_spi = 0, remote_spi = 0;
14431 u32 crypto_alg = 0, integ_alg = 0;
14432 u8 *lck = NULL, *rck = NULL;
14433 u8 *lik = NULL, *rik = NULL;
14434 ip4_address_t local_ip = { {0} };
14435 ip4_address_t remote_ip = { {0} };
14438 u8 anti_replay = 0;
14441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14443 if (unformat (i, "del"))
14445 else if (unformat (i, "esn"))
14447 else if (unformat (i, "anti_replay"))
14449 else if (unformat (i, "local_spi %d", &local_spi))
14451 else if (unformat (i, "remote_spi %d", &remote_spi))
14453 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14455 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14457 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14460 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14462 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14464 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14468 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14470 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14471 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14473 errmsg ("unsupported crypto-alg: '%U'\n",
14474 format_ipsec_crypto_alg, crypto_alg);
14480 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14482 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14483 integ_alg >= IPSEC_INTEG_N_ALG)
14485 errmsg ("unsupported integ-alg: '%U'\n",
14486 format_ipsec_integ_alg, integ_alg);
14492 errmsg ("parse error '%U'\n", format_unformat_error, i);
14497 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14499 mp->is_add = is_add;
14501 mp->anti_replay = anti_replay;
14503 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14504 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14506 mp->local_spi = htonl (local_spi);
14507 mp->remote_spi = htonl (remote_spi);
14508 mp->crypto_alg = (u8) crypto_alg;
14510 mp->local_crypto_key_len = 0;
14513 mp->local_crypto_key_len = vec_len (lck);
14514 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14515 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14516 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14519 mp->remote_crypto_key_len = 0;
14522 mp->remote_crypto_key_len = vec_len (rck);
14523 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14524 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14525 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14528 mp->integ_alg = (u8) integ_alg;
14530 mp->local_integ_key_len = 0;
14533 mp->local_integ_key_len = vec_len (lik);
14534 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14535 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14536 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14539 mp->remote_integ_key_len = 0;
14542 mp->remote_integ_key_len = vec_len (rik);
14543 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14544 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14545 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14554 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14556 vat_main_t *vam = &vat_main;
14558 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14559 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14560 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14561 "tunnel_src_addr %U tunnel_dst_addr %U "
14562 "salt %u seq_outbound %lu last_seq_inbound %lu "
14563 "replay_window %lu total_data_size %lu\n",
14564 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14566 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14567 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14568 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14569 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14570 mp->tunnel_src_addr,
14571 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14572 mp->tunnel_dst_addr,
14574 clib_net_to_host_u64 (mp->seq_outbound),
14575 clib_net_to_host_u64 (mp->last_seq_inbound),
14576 clib_net_to_host_u64 (mp->replay_window),
14577 clib_net_to_host_u64 (mp->total_data_size));
14580 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14581 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14583 static void vl_api_ipsec_sa_details_t_handler_json
14584 (vl_api_ipsec_sa_details_t * mp)
14586 vat_main_t *vam = &vat_main;
14587 vat_json_node_t *node = NULL;
14588 struct in_addr src_ip4, dst_ip4;
14589 struct in6_addr src_ip6, dst_ip6;
14591 if (VAT_JSON_ARRAY != vam->json_tree.type)
14593 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14594 vat_json_init_array (&vam->json_tree);
14596 node = vat_json_array_add (&vam->json_tree);
14598 vat_json_init_object (node);
14599 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14600 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14601 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14602 vat_json_object_add_uint (node, "proto", mp->protocol);
14603 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14604 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14605 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14606 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14607 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14608 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14609 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14610 mp->crypto_key_len);
14611 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14612 mp->integ_key_len);
14613 if (mp->is_tunnel_ip6)
14615 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14616 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14617 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14618 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14622 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14623 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14624 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14625 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14627 vat_json_object_add_uint (node, "replay_window",
14628 clib_net_to_host_u64 (mp->replay_window));
14629 vat_json_object_add_uint (node, "total_data_size",
14630 clib_net_to_host_u64 (mp->total_data_size));
14635 api_ipsec_sa_dump (vat_main_t * vam)
14637 unformat_input_t *i = vam->input;
14638 vl_api_ipsec_sa_dump_t *mp;
14639 vl_api_control_ping_t *mp_ping;
14643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14645 if (unformat (i, "sa_id %d", &sa_id))
14649 clib_warning ("parse error '%U'", format_unformat_error, i);
14654 M (IPSEC_SA_DUMP, mp);
14656 mp->sa_id = ntohl (sa_id);
14660 /* Use a control ping for synchronization */
14661 M (CONTROL_PING, mp_ping);
14669 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14671 unformat_input_t *i = vam->input;
14672 vl_api_ipsec_tunnel_if_set_key_t *mp;
14673 u32 sw_if_index = ~0;
14674 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14681 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14684 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14685 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14687 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14688 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14689 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14690 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14692 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14693 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14694 else if (unformat (i, "%U", unformat_hex_string, &key))
14698 clib_warning ("parse error '%U'", format_unformat_error, i);
14703 if (sw_if_index == ~0)
14705 errmsg ("interface must be specified");
14709 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14711 errmsg ("key type must be specified");
14717 errmsg ("algorithm must be specified");
14721 if (vec_len (key) == 0)
14723 errmsg ("key must be specified");
14727 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14729 mp->sw_if_index = htonl (sw_if_index);
14731 mp->key_type = key_type;
14732 mp->key_len = vec_len (key);
14733 clib_memcpy (mp->key, key, vec_len (key));
14742 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14744 unformat_input_t *i = vam->input;
14745 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14746 u32 sw_if_index = ~0;
14748 u8 is_outbound = (u8) ~ 0;
14751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14753 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14755 else if (unformat (i, "sa_id %d", &sa_id))
14757 else if (unformat (i, "outbound"))
14759 else if (unformat (i, "inbound"))
14763 clib_warning ("parse error '%U'", format_unformat_error, i);
14768 if (sw_if_index == ~0)
14770 errmsg ("interface must be specified");
14776 errmsg ("SA ID must be specified");
14780 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14782 mp->sw_if_index = htonl (sw_if_index);
14783 mp->sa_id = htonl (sa_id);
14784 mp->is_outbound = is_outbound;
14793 api_ikev2_profile_add_del (vat_main_t * vam)
14795 unformat_input_t *i = vam->input;
14796 vl_api_ikev2_profile_add_del_t *mp;
14801 const char *valid_chars = "a-zA-Z0-9_";
14803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14805 if (unformat (i, "del"))
14807 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14808 vec_add1 (name, 0);
14811 errmsg ("parse error '%U'", format_unformat_error, i);
14816 if (!vec_len (name))
14818 errmsg ("profile name must be specified");
14822 if (vec_len (name) > 64)
14824 errmsg ("profile name too long");
14828 M (IKEV2_PROFILE_ADD_DEL, mp);
14830 clib_memcpy (mp->name, name, vec_len (name));
14831 mp->is_add = is_add;
14840 api_ikev2_profile_set_auth (vat_main_t * vam)
14842 unformat_input_t *i = vam->input;
14843 vl_api_ikev2_profile_set_auth_t *mp;
14846 u32 auth_method = 0;
14850 const char *valid_chars = "a-zA-Z0-9_";
14852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14854 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14855 vec_add1 (name, 0);
14856 else if (unformat (i, "auth_method %U",
14857 unformat_ikev2_auth_method, &auth_method))
14859 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
14861 else if (unformat (i, "auth_data %v", &data))
14865 errmsg ("parse error '%U'", format_unformat_error, i);
14870 if (!vec_len (name))
14872 errmsg ("profile name must be specified");
14876 if (vec_len (name) > 64)
14878 errmsg ("profile name too long");
14882 if (!vec_len (data))
14884 errmsg ("auth_data must be specified");
14890 errmsg ("auth_method must be specified");
14894 M (IKEV2_PROFILE_SET_AUTH, mp);
14896 mp->is_hex = is_hex;
14897 mp->auth_method = (u8) auth_method;
14898 mp->data_len = vec_len (data);
14899 clib_memcpy (mp->name, name, vec_len (name));
14900 clib_memcpy (mp->data, data, vec_len (data));
14910 api_ikev2_profile_set_id (vat_main_t * vam)
14912 unformat_input_t *i = vam->input;
14913 vl_api_ikev2_profile_set_id_t *mp;
14921 const char *valid_chars = "a-zA-Z0-9_";
14923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14925 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14926 vec_add1 (name, 0);
14927 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
14929 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
14931 data = vec_new (u8, 4);
14932 clib_memcpy (data, ip4.as_u8, 4);
14934 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
14936 else if (unformat (i, "id_data %v", &data))
14938 else if (unformat (i, "local"))
14940 else if (unformat (i, "remote"))
14944 errmsg ("parse error '%U'", format_unformat_error, i);
14949 if (!vec_len (name))
14951 errmsg ("profile name must be specified");
14955 if (vec_len (name) > 64)
14957 errmsg ("profile name too long");
14961 if (!vec_len (data))
14963 errmsg ("id_data must be specified");
14969 errmsg ("id_type must be specified");
14973 M (IKEV2_PROFILE_SET_ID, mp);
14975 mp->is_local = is_local;
14976 mp->id_type = (u8) id_type;
14977 mp->data_len = vec_len (data);
14978 clib_memcpy (mp->name, name, vec_len (name));
14979 clib_memcpy (mp->data, data, vec_len (data));
14989 api_ikev2_profile_set_ts (vat_main_t * vam)
14991 unformat_input_t *i = vam->input;
14992 vl_api_ikev2_profile_set_ts_t *mp;
14995 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
14996 ip4_address_t start_addr, end_addr;
14998 const char *valid_chars = "a-zA-Z0-9_";
15001 start_addr.as_u32 = 0;
15002 end_addr.as_u32 = (u32) ~ 0;
15004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15006 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15007 vec_add1 (name, 0);
15008 else if (unformat (i, "protocol %d", &proto))
15010 else if (unformat (i, "start_port %d", &start_port))
15012 else if (unformat (i, "end_port %d", &end_port))
15015 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15017 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15019 else if (unformat (i, "local"))
15021 else if (unformat (i, "remote"))
15025 errmsg ("parse error '%U'", format_unformat_error, i);
15030 if (!vec_len (name))
15032 errmsg ("profile name must be specified");
15036 if (vec_len (name) > 64)
15038 errmsg ("profile name too long");
15042 M (IKEV2_PROFILE_SET_TS, mp);
15044 mp->is_local = is_local;
15045 mp->proto = (u8) proto;
15046 mp->start_port = (u16) start_port;
15047 mp->end_port = (u16) end_port;
15048 mp->start_addr = start_addr.as_u32;
15049 mp->end_addr = end_addr.as_u32;
15050 clib_memcpy (mp->name, name, vec_len (name));
15059 api_ikev2_set_local_key (vat_main_t * vam)
15061 unformat_input_t *i = vam->input;
15062 vl_api_ikev2_set_local_key_t *mp;
15066 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15068 if (unformat (i, "file %v", &file))
15069 vec_add1 (file, 0);
15072 errmsg ("parse error '%U'", format_unformat_error, i);
15077 if (!vec_len (file))
15079 errmsg ("RSA key file must be specified");
15083 if (vec_len (file) > 256)
15085 errmsg ("file name too long");
15089 M (IKEV2_SET_LOCAL_KEY, mp);
15091 clib_memcpy (mp->key_file, file, vec_len (file));
15100 api_ikev2_set_responder (vat_main_t * vam)
15102 unformat_input_t *i = vam->input;
15103 vl_api_ikev2_set_responder_t *mp;
15106 u32 sw_if_index = ~0;
15107 ip4_address_t address;
15109 const char *valid_chars = "a-zA-Z0-9_";
15111 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15114 (i, "%U interface %d address %U", unformat_token, valid_chars,
15115 &name, &sw_if_index, unformat_ip4_address, &address))
15116 vec_add1 (name, 0);
15119 errmsg ("parse error '%U'", format_unformat_error, i);
15124 if (!vec_len (name))
15126 errmsg ("profile name must be specified");
15130 if (vec_len (name) > 64)
15132 errmsg ("profile name too long");
15136 M (IKEV2_SET_RESPONDER, mp);
15138 clib_memcpy (mp->name, name, vec_len (name));
15141 mp->sw_if_index = sw_if_index;
15142 clib_memcpy (mp->address, &address, sizeof (address));
15150 api_ikev2_set_ike_transforms (vat_main_t * vam)
15152 unformat_input_t *i = vam->input;
15153 vl_api_ikev2_set_ike_transforms_t *mp;
15156 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15158 const char *valid_chars = "a-zA-Z0-9_";
15160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15162 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15163 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15164 vec_add1 (name, 0);
15167 errmsg ("parse error '%U'", format_unformat_error, i);
15172 if (!vec_len (name))
15174 errmsg ("profile name must be specified");
15178 if (vec_len (name) > 64)
15180 errmsg ("profile name too long");
15184 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15186 clib_memcpy (mp->name, name, vec_len (name));
15188 mp->crypto_alg = crypto_alg;
15189 mp->crypto_key_size = crypto_key_size;
15190 mp->integ_alg = integ_alg;
15191 mp->dh_group = dh_group;
15200 api_ikev2_set_esp_transforms (vat_main_t * vam)
15202 unformat_input_t *i = vam->input;
15203 vl_api_ikev2_set_esp_transforms_t *mp;
15206 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15208 const char *valid_chars = "a-zA-Z0-9_";
15210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15212 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15213 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15214 vec_add1 (name, 0);
15217 errmsg ("parse error '%U'", format_unformat_error, i);
15222 if (!vec_len (name))
15224 errmsg ("profile name must be specified");
15228 if (vec_len (name) > 64)
15230 errmsg ("profile name too long");
15234 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15236 clib_memcpy (mp->name, name, vec_len (name));
15238 mp->crypto_alg = crypto_alg;
15239 mp->crypto_key_size = crypto_key_size;
15240 mp->integ_alg = integ_alg;
15241 mp->dh_group = dh_group;
15249 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15251 unformat_input_t *i = vam->input;
15252 vl_api_ikev2_set_sa_lifetime_t *mp;
15255 u64 lifetime, lifetime_maxdata;
15256 u32 lifetime_jitter, handover;
15258 const char *valid_chars = "a-zA-Z0-9_";
15260 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15262 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15263 &lifetime, &lifetime_jitter, &handover,
15264 &lifetime_maxdata))
15265 vec_add1 (name, 0);
15268 errmsg ("parse error '%U'", format_unformat_error, i);
15273 if (!vec_len (name))
15275 errmsg ("profile name must be specified");
15279 if (vec_len (name) > 64)
15281 errmsg ("profile name too long");
15285 M (IKEV2_SET_SA_LIFETIME, mp);
15287 clib_memcpy (mp->name, name, vec_len (name));
15289 mp->lifetime = lifetime;
15290 mp->lifetime_jitter = lifetime_jitter;
15291 mp->handover = handover;
15292 mp->lifetime_maxdata = lifetime_maxdata;
15300 api_ikev2_initiate_sa_init (vat_main_t * vam)
15302 unformat_input_t *i = vam->input;
15303 vl_api_ikev2_initiate_sa_init_t *mp;
15307 const char *valid_chars = "a-zA-Z0-9_";
15309 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15311 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15312 vec_add1 (name, 0);
15315 errmsg ("parse error '%U'", format_unformat_error, i);
15320 if (!vec_len (name))
15322 errmsg ("profile name must be specified");
15326 if (vec_len (name) > 64)
15328 errmsg ("profile name too long");
15332 M (IKEV2_INITIATE_SA_INIT, mp);
15334 clib_memcpy (mp->name, name, vec_len (name));
15343 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15345 unformat_input_t *i = vam->input;
15346 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15353 if (unformat (i, "%lx", &ispi))
15357 errmsg ("parse error '%U'", format_unformat_error, i);
15362 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15372 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15374 unformat_input_t *i = vam->input;
15375 vl_api_ikev2_initiate_del_child_sa_t *mp;
15380 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15382 if (unformat (i, "%x", &ispi))
15386 errmsg ("parse error '%U'", format_unformat_error, i);
15391 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15401 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15403 unformat_input_t *i = vam->input;
15404 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15411 if (unformat (i, "%x", &ispi))
15415 errmsg ("parse error '%U'", format_unformat_error, i);
15420 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15433 api_map_add_domain (vat_main_t * vam)
15435 unformat_input_t *i = vam->input;
15436 vl_api_map_add_domain_t *mp;
15438 ip4_address_t ip4_prefix;
15439 ip6_address_t ip6_prefix;
15440 ip6_address_t ip6_src;
15441 u32 num_m_args = 0;
15442 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15443 0, psid_length = 0;
15444 u8 is_translation = 0;
15446 u32 ip6_src_len = 128;
15449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15451 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15452 &ip4_prefix, &ip4_prefix_len))
15454 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15455 &ip6_prefix, &ip6_prefix_len))
15459 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15462 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15464 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15466 else if (unformat (i, "psid-offset %d", &psid_offset))
15468 else if (unformat (i, "psid-len %d", &psid_length))
15470 else if (unformat (i, "mtu %d", &mtu))
15472 else if (unformat (i, "map-t"))
15473 is_translation = 1;
15476 clib_warning ("parse error '%U'", format_unformat_error, i);
15481 if (num_m_args < 3)
15483 errmsg ("mandatory argument(s) missing");
15487 /* Construct the API message */
15488 M (MAP_ADD_DOMAIN, mp);
15490 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15491 mp->ip4_prefix_len = ip4_prefix_len;
15493 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15494 mp->ip6_prefix_len = ip6_prefix_len;
15496 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15497 mp->ip6_src_prefix_len = ip6_src_len;
15499 mp->ea_bits_len = ea_bits_len;
15500 mp->psid_offset = psid_offset;
15501 mp->psid_length = psid_length;
15502 mp->is_translation = is_translation;
15503 mp->mtu = htons (mtu);
15508 /* Wait for a reply, return good/bad news */
15514 api_map_del_domain (vat_main_t * vam)
15516 unformat_input_t *i = vam->input;
15517 vl_api_map_del_domain_t *mp;
15519 u32 num_m_args = 0;
15523 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15525 if (unformat (i, "index %d", &index))
15529 clib_warning ("parse error '%U'", format_unformat_error, i);
15534 if (num_m_args != 1)
15536 errmsg ("mandatory argument(s) missing");
15540 /* Construct the API message */
15541 M (MAP_DEL_DOMAIN, mp);
15543 mp->index = ntohl (index);
15548 /* Wait for a reply, return good/bad news */
15554 api_map_add_del_rule (vat_main_t * vam)
15556 unformat_input_t *i = vam->input;
15557 vl_api_map_add_del_rule_t *mp;
15559 ip6_address_t ip6_dst;
15560 u32 num_m_args = 0, index, psid = 0;
15563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15565 if (unformat (i, "index %d", &index))
15567 else if (unformat (i, "psid %d", &psid))
15569 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15571 else if (unformat (i, "del"))
15577 clib_warning ("parse error '%U'", format_unformat_error, i);
15582 /* Construct the API message */
15583 M (MAP_ADD_DEL_RULE, mp);
15585 mp->index = ntohl (index);
15586 mp->is_add = is_add;
15587 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15588 mp->psid = ntohs (psid);
15593 /* Wait for a reply, return good/bad news */
15599 api_map_domain_dump (vat_main_t * vam)
15601 vl_api_map_domain_dump_t *mp;
15602 vl_api_control_ping_t *mp_ping;
15605 /* Construct the API message */
15606 M (MAP_DOMAIN_DUMP, mp);
15611 /* Use a control ping for synchronization */
15612 MPING (CONTROL_PING, mp_ping);
15620 api_map_rule_dump (vat_main_t * vam)
15622 unformat_input_t *i = vam->input;
15623 vl_api_map_rule_dump_t *mp;
15624 vl_api_control_ping_t *mp_ping;
15625 u32 domain_index = ~0;
15628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15630 if (unformat (i, "index %u", &domain_index))
15636 if (domain_index == ~0)
15638 clib_warning ("parse error: domain index expected");
15642 /* Construct the API message */
15643 M (MAP_RULE_DUMP, mp);
15645 mp->domain_index = htonl (domain_index);
15650 /* Use a control ping for synchronization */
15651 MPING (CONTROL_PING, mp_ping);
15658 static void vl_api_map_add_domain_reply_t_handler
15659 (vl_api_map_add_domain_reply_t * mp)
15661 vat_main_t *vam = &vat_main;
15662 i32 retval = ntohl (mp->retval);
15664 if (vam->async_mode)
15666 vam->async_errors += (retval < 0);
15670 vam->retval = retval;
15671 vam->result_ready = 1;
15675 static void vl_api_map_add_domain_reply_t_handler_json
15676 (vl_api_map_add_domain_reply_t * mp)
15678 vat_main_t *vam = &vat_main;
15679 vat_json_node_t node;
15681 vat_json_init_object (&node);
15682 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15683 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15685 vat_json_print (vam->ofp, &node);
15686 vat_json_free (&node);
15688 vam->retval = ntohl (mp->retval);
15689 vam->result_ready = 1;
15693 api_get_first_msg_id (vat_main_t * vam)
15695 vl_api_get_first_msg_id_t *mp;
15696 unformat_input_t *i = vam->input;
15701 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15703 if (unformat (i, "client %s", &name))
15711 errmsg ("missing client name");
15714 vec_add1 (name, 0);
15716 if (vec_len (name) > 63)
15718 errmsg ("client name too long");
15722 M (GET_FIRST_MSG_ID, mp);
15723 clib_memcpy (mp->name, name, vec_len (name));
15730 api_cop_interface_enable_disable (vat_main_t * vam)
15732 unformat_input_t *line_input = vam->input;
15733 vl_api_cop_interface_enable_disable_t *mp;
15734 u32 sw_if_index = ~0;
15735 u8 enable_disable = 1;
15738 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15740 if (unformat (line_input, "disable"))
15741 enable_disable = 0;
15742 if (unformat (line_input, "enable"))
15743 enable_disable = 1;
15744 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15745 vam, &sw_if_index))
15747 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15753 if (sw_if_index == ~0)
15755 errmsg ("missing interface name or sw_if_index");
15759 /* Construct the API message */
15760 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15761 mp->sw_if_index = ntohl (sw_if_index);
15762 mp->enable_disable = enable_disable;
15766 /* Wait for the reply */
15772 api_cop_whitelist_enable_disable (vat_main_t * vam)
15774 unformat_input_t *line_input = vam->input;
15775 vl_api_cop_whitelist_enable_disable_t *mp;
15776 u32 sw_if_index = ~0;
15777 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15781 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15783 if (unformat (line_input, "ip4"))
15785 else if (unformat (line_input, "ip6"))
15787 else if (unformat (line_input, "default"))
15789 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15790 vam, &sw_if_index))
15792 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15794 else if (unformat (line_input, "fib-id %d", &fib_id))
15800 if (sw_if_index == ~0)
15802 errmsg ("missing interface name or sw_if_index");
15806 /* Construct the API message */
15807 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15808 mp->sw_if_index = ntohl (sw_if_index);
15809 mp->fib_id = ntohl (fib_id);
15812 mp->default_cop = default_cop;
15816 /* Wait for the reply */
15822 api_get_node_graph (vat_main_t * vam)
15824 vl_api_get_node_graph_t *mp;
15827 M (GET_NODE_GRAPH, mp);
15831 /* Wait for the reply */
15837 /** Used for parsing LISP eids */
15838 typedef CLIB_PACKED(struct{
15839 u8 addr[16]; /**< eid address */
15840 u32 len; /**< prefix length if IP */
15841 u8 type; /**< type of eid */
15846 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15848 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15850 memset (a, 0, sizeof (a[0]));
15852 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15854 a->type = 0; /* ipv4 type */
15856 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15858 a->type = 1; /* ipv6 type */
15860 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15862 a->type = 2; /* mac type */
15864 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15866 a->type = 3; /* NSH type */
15867 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15868 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15875 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15884 lisp_eid_size_vat (u8 type)
15901 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15903 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15907 api_one_add_del_locator_set (vat_main_t * vam)
15909 unformat_input_t *input = vam->input;
15910 vl_api_one_add_del_locator_set_t *mp;
15912 u8 *locator_set_name = NULL;
15913 u8 locator_set_name_set = 0;
15914 vl_api_local_locator_t locator, *locators = 0;
15915 u32 sw_if_index, priority, weight;
15919 /* Parse args required to build the message */
15920 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15922 if (unformat (input, "del"))
15926 else if (unformat (input, "locator-set %s", &locator_set_name))
15928 locator_set_name_set = 1;
15930 else if (unformat (input, "sw_if_index %u p %u w %u",
15931 &sw_if_index, &priority, &weight))
15933 locator.sw_if_index = htonl (sw_if_index);
15934 locator.priority = priority;
15935 locator.weight = weight;
15936 vec_add1 (locators, locator);
15940 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15941 &sw_if_index, &priority, &weight))
15943 locator.sw_if_index = htonl (sw_if_index);
15944 locator.priority = priority;
15945 locator.weight = weight;
15946 vec_add1 (locators, locator);
15952 if (locator_set_name_set == 0)
15954 errmsg ("missing locator-set name");
15955 vec_free (locators);
15959 if (vec_len (locator_set_name) > 64)
15961 errmsg ("locator-set name too long");
15962 vec_free (locator_set_name);
15963 vec_free (locators);
15966 vec_add1 (locator_set_name, 0);
15968 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15970 /* Construct the API message */
15971 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15973 mp->is_add = is_add;
15974 clib_memcpy (mp->locator_set_name, locator_set_name,
15975 vec_len (locator_set_name));
15976 vec_free (locator_set_name);
15978 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15980 clib_memcpy (mp->locators, locators, data_len);
15981 vec_free (locators);
15986 /* Wait for a reply... */
15991 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15994 api_one_add_del_locator (vat_main_t * vam)
15996 unformat_input_t *input = vam->input;
15997 vl_api_one_add_del_locator_t *mp;
15998 u32 tmp_if_index = ~0;
15999 u32 sw_if_index = ~0;
16000 u8 sw_if_index_set = 0;
16001 u8 sw_if_index_if_name_set = 0;
16003 u8 priority_set = 0;
16007 u8 *locator_set_name = NULL;
16008 u8 locator_set_name_set = 0;
16011 /* Parse args required to build the message */
16012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16014 if (unformat (input, "del"))
16018 else if (unformat (input, "locator-set %s", &locator_set_name))
16020 locator_set_name_set = 1;
16022 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16025 sw_if_index_if_name_set = 1;
16026 sw_if_index = tmp_if_index;
16028 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16030 sw_if_index_set = 1;
16031 sw_if_index = tmp_if_index;
16033 else if (unformat (input, "p %d", &priority))
16037 else if (unformat (input, "w %d", &weight))
16045 if (locator_set_name_set == 0)
16047 errmsg ("missing locator-set name");
16051 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16053 errmsg ("missing sw_if_index");
16054 vec_free (locator_set_name);
16058 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16060 errmsg ("cannot use both params interface name and sw_if_index");
16061 vec_free (locator_set_name);
16065 if (priority_set == 0)
16067 errmsg ("missing locator-set priority");
16068 vec_free (locator_set_name);
16072 if (weight_set == 0)
16074 errmsg ("missing locator-set weight");
16075 vec_free (locator_set_name);
16079 if (vec_len (locator_set_name) > 64)
16081 errmsg ("locator-set name too long");
16082 vec_free (locator_set_name);
16085 vec_add1 (locator_set_name, 0);
16087 /* Construct the API message */
16088 M (ONE_ADD_DEL_LOCATOR, mp);
16090 mp->is_add = is_add;
16091 mp->sw_if_index = ntohl (sw_if_index);
16092 mp->priority = priority;
16093 mp->weight = weight;
16094 clib_memcpy (mp->locator_set_name, locator_set_name,
16095 vec_len (locator_set_name));
16096 vec_free (locator_set_name);
16101 /* Wait for a reply... */
16106 #define api_lisp_add_del_locator api_one_add_del_locator
16109 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16111 u32 *key_id = va_arg (*args, u32 *);
16114 if (unformat (input, "%s", &s))
16116 if (!strcmp ((char *) s, "sha1"))
16117 key_id[0] = HMAC_SHA_1_96;
16118 else if (!strcmp ((char *) s, "sha256"))
16119 key_id[0] = HMAC_SHA_256_128;
16122 clib_warning ("invalid key_id: '%s'", s);
16123 key_id[0] = HMAC_NO_KEY;
16134 api_one_add_del_local_eid (vat_main_t * vam)
16136 unformat_input_t *input = vam->input;
16137 vl_api_one_add_del_local_eid_t *mp;
16140 lisp_eid_vat_t _eid, *eid = &_eid;
16141 u8 *locator_set_name = 0;
16142 u8 locator_set_name_set = 0;
16148 /* Parse args required to build the message */
16149 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16151 if (unformat (input, "del"))
16155 else if (unformat (input, "vni %d", &vni))
16159 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16163 else if (unformat (input, "locator-set %s", &locator_set_name))
16165 locator_set_name_set = 1;
16167 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16169 else if (unformat (input, "secret-key %_%v%_", &key))
16175 if (locator_set_name_set == 0)
16177 errmsg ("missing locator-set name");
16183 errmsg ("EID address not set!");
16184 vec_free (locator_set_name);
16188 if (key && (0 == key_id))
16190 errmsg ("invalid key_id!");
16194 if (vec_len (key) > 64)
16196 errmsg ("key too long");
16201 if (vec_len (locator_set_name) > 64)
16203 errmsg ("locator-set name too long");
16204 vec_free (locator_set_name);
16207 vec_add1 (locator_set_name, 0);
16209 /* Construct the API message */
16210 M (ONE_ADD_DEL_LOCAL_EID, mp);
16212 mp->is_add = is_add;
16213 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16214 mp->eid_type = eid->type;
16215 mp->prefix_len = eid->len;
16216 mp->vni = clib_host_to_net_u32 (vni);
16217 mp->key_id = clib_host_to_net_u16 (key_id);
16218 clib_memcpy (mp->locator_set_name, locator_set_name,
16219 vec_len (locator_set_name));
16220 clib_memcpy (mp->key, key, vec_len (key));
16222 vec_free (locator_set_name);
16228 /* Wait for a reply... */
16233 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16236 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16238 u32 dp_table = 0, vni = 0;;
16239 unformat_input_t *input = vam->input;
16240 vl_api_gpe_add_del_fwd_entry_t *mp;
16242 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16243 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16244 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16245 u32 action = ~0, w;
16246 ip4_address_t rmt_rloc4, lcl_rloc4;
16247 ip6_address_t rmt_rloc6, lcl_rloc6;
16248 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16251 memset (&rloc, 0, sizeof (rloc));
16253 /* Parse args required to build the message */
16254 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16256 if (unformat (input, "del"))
16258 else if (unformat (input, "add"))
16260 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16264 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16268 else if (unformat (input, "vrf %d", &dp_table))
16270 else if (unformat (input, "bd %d", &dp_table))
16272 else if (unformat (input, "vni %d", &vni))
16274 else if (unformat (input, "w %d", &w))
16278 errmsg ("No RLOC configured for setting priority/weight!");
16281 curr_rloc->weight = w;
16283 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16284 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16288 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16290 vec_add1 (lcl_locs, rloc);
16292 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16293 vec_add1 (rmt_locs, rloc);
16294 /* weight saved in rmt loc */
16295 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16297 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16298 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16301 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16303 vec_add1 (lcl_locs, rloc);
16305 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16306 vec_add1 (rmt_locs, rloc);
16307 /* weight saved in rmt loc */
16308 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16310 else if (unformat (input, "action %d", &action))
16316 clib_warning ("parse error '%U'", format_unformat_error, input);
16323 errmsg ("remote eid addresses not set");
16327 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16329 errmsg ("eid types don't match");
16333 if (0 == rmt_locs && (u32) ~ 0 == action)
16335 errmsg ("action not set for negative mapping");
16339 /* Construct the API message */
16340 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16341 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16343 mp->is_add = is_add;
16344 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16345 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16346 mp->eid_type = rmt_eid->type;
16347 mp->dp_table = clib_host_to_net_u32 (dp_table);
16348 mp->vni = clib_host_to_net_u32 (vni);
16349 mp->rmt_len = rmt_eid->len;
16350 mp->lcl_len = lcl_eid->len;
16351 mp->action = action;
16353 if (0 != rmt_locs && 0 != lcl_locs)
16355 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16356 clib_memcpy (mp->locs, lcl_locs,
16357 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16359 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16360 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16361 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16363 vec_free (lcl_locs);
16364 vec_free (rmt_locs);
16369 /* Wait for a reply... */
16375 api_one_add_del_map_server (vat_main_t * vam)
16377 unformat_input_t *input = vam->input;
16378 vl_api_one_add_del_map_server_t *mp;
16382 ip4_address_t ipv4;
16383 ip6_address_t ipv6;
16386 /* Parse args required to build the message */
16387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16389 if (unformat (input, "del"))
16393 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16397 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16405 if (ipv4_set && ipv6_set)
16407 errmsg ("both eid v4 and v6 addresses set");
16411 if (!ipv4_set && !ipv6_set)
16413 errmsg ("eid addresses not set");
16417 /* Construct the API message */
16418 M (ONE_ADD_DEL_MAP_SERVER, mp);
16420 mp->is_add = is_add;
16424 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16429 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16435 /* Wait for a reply... */
16440 #define api_lisp_add_del_map_server api_one_add_del_map_server
16443 api_one_add_del_map_resolver (vat_main_t * vam)
16445 unformat_input_t *input = vam->input;
16446 vl_api_one_add_del_map_resolver_t *mp;
16450 ip4_address_t ipv4;
16451 ip6_address_t ipv6;
16454 /* Parse args required to build the message */
16455 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16457 if (unformat (input, "del"))
16461 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16465 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16473 if (ipv4_set && ipv6_set)
16475 errmsg ("both eid v4 and v6 addresses set");
16479 if (!ipv4_set && !ipv6_set)
16481 errmsg ("eid addresses not set");
16485 /* Construct the API message */
16486 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16488 mp->is_add = is_add;
16492 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16497 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16503 /* Wait for a reply... */
16508 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16511 api_lisp_gpe_enable_disable (vat_main_t * vam)
16513 unformat_input_t *input = vam->input;
16514 vl_api_gpe_enable_disable_t *mp;
16519 /* Parse args required to build the message */
16520 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16522 if (unformat (input, "enable"))
16527 else if (unformat (input, "disable"))
16538 errmsg ("Value not set");
16542 /* Construct the API message */
16543 M (GPE_ENABLE_DISABLE, mp);
16550 /* Wait for a reply... */
16556 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16558 unformat_input_t *input = vam->input;
16559 vl_api_one_rloc_probe_enable_disable_t *mp;
16564 /* Parse args required to build the message */
16565 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16567 if (unformat (input, "enable"))
16572 else if (unformat (input, "disable"))
16580 errmsg ("Value not set");
16584 /* Construct the API message */
16585 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16587 mp->is_enabled = is_en;
16592 /* Wait for a reply... */
16597 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16600 api_one_map_register_enable_disable (vat_main_t * vam)
16602 unformat_input_t *input = vam->input;
16603 vl_api_one_map_register_enable_disable_t *mp;
16608 /* Parse args required to build the message */
16609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16611 if (unformat (input, "enable"))
16616 else if (unformat (input, "disable"))
16624 errmsg ("Value not set");
16628 /* Construct the API message */
16629 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16631 mp->is_enabled = is_en;
16636 /* Wait for a reply... */
16641 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16644 api_one_enable_disable (vat_main_t * vam)
16646 unformat_input_t *input = vam->input;
16647 vl_api_one_enable_disable_t *mp;
16652 /* Parse args required to build the message */
16653 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16655 if (unformat (input, "enable"))
16660 else if (unformat (input, "disable"))
16670 errmsg ("Value not set");
16674 /* Construct the API message */
16675 M (ONE_ENABLE_DISABLE, mp);
16682 /* Wait for a reply... */
16687 #define api_lisp_enable_disable api_one_enable_disable
16690 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16692 unformat_input_t *input = vam->input;
16693 vl_api_one_enable_disable_xtr_mode_t *mp;
16698 /* Parse args required to build the message */
16699 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16701 if (unformat (input, "enable"))
16706 else if (unformat (input, "disable"))
16716 errmsg ("Value not set");
16720 /* Construct the API message */
16721 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16728 /* Wait for a reply... */
16734 api_one_show_xtr_mode (vat_main_t * vam)
16736 vl_api_one_show_xtr_mode_t *mp;
16739 /* Construct the API message */
16740 M (ONE_SHOW_XTR_MODE, mp);
16745 /* Wait for a reply... */
16751 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16753 unformat_input_t *input = vam->input;
16754 vl_api_one_enable_disable_pitr_mode_t *mp;
16759 /* Parse args required to build the message */
16760 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16762 if (unformat (input, "enable"))
16767 else if (unformat (input, "disable"))
16777 errmsg ("Value not set");
16781 /* Construct the API message */
16782 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16789 /* Wait for a reply... */
16795 api_one_show_pitr_mode (vat_main_t * vam)
16797 vl_api_one_show_pitr_mode_t *mp;
16800 /* Construct the API message */
16801 M (ONE_SHOW_PITR_MODE, mp);
16806 /* Wait for a reply... */
16812 api_one_enable_disable_petr_mode (vat_main_t * vam)
16814 unformat_input_t *input = vam->input;
16815 vl_api_one_enable_disable_petr_mode_t *mp;
16820 /* Parse args required to build the message */
16821 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16823 if (unformat (input, "enable"))
16828 else if (unformat (input, "disable"))
16838 errmsg ("Value not set");
16842 /* Construct the API message */
16843 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16850 /* Wait for a reply... */
16856 api_one_show_petr_mode (vat_main_t * vam)
16858 vl_api_one_show_petr_mode_t *mp;
16861 /* Construct the API message */
16862 M (ONE_SHOW_PETR_MODE, mp);
16867 /* Wait for a reply... */
16873 api_show_one_map_register_state (vat_main_t * vam)
16875 vl_api_show_one_map_register_state_t *mp;
16878 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16883 /* wait for reply */
16888 #define api_show_lisp_map_register_state api_show_one_map_register_state
16891 api_show_one_rloc_probe_state (vat_main_t * vam)
16893 vl_api_show_one_rloc_probe_state_t *mp;
16896 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16901 /* wait for reply */
16906 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16909 api_one_add_del_ndp_entry (vat_main_t * vam)
16911 vl_api_one_add_del_ndp_entry_t *mp;
16912 unformat_input_t *input = vam->input;
16917 u8 mac[6] = { 0, };
16918 u8 ip6[16] = { 0, };
16922 /* Parse args required to build the message */
16923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16925 if (unformat (input, "del"))
16927 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16929 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16931 else if (unformat (input, "bd %d", &bd))
16935 errmsg ("parse error '%U'", format_unformat_error, input);
16940 if (!bd_set || !ip_set || (!mac_set && is_add))
16942 errmsg ("Missing BD, IP or MAC!");
16946 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16947 mp->is_add = is_add;
16948 clib_memcpy (mp->mac, mac, 6);
16949 mp->bd = clib_host_to_net_u32 (bd);
16950 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16955 /* wait for reply */
16961 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16963 vl_api_one_add_del_l2_arp_entry_t *mp;
16964 unformat_input_t *input = vam->input;
16969 u8 mac[6] = { 0, };
16970 u32 ip4 = 0, bd = ~0;
16973 /* Parse args required to build the message */
16974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16976 if (unformat (input, "del"))
16978 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16980 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16982 else if (unformat (input, "bd %d", &bd))
16986 errmsg ("parse error '%U'", format_unformat_error, input);
16991 if (!bd_set || !ip_set || (!mac_set && is_add))
16993 errmsg ("Missing BD, IP or MAC!");
16997 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16998 mp->is_add = is_add;
16999 clib_memcpy (mp->mac, mac, 6);
17000 mp->bd = clib_host_to_net_u32 (bd);
17006 /* wait for reply */
17012 api_one_ndp_bd_get (vat_main_t * vam)
17014 vl_api_one_ndp_bd_get_t *mp;
17017 M (ONE_NDP_BD_GET, mp);
17022 /* wait for reply */
17028 api_one_ndp_entries_get (vat_main_t * vam)
17030 vl_api_one_ndp_entries_get_t *mp;
17031 unformat_input_t *input = vam->input;
17036 /* Parse args required to build the message */
17037 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17039 if (unformat (input, "bd %d", &bd))
17043 errmsg ("parse error '%U'", format_unformat_error, input);
17050 errmsg ("Expected bridge domain!");
17054 M (ONE_NDP_ENTRIES_GET, mp);
17055 mp->bd = clib_host_to_net_u32 (bd);
17060 /* wait for reply */
17066 api_one_l2_arp_bd_get (vat_main_t * vam)
17068 vl_api_one_l2_arp_bd_get_t *mp;
17071 M (ONE_L2_ARP_BD_GET, mp);
17076 /* wait for reply */
17082 api_one_l2_arp_entries_get (vat_main_t * vam)
17084 vl_api_one_l2_arp_entries_get_t *mp;
17085 unformat_input_t *input = vam->input;
17090 /* Parse args required to build the message */
17091 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17093 if (unformat (input, "bd %d", &bd))
17097 errmsg ("parse error '%U'", format_unformat_error, input);
17104 errmsg ("Expected bridge domain!");
17108 M (ONE_L2_ARP_ENTRIES_GET, mp);
17109 mp->bd = clib_host_to_net_u32 (bd);
17114 /* wait for reply */
17120 api_one_stats_enable_disable (vat_main_t * vam)
17122 vl_api_one_stats_enable_disable_t *mp;
17123 unformat_input_t *input = vam->input;
17128 /* Parse args required to build the message */
17129 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17131 if (unformat (input, "enable"))
17136 else if (unformat (input, "disable"))
17146 errmsg ("Value not set");
17150 M (ONE_STATS_ENABLE_DISABLE, mp);
17156 /* wait for reply */
17162 api_show_one_stats_enable_disable (vat_main_t * vam)
17164 vl_api_show_one_stats_enable_disable_t *mp;
17167 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17172 /* wait for reply */
17178 api_show_one_map_request_mode (vat_main_t * vam)
17180 vl_api_show_one_map_request_mode_t *mp;
17183 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17188 /* wait for reply */
17193 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17196 api_one_map_request_mode (vat_main_t * vam)
17198 unformat_input_t *input = vam->input;
17199 vl_api_one_map_request_mode_t *mp;
17203 /* Parse args required to build the message */
17204 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17206 if (unformat (input, "dst-only"))
17208 else if (unformat (input, "src-dst"))
17212 errmsg ("parse error '%U'", format_unformat_error, input);
17217 M (ONE_MAP_REQUEST_MODE, mp);
17224 /* wait for reply */
17229 #define api_lisp_map_request_mode api_one_map_request_mode
17232 * Enable/disable ONE proxy ITR.
17234 * @param vam vpp API test context
17235 * @return return code
17238 api_one_pitr_set_locator_set (vat_main_t * vam)
17240 u8 ls_name_set = 0;
17241 unformat_input_t *input = vam->input;
17242 vl_api_one_pitr_set_locator_set_t *mp;
17247 /* Parse args required to build the message */
17248 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17250 if (unformat (input, "del"))
17252 else if (unformat (input, "locator-set %s", &ls_name))
17256 errmsg ("parse error '%U'", format_unformat_error, input);
17263 errmsg ("locator-set name not set!");
17267 M (ONE_PITR_SET_LOCATOR_SET, mp);
17269 mp->is_add = is_add;
17270 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17271 vec_free (ls_name);
17276 /* wait for reply */
17281 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17284 api_one_nsh_set_locator_set (vat_main_t * vam)
17286 u8 ls_name_set = 0;
17287 unformat_input_t *input = vam->input;
17288 vl_api_one_nsh_set_locator_set_t *mp;
17293 /* Parse args required to build the message */
17294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17296 if (unformat (input, "del"))
17298 else if (unformat (input, "ls %s", &ls_name))
17302 errmsg ("parse error '%U'", format_unformat_error, input);
17307 if (!ls_name_set && is_add)
17309 errmsg ("locator-set name not set!");
17313 M (ONE_NSH_SET_LOCATOR_SET, mp);
17315 mp->is_add = is_add;
17316 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17317 vec_free (ls_name);
17322 /* wait for reply */
17328 api_show_one_pitr (vat_main_t * vam)
17330 vl_api_show_one_pitr_t *mp;
17333 if (!vam->json_output)
17335 print (vam->ofp, "%=20s", "lisp status:");
17338 M (SHOW_ONE_PITR, mp);
17342 /* Wait for a reply... */
17347 #define api_show_lisp_pitr api_show_one_pitr
17350 api_one_use_petr (vat_main_t * vam)
17352 unformat_input_t *input = vam->input;
17353 vl_api_one_use_petr_t *mp;
17358 memset (&ip, 0, sizeof (ip));
17360 /* Parse args required to build the message */
17361 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17363 if (unformat (input, "disable"))
17366 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17369 ip_addr_version (&ip) = IP4;
17372 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17375 ip_addr_version (&ip) = IP6;
17379 errmsg ("parse error '%U'", format_unformat_error, input);
17384 M (ONE_USE_PETR, mp);
17386 mp->is_add = is_add;
17389 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17391 clib_memcpy (mp->address, &ip, 4);
17393 clib_memcpy (mp->address, &ip, 16);
17399 /* wait for reply */
17404 #define api_lisp_use_petr api_one_use_petr
17407 api_show_one_nsh_mapping (vat_main_t * vam)
17409 vl_api_show_one_use_petr_t *mp;
17412 if (!vam->json_output)
17414 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17417 M (SHOW_ONE_NSH_MAPPING, mp);
17421 /* Wait for a reply... */
17427 api_show_one_use_petr (vat_main_t * vam)
17429 vl_api_show_one_use_petr_t *mp;
17432 if (!vam->json_output)
17434 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17437 M (SHOW_ONE_USE_PETR, mp);
17441 /* Wait for a reply... */
17446 #define api_show_lisp_use_petr api_show_one_use_petr
17449 * Add/delete mapping between vni and vrf
17452 api_one_eid_table_add_del_map (vat_main_t * vam)
17454 unformat_input_t *input = vam->input;
17455 vl_api_one_eid_table_add_del_map_t *mp;
17456 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17457 u32 vni, vrf, bd_index;
17460 /* Parse args required to build the message */
17461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17463 if (unformat (input, "del"))
17465 else if (unformat (input, "vrf %d", &vrf))
17467 else if (unformat (input, "bd_index %d", &bd_index))
17469 else if (unformat (input, "vni %d", &vni))
17475 if (!vni_set || (!vrf_set && !bd_index_set))
17477 errmsg ("missing arguments!");
17481 if (vrf_set && bd_index_set)
17483 errmsg ("error: both vrf and bd entered!");
17487 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17489 mp->is_add = is_add;
17490 mp->vni = htonl (vni);
17491 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17492 mp->is_l2 = bd_index_set;
17497 /* wait for reply */
17502 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17505 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17507 u32 *action = va_arg (*args, u32 *);
17510 if (unformat (input, "%s", &s))
17512 if (!strcmp ((char *) s, "no-action"))
17514 else if (!strcmp ((char *) s, "natively-forward"))
17516 else if (!strcmp ((char *) s, "send-map-request"))
17518 else if (!strcmp ((char *) s, "drop"))
17522 clib_warning ("invalid action: '%s'", s);
17534 * Add/del remote mapping to/from ONE control plane
17536 * @param vam vpp API test context
17537 * @return return code
17540 api_one_add_del_remote_mapping (vat_main_t * vam)
17542 unformat_input_t *input = vam->input;
17543 vl_api_one_add_del_remote_mapping_t *mp;
17545 lisp_eid_vat_t _eid, *eid = &_eid;
17546 lisp_eid_vat_t _seid, *seid = &_seid;
17547 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17548 u32 action = ~0, p, w, data_len;
17549 ip4_address_t rloc4;
17550 ip6_address_t rloc6;
17551 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17554 memset (&rloc, 0, sizeof (rloc));
17556 /* Parse args required to build the message */
17557 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17559 if (unformat (input, "del-all"))
17563 else if (unformat (input, "del"))
17567 else if (unformat (input, "add"))
17571 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17575 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17579 else if (unformat (input, "vni %d", &vni))
17583 else if (unformat (input, "p %d w %d", &p, &w))
17587 errmsg ("No RLOC configured for setting priority/weight!");
17590 curr_rloc->priority = p;
17591 curr_rloc->weight = w;
17593 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17596 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17597 vec_add1 (rlocs, rloc);
17598 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17600 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17603 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17604 vec_add1 (rlocs, rloc);
17605 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17607 else if (unformat (input, "action %U",
17608 unformat_negative_mapping_action, &action))
17614 clib_warning ("parse error '%U'", format_unformat_error, input);
17621 errmsg ("missing params!");
17625 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17627 errmsg ("no action set for negative map-reply!");
17631 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17633 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17634 mp->is_add = is_add;
17635 mp->vni = htonl (vni);
17636 mp->action = (u8) action;
17637 mp->is_src_dst = seid_set;
17638 mp->eid_len = eid->len;
17639 mp->seid_len = seid->len;
17640 mp->del_all = del_all;
17641 mp->eid_type = eid->type;
17642 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17643 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17645 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17646 clib_memcpy (mp->rlocs, rlocs, data_len);
17652 /* Wait for a reply... */
17657 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17660 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17661 * forwarding entries in data-plane accordingly.
17663 * @param vam vpp API test context
17664 * @return return code
17667 api_one_add_del_adjacency (vat_main_t * vam)
17669 unformat_input_t *input = vam->input;
17670 vl_api_one_add_del_adjacency_t *mp;
17672 ip4_address_t leid4, reid4;
17673 ip6_address_t leid6, reid6;
17674 u8 reid_mac[6] = { 0 };
17675 u8 leid_mac[6] = { 0 };
17676 u8 reid_type, leid_type;
17677 u32 leid_len = 0, reid_len = 0, len;
17681 leid_type = reid_type = (u8) ~ 0;
17683 /* Parse args required to build the message */
17684 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17686 if (unformat (input, "del"))
17690 else if (unformat (input, "add"))
17694 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17697 reid_type = 0; /* ipv4 */
17700 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17703 reid_type = 1; /* ipv6 */
17706 else if (unformat (input, "reid %U", unformat_ethernet_address,
17709 reid_type = 2; /* mac */
17711 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17714 leid_type = 0; /* ipv4 */
17717 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17720 leid_type = 1; /* ipv6 */
17723 else if (unformat (input, "leid %U", unformat_ethernet_address,
17726 leid_type = 2; /* mac */
17728 else if (unformat (input, "vni %d", &vni))
17734 errmsg ("parse error '%U'", format_unformat_error, input);
17739 if ((u8) ~ 0 == reid_type)
17741 errmsg ("missing params!");
17745 if (leid_type != reid_type)
17747 errmsg ("remote and local EIDs are of different types!");
17751 M (ONE_ADD_DEL_ADJACENCY, mp);
17752 mp->is_add = is_add;
17753 mp->vni = htonl (vni);
17754 mp->leid_len = leid_len;
17755 mp->reid_len = reid_len;
17756 mp->eid_type = reid_type;
17758 switch (mp->eid_type)
17761 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17762 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17765 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17766 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17769 clib_memcpy (mp->leid, leid_mac, 6);
17770 clib_memcpy (mp->reid, reid_mac, 6);
17773 errmsg ("unknown EID type %d!", mp->eid_type);
17780 /* Wait for a reply... */
17785 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17788 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17790 u32 *mode = va_arg (*args, u32 *);
17792 if (unformat (input, "lisp"))
17794 else if (unformat (input, "vxlan"))
17803 api_gpe_get_encap_mode (vat_main_t * vam)
17805 vl_api_gpe_get_encap_mode_t *mp;
17808 /* Construct the API message */
17809 M (GPE_GET_ENCAP_MODE, mp);
17814 /* Wait for a reply... */
17820 api_gpe_set_encap_mode (vat_main_t * vam)
17822 unformat_input_t *input = vam->input;
17823 vl_api_gpe_set_encap_mode_t *mp;
17827 /* Parse args required to build the message */
17828 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17830 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17836 /* Construct the API message */
17837 M (GPE_SET_ENCAP_MODE, mp);
17844 /* Wait for a reply... */
17850 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17852 unformat_input_t *input = vam->input;
17853 vl_api_gpe_add_del_iface_t *mp;
17854 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17855 u32 dp_table = 0, vni = 0;
17858 /* Parse args required to build the message */
17859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17861 if (unformat (input, "up"))
17866 else if (unformat (input, "down"))
17871 else if (unformat (input, "table_id %d", &dp_table))
17875 else if (unformat (input, "bd_id %d", &dp_table))
17880 else if (unformat (input, "vni %d", &vni))
17888 if (action_set == 0)
17890 errmsg ("Action not set");
17893 if (dp_table_set == 0 || vni_set == 0)
17895 errmsg ("vni and dp_table must be set");
17899 /* Construct the API message */
17900 M (GPE_ADD_DEL_IFACE, mp);
17902 mp->is_add = is_add;
17903 mp->dp_table = clib_host_to_net_u32 (dp_table);
17905 mp->vni = clib_host_to_net_u32 (vni);
17910 /* Wait for a reply... */
17916 api_one_map_register_fallback_threshold (vat_main_t * vam)
17918 unformat_input_t *input = vam->input;
17919 vl_api_one_map_register_fallback_threshold_t *mp;
17924 /* Parse args required to build the message */
17925 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17927 if (unformat (input, "%u", &value))
17931 clib_warning ("parse error '%U'", format_unformat_error, input);
17938 errmsg ("fallback threshold value is missing!");
17942 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17943 mp->value = clib_host_to_net_u32 (value);
17948 /* Wait for a reply... */
17954 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17956 vl_api_show_one_map_register_fallback_threshold_t *mp;
17959 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17964 /* Wait for a reply... */
17970 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17972 u32 *proto = va_arg (*args, u32 *);
17974 if (unformat (input, "udp"))
17976 else if (unformat (input, "api"))
17985 api_one_set_transport_protocol (vat_main_t * vam)
17987 unformat_input_t *input = vam->input;
17988 vl_api_one_set_transport_protocol_t *mp;
17993 /* Parse args required to build the message */
17994 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17996 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18000 clib_warning ("parse error '%U'", format_unformat_error, input);
18007 errmsg ("Transport protocol missing!");
18011 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18012 mp->protocol = (u8) protocol;
18017 /* Wait for a reply... */
18023 api_one_get_transport_protocol (vat_main_t * vam)
18025 vl_api_one_get_transport_protocol_t *mp;
18028 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18033 /* Wait for a reply... */
18039 api_one_map_register_set_ttl (vat_main_t * vam)
18041 unformat_input_t *input = vam->input;
18042 vl_api_one_map_register_set_ttl_t *mp;
18047 /* Parse args required to build the message */
18048 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18050 if (unformat (input, "%u", &ttl))
18054 clib_warning ("parse error '%U'", format_unformat_error, input);
18061 errmsg ("TTL value missing!");
18065 M (ONE_MAP_REGISTER_SET_TTL, mp);
18066 mp->ttl = clib_host_to_net_u32 (ttl);
18071 /* Wait for a reply... */
18077 api_show_one_map_register_ttl (vat_main_t * vam)
18079 vl_api_show_one_map_register_ttl_t *mp;
18082 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18087 /* Wait for a reply... */
18093 * Add/del map request itr rlocs from ONE control plane and updates
18095 * @param vam vpp API test context
18096 * @return return code
18099 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18101 unformat_input_t *input = vam->input;
18102 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18103 u8 *locator_set_name = 0;
18104 u8 locator_set_name_set = 0;
18108 /* Parse args required to build the message */
18109 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18111 if (unformat (input, "del"))
18115 else if (unformat (input, "%_%v%_", &locator_set_name))
18117 locator_set_name_set = 1;
18121 clib_warning ("parse error '%U'", format_unformat_error, input);
18126 if (is_add && !locator_set_name_set)
18128 errmsg ("itr-rloc is not set!");
18132 if (is_add && vec_len (locator_set_name) > 64)
18134 errmsg ("itr-rloc locator-set name too long");
18135 vec_free (locator_set_name);
18139 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18140 mp->is_add = is_add;
18143 clib_memcpy (mp->locator_set_name, locator_set_name,
18144 vec_len (locator_set_name));
18148 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18150 vec_free (locator_set_name);
18155 /* Wait for a reply... */
18160 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18163 api_one_locator_dump (vat_main_t * vam)
18165 unformat_input_t *input = vam->input;
18166 vl_api_one_locator_dump_t *mp;
18167 vl_api_control_ping_t *mp_ping;
18168 u8 is_index_set = 0, is_name_set = 0;
18173 /* Parse args required to build the message */
18174 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18176 if (unformat (input, "ls_name %_%v%_", &ls_name))
18180 else if (unformat (input, "ls_index %d", &ls_index))
18186 errmsg ("parse error '%U'", format_unformat_error, input);
18191 if (!is_index_set && !is_name_set)
18193 errmsg ("error: expected one of index or name!");
18197 if (is_index_set && is_name_set)
18199 errmsg ("error: only one param expected!");
18203 if (vec_len (ls_name) > 62)
18205 errmsg ("error: locator set name too long!");
18209 if (!vam->json_output)
18211 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18214 M (ONE_LOCATOR_DUMP, mp);
18215 mp->is_index_set = is_index_set;
18218 mp->ls_index = clib_host_to_net_u32 (ls_index);
18221 vec_add1 (ls_name, 0);
18222 strncpy ((char *) mp->ls_name, (char *) ls_name,
18223 sizeof (mp->ls_name) - 1);
18229 /* Use a control ping for synchronization */
18230 MPING (CONTROL_PING, mp_ping);
18233 /* Wait for a reply... */
18238 #define api_lisp_locator_dump api_one_locator_dump
18241 api_one_locator_set_dump (vat_main_t * vam)
18243 vl_api_one_locator_set_dump_t *mp;
18244 vl_api_control_ping_t *mp_ping;
18245 unformat_input_t *input = vam->input;
18249 /* Parse args required to build the message */
18250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18252 if (unformat (input, "local"))
18256 else if (unformat (input, "remote"))
18262 errmsg ("parse error '%U'", format_unformat_error, input);
18267 if (!vam->json_output)
18269 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18272 M (ONE_LOCATOR_SET_DUMP, mp);
18274 mp->filter = filter;
18279 /* Use a control ping for synchronization */
18280 MPING (CONTROL_PING, mp_ping);
18283 /* Wait for a reply... */
18288 #define api_lisp_locator_set_dump api_one_locator_set_dump
18291 api_one_eid_table_map_dump (vat_main_t * vam)
18295 unformat_input_t *input = vam->input;
18296 vl_api_one_eid_table_map_dump_t *mp;
18297 vl_api_control_ping_t *mp_ping;
18300 /* Parse args required to build the message */
18301 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18303 if (unformat (input, "l2"))
18308 else if (unformat (input, "l3"))
18315 errmsg ("parse error '%U'", format_unformat_error, input);
18322 errmsg ("expected one of 'l2' or 'l3' parameter!");
18326 if (!vam->json_output)
18328 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18331 M (ONE_EID_TABLE_MAP_DUMP, mp);
18337 /* Use a control ping for synchronization */
18338 MPING (CONTROL_PING, mp_ping);
18341 /* Wait for a reply... */
18346 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18349 api_one_eid_table_vni_dump (vat_main_t * vam)
18351 vl_api_one_eid_table_vni_dump_t *mp;
18352 vl_api_control_ping_t *mp_ping;
18355 if (!vam->json_output)
18357 print (vam->ofp, "VNI");
18360 M (ONE_EID_TABLE_VNI_DUMP, mp);
18365 /* Use a control ping for synchronization */
18366 MPING (CONTROL_PING, mp_ping);
18369 /* Wait for a reply... */
18374 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18377 api_one_eid_table_dump (vat_main_t * vam)
18379 unformat_input_t *i = vam->input;
18380 vl_api_one_eid_table_dump_t *mp;
18381 vl_api_control_ping_t *mp_ping;
18382 struct in_addr ip4;
18383 struct in6_addr ip6;
18385 u8 eid_type = ~0, eid_set = 0;
18386 u32 prefix_length = ~0, t, vni = 0;
18389 lisp_nsh_api_t nsh;
18391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18393 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18399 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18405 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18410 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18415 else if (unformat (i, "vni %d", &t))
18419 else if (unformat (i, "local"))
18423 else if (unformat (i, "remote"))
18429 errmsg ("parse error '%U'", format_unformat_error, i);
18434 if (!vam->json_output)
18436 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18437 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18440 M (ONE_EID_TABLE_DUMP, mp);
18442 mp->filter = filter;
18446 mp->vni = htonl (vni);
18447 mp->eid_type = eid_type;
18451 mp->prefix_length = prefix_length;
18452 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18455 mp->prefix_length = prefix_length;
18456 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18459 clib_memcpy (mp->eid, mac, sizeof (mac));
18462 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18465 errmsg ("unknown EID type %d!", eid_type);
18473 /* Use a control ping for synchronization */
18474 MPING (CONTROL_PING, mp_ping);
18477 /* Wait for a reply... */
18482 #define api_lisp_eid_table_dump api_one_eid_table_dump
18485 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18487 unformat_input_t *i = vam->input;
18488 vl_api_gpe_fwd_entries_get_t *mp;
18493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18495 if (unformat (i, "vni %d", &vni))
18501 errmsg ("parse error '%U'", format_unformat_error, i);
18508 errmsg ("vni not set!");
18512 if (!vam->json_output)
18514 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18518 M (GPE_FWD_ENTRIES_GET, mp);
18519 mp->vni = clib_host_to_net_u32 (vni);
18524 /* Wait for a reply... */
18529 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18530 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18531 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18532 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18533 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18534 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18535 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18536 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18539 api_one_adjacencies_get (vat_main_t * vam)
18541 unformat_input_t *i = vam->input;
18542 vl_api_one_adjacencies_get_t *mp;
18547 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18549 if (unformat (i, "vni %d", &vni))
18555 errmsg ("parse error '%U'", format_unformat_error, i);
18562 errmsg ("vni not set!");
18566 if (!vam->json_output)
18568 print (vam->ofp, "%s %40s", "leid", "reid");
18571 M (ONE_ADJACENCIES_GET, mp);
18572 mp->vni = clib_host_to_net_u32 (vni);
18577 /* Wait for a reply... */
18582 #define api_lisp_adjacencies_get api_one_adjacencies_get
18585 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18587 unformat_input_t *i = vam->input;
18588 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18590 u8 ip_family_set = 0, is_ip4 = 1;
18592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18594 if (unformat (i, "ip4"))
18599 else if (unformat (i, "ip6"))
18606 errmsg ("parse error '%U'", format_unformat_error, i);
18611 if (!ip_family_set)
18613 errmsg ("ip family not set!");
18617 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18618 mp->is_ip4 = is_ip4;
18623 /* Wait for a reply... */
18629 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18631 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18634 if (!vam->json_output)
18636 print (vam->ofp, "VNIs");
18639 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18644 /* Wait for a reply... */
18650 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18652 unformat_input_t *i = vam->input;
18653 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18655 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18656 struct in_addr ip4;
18657 struct in6_addr ip6;
18658 u32 table_id = 0, nh_sw_if_index = ~0;
18660 memset (&ip4, 0, sizeof (ip4));
18661 memset (&ip6, 0, sizeof (ip6));
18663 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18665 if (unformat (i, "del"))
18667 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18668 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18673 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18674 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18679 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18683 nh_sw_if_index = ~0;
18685 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18689 nh_sw_if_index = ~0;
18691 else if (unformat (i, "table %d", &table_id))
18695 errmsg ("parse error '%U'", format_unformat_error, i);
18702 errmsg ("nh addr not set!");
18706 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18707 mp->is_add = is_add;
18708 mp->table_id = clib_host_to_net_u32 (table_id);
18709 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18710 mp->is_ip4 = is_ip4;
18712 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18714 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18719 /* Wait for a reply... */
18725 api_one_map_server_dump (vat_main_t * vam)
18727 vl_api_one_map_server_dump_t *mp;
18728 vl_api_control_ping_t *mp_ping;
18731 if (!vam->json_output)
18733 print (vam->ofp, "%=20s", "Map server");
18736 M (ONE_MAP_SERVER_DUMP, mp);
18740 /* Use a control ping for synchronization */
18741 MPING (CONTROL_PING, mp_ping);
18744 /* Wait for a reply... */
18749 #define api_lisp_map_server_dump api_one_map_server_dump
18752 api_one_map_resolver_dump (vat_main_t * vam)
18754 vl_api_one_map_resolver_dump_t *mp;
18755 vl_api_control_ping_t *mp_ping;
18758 if (!vam->json_output)
18760 print (vam->ofp, "%=20s", "Map resolver");
18763 M (ONE_MAP_RESOLVER_DUMP, mp);
18767 /* Use a control ping for synchronization */
18768 MPING (CONTROL_PING, mp_ping);
18771 /* Wait for a reply... */
18776 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18779 api_one_stats_flush (vat_main_t * vam)
18781 vl_api_one_stats_flush_t *mp;
18784 M (ONE_STATS_FLUSH, mp);
18791 api_one_stats_dump (vat_main_t * vam)
18793 vl_api_one_stats_dump_t *mp;
18794 vl_api_control_ping_t *mp_ping;
18797 M (ONE_STATS_DUMP, mp);
18801 /* Use a control ping for synchronization */
18802 MPING (CONTROL_PING, mp_ping);
18805 /* Wait for a reply... */
18811 api_show_one_status (vat_main_t * vam)
18813 vl_api_show_one_status_t *mp;
18816 if (!vam->json_output)
18818 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18821 M (SHOW_ONE_STATUS, mp);
18824 /* Wait for a reply... */
18829 #define api_show_lisp_status api_show_one_status
18832 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18834 vl_api_gpe_fwd_entry_path_dump_t *mp;
18835 vl_api_control_ping_t *mp_ping;
18836 unformat_input_t *i = vam->input;
18837 u32 fwd_entry_index = ~0;
18840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18842 if (unformat (i, "index %d", &fwd_entry_index))
18848 if (~0 == fwd_entry_index)
18850 errmsg ("no index specified!");
18854 if (!vam->json_output)
18856 print (vam->ofp, "first line");
18859 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18863 /* Use a control ping for synchronization */
18864 MPING (CONTROL_PING, mp_ping);
18867 /* Wait for a reply... */
18873 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18875 vl_api_one_get_map_request_itr_rlocs_t *mp;
18878 if (!vam->json_output)
18880 print (vam->ofp, "%=20s", "itr-rlocs:");
18883 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18886 /* Wait for a reply... */
18891 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18894 api_af_packet_create (vat_main_t * vam)
18896 unformat_input_t *i = vam->input;
18897 vl_api_af_packet_create_t *mp;
18898 u8 *host_if_name = 0;
18900 u8 random_hw_addr = 1;
18903 memset (hw_addr, 0, sizeof (hw_addr));
18905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18907 if (unformat (i, "name %s", &host_if_name))
18908 vec_add1 (host_if_name, 0);
18909 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18910 random_hw_addr = 0;
18915 if (!vec_len (host_if_name))
18917 errmsg ("host-interface name must be specified");
18921 if (vec_len (host_if_name) > 64)
18923 errmsg ("host-interface name too long");
18927 M (AF_PACKET_CREATE, mp);
18929 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18930 clib_memcpy (mp->hw_addr, hw_addr, 6);
18931 mp->use_random_hw_addr = random_hw_addr;
18932 vec_free (host_if_name);
18940 fprintf (vam->ofp ? vam->ofp : stderr,
18941 " new sw_if_index = %d\n", vam->sw_if_index);
18948 api_af_packet_delete (vat_main_t * vam)
18950 unformat_input_t *i = vam->input;
18951 vl_api_af_packet_delete_t *mp;
18952 u8 *host_if_name = 0;
18955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18957 if (unformat (i, "name %s", &host_if_name))
18958 vec_add1 (host_if_name, 0);
18963 if (!vec_len (host_if_name))
18965 errmsg ("host-interface name must be specified");
18969 if (vec_len (host_if_name) > 64)
18971 errmsg ("host-interface name too long");
18975 M (AF_PACKET_DELETE, mp);
18977 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18978 vec_free (host_if_name);
18986 api_policer_add_del (vat_main_t * vam)
18988 unformat_input_t *i = vam->input;
18989 vl_api_policer_add_del_t *mp;
18999 u8 color_aware = 0;
19000 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19003 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19004 conform_action.dscp = 0;
19005 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19006 exceed_action.dscp = 0;
19007 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19008 violate_action.dscp = 0;
19010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19012 if (unformat (i, "del"))
19014 else if (unformat (i, "name %s", &name))
19015 vec_add1 (name, 0);
19016 else if (unformat (i, "cir %u", &cir))
19018 else if (unformat (i, "eir %u", &eir))
19020 else if (unformat (i, "cb %u", &cb))
19022 else if (unformat (i, "eb %u", &eb))
19024 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19027 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19030 else if (unformat (i, "type %U", unformat_policer_type, &type))
19032 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19035 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19038 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19041 else if (unformat (i, "color-aware"))
19047 if (!vec_len (name))
19049 errmsg ("policer name must be specified");
19053 if (vec_len (name) > 64)
19055 errmsg ("policer name too long");
19059 M (POLICER_ADD_DEL, mp);
19061 clib_memcpy (mp->name, name, vec_len (name));
19063 mp->is_add = is_add;
19064 mp->cir = ntohl (cir);
19065 mp->eir = ntohl (eir);
19066 mp->cb = clib_net_to_host_u64 (cb);
19067 mp->eb = clib_net_to_host_u64 (eb);
19068 mp->rate_type = rate_type;
19069 mp->round_type = round_type;
19071 mp->conform_action_type = conform_action.action_type;
19072 mp->conform_dscp = conform_action.dscp;
19073 mp->exceed_action_type = exceed_action.action_type;
19074 mp->exceed_dscp = exceed_action.dscp;
19075 mp->violate_action_type = violate_action.action_type;
19076 mp->violate_dscp = violate_action.dscp;
19077 mp->color_aware = color_aware;
19085 api_policer_dump (vat_main_t * vam)
19087 unformat_input_t *i = vam->input;
19088 vl_api_policer_dump_t *mp;
19089 vl_api_control_ping_t *mp_ping;
19090 u8 *match_name = 0;
19091 u8 match_name_valid = 0;
19094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19096 if (unformat (i, "name %s", &match_name))
19098 vec_add1 (match_name, 0);
19099 match_name_valid = 1;
19105 M (POLICER_DUMP, mp);
19106 mp->match_name_valid = match_name_valid;
19107 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19108 vec_free (match_name);
19112 /* Use a control ping for synchronization */
19113 MPING (CONTROL_PING, mp_ping);
19116 /* Wait for a reply... */
19122 api_policer_classify_set_interface (vat_main_t * vam)
19124 unformat_input_t *i = vam->input;
19125 vl_api_policer_classify_set_interface_t *mp;
19127 int sw_if_index_set;
19128 u32 ip4_table_index = ~0;
19129 u32 ip6_table_index = ~0;
19130 u32 l2_table_index = ~0;
19134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19137 sw_if_index_set = 1;
19138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19139 sw_if_index_set = 1;
19140 else if (unformat (i, "del"))
19142 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19144 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19146 else if (unformat (i, "l2-table %d", &l2_table_index))
19150 clib_warning ("parse error '%U'", format_unformat_error, i);
19155 if (sw_if_index_set == 0)
19157 errmsg ("missing interface name or sw_if_index");
19161 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19163 mp->sw_if_index = ntohl (sw_if_index);
19164 mp->ip4_table_index = ntohl (ip4_table_index);
19165 mp->ip6_table_index = ntohl (ip6_table_index);
19166 mp->l2_table_index = ntohl (l2_table_index);
19167 mp->is_add = is_add;
19175 api_policer_classify_dump (vat_main_t * vam)
19177 unformat_input_t *i = vam->input;
19178 vl_api_policer_classify_dump_t *mp;
19179 vl_api_control_ping_t *mp_ping;
19180 u8 type = POLICER_CLASSIFY_N_TABLES;
19183 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19187 errmsg ("classify table type must be specified");
19191 if (!vam->json_output)
19193 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19196 M (POLICER_CLASSIFY_DUMP, mp);
19201 /* Use a control ping for synchronization */
19202 MPING (CONTROL_PING, mp_ping);
19205 /* Wait for a reply... */
19211 api_netmap_create (vat_main_t * vam)
19213 unformat_input_t *i = vam->input;
19214 vl_api_netmap_create_t *mp;
19217 u8 random_hw_addr = 1;
19222 memset (hw_addr, 0, sizeof (hw_addr));
19224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19226 if (unformat (i, "name %s", &if_name))
19227 vec_add1 (if_name, 0);
19228 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19229 random_hw_addr = 0;
19230 else if (unformat (i, "pipe"))
19232 else if (unformat (i, "master"))
19234 else if (unformat (i, "slave"))
19240 if (!vec_len (if_name))
19242 errmsg ("interface name must be specified");
19246 if (vec_len (if_name) > 64)
19248 errmsg ("interface name too long");
19252 M (NETMAP_CREATE, mp);
19254 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19255 clib_memcpy (mp->hw_addr, hw_addr, 6);
19256 mp->use_random_hw_addr = random_hw_addr;
19257 mp->is_pipe = is_pipe;
19258 mp->is_master = is_master;
19259 vec_free (if_name);
19267 api_netmap_delete (vat_main_t * vam)
19269 unformat_input_t *i = vam->input;
19270 vl_api_netmap_delete_t *mp;
19274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19276 if (unformat (i, "name %s", &if_name))
19277 vec_add1 (if_name, 0);
19282 if (!vec_len (if_name))
19284 errmsg ("interface name must be specified");
19288 if (vec_len (if_name) > 64)
19290 errmsg ("interface name too long");
19294 M (NETMAP_DELETE, mp);
19296 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19297 vec_free (if_name);
19305 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19307 if (fp->afi == IP46_TYPE_IP6)
19309 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19310 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19311 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19312 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19313 format_ip6_address, fp->next_hop);
19314 else if (fp->afi == IP46_TYPE_IP4)
19316 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19317 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19318 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19319 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19320 format_ip4_address, fp->next_hop);
19324 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19325 vl_api_fib_path2_t * fp)
19327 struct in_addr ip4;
19328 struct in6_addr ip6;
19330 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19331 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19332 vat_json_object_add_uint (node, "is_local", fp->is_local);
19333 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19334 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19335 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19336 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19337 if (fp->afi == IP46_TYPE_IP4)
19339 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19340 vat_json_object_add_ip4 (node, "next_hop", ip4);
19342 else if (fp->afi == IP46_TYPE_IP6)
19344 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19345 vat_json_object_add_ip6 (node, "next_hop", ip6);
19350 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19352 vat_main_t *vam = &vat_main;
19353 int count = ntohl (mp->mt_count);
19354 vl_api_fib_path2_t *fp;
19357 print (vam->ofp, "[%d]: sw_if_index %d via:",
19358 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19360 for (i = 0; i < count; i++)
19362 vl_api_mpls_fib_path_print (vam, fp);
19366 print (vam->ofp, "");
19369 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19370 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19373 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19375 vat_main_t *vam = &vat_main;
19376 vat_json_node_t *node = NULL;
19377 int count = ntohl (mp->mt_count);
19378 vl_api_fib_path2_t *fp;
19381 if (VAT_JSON_ARRAY != vam->json_tree.type)
19383 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19384 vat_json_init_array (&vam->json_tree);
19386 node = vat_json_array_add (&vam->json_tree);
19388 vat_json_init_object (node);
19389 vat_json_object_add_uint (node, "tunnel_index",
19390 ntohl (mp->mt_tunnel_index));
19391 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19393 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19396 for (i = 0; i < count; i++)
19398 vl_api_mpls_fib_path_json_print (node, fp);
19404 api_mpls_tunnel_dump (vat_main_t * vam)
19406 vl_api_mpls_tunnel_dump_t *mp;
19407 vl_api_control_ping_t *mp_ping;
19411 /* Parse args required to build the message */
19412 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19414 if (!unformat (vam->input, "tunnel_index %d", &index))
19421 print (vam->ofp, " tunnel_index %d", index);
19423 M (MPLS_TUNNEL_DUMP, mp);
19424 mp->tunnel_index = htonl (index);
19427 /* Use a control ping for synchronization */
19428 MPING (CONTROL_PING, mp_ping);
19435 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19436 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19440 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19442 vat_main_t *vam = &vat_main;
19443 int count = ntohl (mp->count);
19444 vl_api_fib_path2_t *fp;
19448 "table-id %d, label %u, ess_bit %u",
19449 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19451 for (i = 0; i < count; i++)
19453 vl_api_mpls_fib_path_print (vam, fp);
19458 static void vl_api_mpls_fib_details_t_handler_json
19459 (vl_api_mpls_fib_details_t * mp)
19461 vat_main_t *vam = &vat_main;
19462 int count = ntohl (mp->count);
19463 vat_json_node_t *node = NULL;
19464 vl_api_fib_path2_t *fp;
19467 if (VAT_JSON_ARRAY != vam->json_tree.type)
19469 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19470 vat_json_init_array (&vam->json_tree);
19472 node = vat_json_array_add (&vam->json_tree);
19474 vat_json_init_object (node);
19475 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19476 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19477 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19478 vat_json_object_add_uint (node, "path_count", count);
19480 for (i = 0; i < count; i++)
19482 vl_api_mpls_fib_path_json_print (node, fp);
19488 api_mpls_fib_dump (vat_main_t * vam)
19490 vl_api_mpls_fib_dump_t *mp;
19491 vl_api_control_ping_t *mp_ping;
19494 M (MPLS_FIB_DUMP, mp);
19497 /* Use a control ping for synchronization */
19498 MPING (CONTROL_PING, mp_ping);
19505 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19506 #define vl_api_ip_fib_details_t_print vl_noop_handler
19509 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19511 vat_main_t *vam = &vat_main;
19512 int count = ntohl (mp->count);
19513 vl_api_fib_path_t *fp;
19517 "table-id %d, prefix %U/%d",
19518 ntohl (mp->table_id), format_ip4_address, mp->address,
19519 mp->address_length);
19521 for (i = 0; i < count; i++)
19523 if (fp->afi == IP46_TYPE_IP6)
19525 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19526 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19527 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19528 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19529 format_ip6_address, fp->next_hop);
19530 else if (fp->afi == IP46_TYPE_IP4)
19532 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19533 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19534 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19535 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19536 format_ip4_address, fp->next_hop);
19541 static void vl_api_ip_fib_details_t_handler_json
19542 (vl_api_ip_fib_details_t * mp)
19544 vat_main_t *vam = &vat_main;
19545 int count = ntohl (mp->count);
19546 vat_json_node_t *node = NULL;
19547 struct in_addr ip4;
19548 struct in6_addr ip6;
19549 vl_api_fib_path_t *fp;
19552 if (VAT_JSON_ARRAY != vam->json_tree.type)
19554 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19555 vat_json_init_array (&vam->json_tree);
19557 node = vat_json_array_add (&vam->json_tree);
19559 vat_json_init_object (node);
19560 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19561 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19562 vat_json_object_add_ip4 (node, "prefix", ip4);
19563 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19564 vat_json_object_add_uint (node, "path_count", count);
19566 for (i = 0; i < count; i++)
19568 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19569 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19570 vat_json_object_add_uint (node, "is_local", fp->is_local);
19571 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19572 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19573 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19574 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19575 if (fp->afi == IP46_TYPE_IP4)
19577 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19578 vat_json_object_add_ip4 (node, "next_hop", ip4);
19580 else if (fp->afi == IP46_TYPE_IP6)
19582 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19583 vat_json_object_add_ip6 (node, "next_hop", ip6);
19589 api_ip_fib_dump (vat_main_t * vam)
19591 vl_api_ip_fib_dump_t *mp;
19592 vl_api_control_ping_t *mp_ping;
19595 M (IP_FIB_DUMP, mp);
19598 /* Use a control ping for synchronization */
19599 MPING (CONTROL_PING, mp_ping);
19607 api_ip_mfib_dump (vat_main_t * vam)
19609 vl_api_ip_mfib_dump_t *mp;
19610 vl_api_control_ping_t *mp_ping;
19613 M (IP_MFIB_DUMP, mp);
19616 /* Use a control ping for synchronization */
19617 MPING (CONTROL_PING, mp_ping);
19624 static void vl_api_ip_neighbor_details_t_handler
19625 (vl_api_ip_neighbor_details_t * mp)
19627 vat_main_t *vam = &vat_main;
19629 print (vam->ofp, "%c %U %U",
19630 (mp->is_static) ? 'S' : 'D',
19631 format_ethernet_address, &mp->mac_address,
19632 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19636 static void vl_api_ip_neighbor_details_t_handler_json
19637 (vl_api_ip_neighbor_details_t * mp)
19640 vat_main_t *vam = &vat_main;
19641 vat_json_node_t *node;
19642 struct in_addr ip4;
19643 struct in6_addr ip6;
19645 if (VAT_JSON_ARRAY != vam->json_tree.type)
19647 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19648 vat_json_init_array (&vam->json_tree);
19650 node = vat_json_array_add (&vam->json_tree);
19652 vat_json_init_object (node);
19653 vat_json_object_add_string_copy (node, "flag",
19654 (mp->is_static) ? (u8 *) "static" : (u8 *)
19657 vat_json_object_add_string_copy (node, "link_layer",
19658 format (0, "%U", format_ethernet_address,
19659 &mp->mac_address));
19663 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19664 vat_json_object_add_ip6 (node, "ip_address", ip6);
19668 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19669 vat_json_object_add_ip4 (node, "ip_address", ip4);
19674 api_ip_neighbor_dump (vat_main_t * vam)
19676 unformat_input_t *i = vam->input;
19677 vl_api_ip_neighbor_dump_t *mp;
19678 vl_api_control_ping_t *mp_ping;
19680 u32 sw_if_index = ~0;
19683 /* Parse args required to build the message */
19684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19686 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19688 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19690 else if (unformat (i, "ip6"))
19696 if (sw_if_index == ~0)
19698 errmsg ("missing interface name or sw_if_index");
19702 M (IP_NEIGHBOR_DUMP, mp);
19703 mp->is_ipv6 = (u8) is_ipv6;
19704 mp->sw_if_index = ntohl (sw_if_index);
19707 /* Use a control ping for synchronization */
19708 MPING (CONTROL_PING, mp_ping);
19715 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19716 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19719 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19721 vat_main_t *vam = &vat_main;
19722 int count = ntohl (mp->count);
19723 vl_api_fib_path_t *fp;
19727 "table-id %d, prefix %U/%d",
19728 ntohl (mp->table_id), format_ip6_address, mp->address,
19729 mp->address_length);
19731 for (i = 0; i < count; i++)
19733 if (fp->afi == IP46_TYPE_IP6)
19735 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19736 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19737 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19738 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19739 format_ip6_address, fp->next_hop);
19740 else if (fp->afi == IP46_TYPE_IP4)
19742 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19743 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19744 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19745 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19746 format_ip4_address, fp->next_hop);
19751 static void vl_api_ip6_fib_details_t_handler_json
19752 (vl_api_ip6_fib_details_t * mp)
19754 vat_main_t *vam = &vat_main;
19755 int count = ntohl (mp->count);
19756 vat_json_node_t *node = NULL;
19757 struct in_addr ip4;
19758 struct in6_addr ip6;
19759 vl_api_fib_path_t *fp;
19762 if (VAT_JSON_ARRAY != vam->json_tree.type)
19764 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19765 vat_json_init_array (&vam->json_tree);
19767 node = vat_json_array_add (&vam->json_tree);
19769 vat_json_init_object (node);
19770 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19771 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19772 vat_json_object_add_ip6 (node, "prefix", ip6);
19773 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19774 vat_json_object_add_uint (node, "path_count", count);
19776 for (i = 0; i < count; i++)
19778 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19779 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19780 vat_json_object_add_uint (node, "is_local", fp->is_local);
19781 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19782 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19783 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19784 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19785 if (fp->afi == IP46_TYPE_IP4)
19787 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19788 vat_json_object_add_ip4 (node, "next_hop", ip4);
19790 else if (fp->afi == IP46_TYPE_IP6)
19792 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19793 vat_json_object_add_ip6 (node, "next_hop", ip6);
19799 api_ip6_fib_dump (vat_main_t * vam)
19801 vl_api_ip6_fib_dump_t *mp;
19802 vl_api_control_ping_t *mp_ping;
19805 M (IP6_FIB_DUMP, mp);
19808 /* Use a control ping for synchronization */
19809 MPING (CONTROL_PING, mp_ping);
19817 api_ip6_mfib_dump (vat_main_t * vam)
19819 vl_api_ip6_mfib_dump_t *mp;
19820 vl_api_control_ping_t *mp_ping;
19823 M (IP6_MFIB_DUMP, mp);
19826 /* Use a control ping for synchronization */
19827 MPING (CONTROL_PING, mp_ping);
19835 api_classify_table_ids (vat_main_t * vam)
19837 vl_api_classify_table_ids_t *mp;
19840 /* Construct the API message */
19841 M (CLASSIFY_TABLE_IDS, mp);
19850 api_classify_table_by_interface (vat_main_t * vam)
19852 unformat_input_t *input = vam->input;
19853 vl_api_classify_table_by_interface_t *mp;
19855 u32 sw_if_index = ~0;
19857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19859 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19861 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19866 if (sw_if_index == ~0)
19868 errmsg ("missing interface name or sw_if_index");
19872 /* Construct the API message */
19873 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19875 mp->sw_if_index = ntohl (sw_if_index);
19883 api_classify_table_info (vat_main_t * vam)
19885 unformat_input_t *input = vam->input;
19886 vl_api_classify_table_info_t *mp;
19890 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19892 if (unformat (input, "table_id %d", &table_id))
19897 if (table_id == ~0)
19899 errmsg ("missing table id");
19903 /* Construct the API message */
19904 M (CLASSIFY_TABLE_INFO, mp);
19906 mp->table_id = ntohl (table_id);
19914 api_classify_session_dump (vat_main_t * vam)
19916 unformat_input_t *input = vam->input;
19917 vl_api_classify_session_dump_t *mp;
19918 vl_api_control_ping_t *mp_ping;
19922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19924 if (unformat (input, "table_id %d", &table_id))
19929 if (table_id == ~0)
19931 errmsg ("missing table id");
19935 /* Construct the API message */
19936 M (CLASSIFY_SESSION_DUMP, mp);
19938 mp->table_id = ntohl (table_id);
19941 /* Use a control ping for synchronization */
19942 MPING (CONTROL_PING, mp_ping);
19950 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19952 vat_main_t *vam = &vat_main;
19954 print (vam->ofp, "collector_address %U, collector_port %d, "
19955 "src_address %U, vrf_id %d, path_mtu %u, "
19956 "template_interval %u, udp_checksum %d",
19957 format_ip4_address, mp->collector_address,
19958 ntohs (mp->collector_port),
19959 format_ip4_address, mp->src_address,
19960 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19961 ntohl (mp->template_interval), mp->udp_checksum);
19964 vam->result_ready = 1;
19968 vl_api_ipfix_exporter_details_t_handler_json
19969 (vl_api_ipfix_exporter_details_t * mp)
19971 vat_main_t *vam = &vat_main;
19972 vat_json_node_t node;
19973 struct in_addr collector_address;
19974 struct in_addr src_address;
19976 vat_json_init_object (&node);
19977 clib_memcpy (&collector_address, &mp->collector_address,
19978 sizeof (collector_address));
19979 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19980 vat_json_object_add_uint (&node, "collector_port",
19981 ntohs (mp->collector_port));
19982 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19983 vat_json_object_add_ip4 (&node, "src_address", src_address);
19984 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19985 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19986 vat_json_object_add_uint (&node, "template_interval",
19987 ntohl (mp->template_interval));
19988 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19990 vat_json_print (vam->ofp, &node);
19991 vat_json_free (&node);
19993 vam->result_ready = 1;
19997 api_ipfix_exporter_dump (vat_main_t * vam)
19999 vl_api_ipfix_exporter_dump_t *mp;
20002 /* Construct the API message */
20003 M (IPFIX_EXPORTER_DUMP, mp);
20012 api_ipfix_classify_stream_dump (vat_main_t * vam)
20014 vl_api_ipfix_classify_stream_dump_t *mp;
20017 /* Construct the API message */
20018 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20029 vl_api_ipfix_classify_stream_details_t_handler
20030 (vl_api_ipfix_classify_stream_details_t * mp)
20032 vat_main_t *vam = &vat_main;
20033 print (vam->ofp, "domain_id %d, src_port %d",
20034 ntohl (mp->domain_id), ntohs (mp->src_port));
20036 vam->result_ready = 1;
20040 vl_api_ipfix_classify_stream_details_t_handler_json
20041 (vl_api_ipfix_classify_stream_details_t * mp)
20043 vat_main_t *vam = &vat_main;
20044 vat_json_node_t node;
20046 vat_json_init_object (&node);
20047 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20048 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20050 vat_json_print (vam->ofp, &node);
20051 vat_json_free (&node);
20053 vam->result_ready = 1;
20057 api_ipfix_classify_table_dump (vat_main_t * vam)
20059 vl_api_ipfix_classify_table_dump_t *mp;
20060 vl_api_control_ping_t *mp_ping;
20063 if (!vam->json_output)
20065 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20066 "transport_protocol");
20069 /* Construct the API message */
20070 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20075 /* Use a control ping for synchronization */
20076 MPING (CONTROL_PING, mp_ping);
20084 vl_api_ipfix_classify_table_details_t_handler
20085 (vl_api_ipfix_classify_table_details_t * mp)
20087 vat_main_t *vam = &vat_main;
20088 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20089 mp->transport_protocol);
20093 vl_api_ipfix_classify_table_details_t_handler_json
20094 (vl_api_ipfix_classify_table_details_t * mp)
20096 vat_json_node_t *node = NULL;
20097 vat_main_t *vam = &vat_main;
20099 if (VAT_JSON_ARRAY != vam->json_tree.type)
20101 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20102 vat_json_init_array (&vam->json_tree);
20105 node = vat_json_array_add (&vam->json_tree);
20106 vat_json_init_object (node);
20108 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20109 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20110 vat_json_object_add_uint (node, "transport_protocol",
20111 mp->transport_protocol);
20115 api_sw_interface_span_enable_disable (vat_main_t * vam)
20117 unformat_input_t *i = vam->input;
20118 vl_api_sw_interface_span_enable_disable_t *mp;
20119 u32 src_sw_if_index = ~0;
20120 u32 dst_sw_if_index = ~0;
20125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20128 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20130 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20134 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20136 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20138 else if (unformat (i, "disable"))
20140 else if (unformat (i, "rx"))
20142 else if (unformat (i, "tx"))
20144 else if (unformat (i, "both"))
20146 else if (unformat (i, "l2"))
20152 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20154 mp->sw_if_index_from = htonl (src_sw_if_index);
20155 mp->sw_if_index_to = htonl (dst_sw_if_index);
20165 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20168 vat_main_t *vam = &vat_main;
20169 u8 *sw_if_from_name = 0;
20170 u8 *sw_if_to_name = 0;
20171 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20172 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20173 char *states[] = { "none", "rx", "tx", "both" };
20177 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20179 if ((u32) p->value[0] == sw_if_index_from)
20181 sw_if_from_name = (u8 *)(p->key);
20185 if ((u32) p->value[0] == sw_if_index_to)
20187 sw_if_to_name = (u8 *)(p->key);
20188 if (sw_if_from_name)
20193 print (vam->ofp, "%20s => %20s (%s)",
20194 sw_if_from_name, sw_if_to_name, states[mp->state]);
20198 vl_api_sw_interface_span_details_t_handler_json
20199 (vl_api_sw_interface_span_details_t * mp)
20201 vat_main_t *vam = &vat_main;
20202 vat_json_node_t *node = NULL;
20203 u8 *sw_if_from_name = 0;
20204 u8 *sw_if_to_name = 0;
20205 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20206 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20210 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20212 if ((u32) p->value[0] == sw_if_index_from)
20214 sw_if_from_name = (u8 *)(p->key);
20218 if ((u32) p->value[0] == sw_if_index_to)
20220 sw_if_to_name = (u8 *)(p->key);
20221 if (sw_if_from_name)
20227 if (VAT_JSON_ARRAY != vam->json_tree.type)
20229 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20230 vat_json_init_array (&vam->json_tree);
20232 node = vat_json_array_add (&vam->json_tree);
20234 vat_json_init_object (node);
20235 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20236 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20237 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20238 if (0 != sw_if_to_name)
20240 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20242 vat_json_object_add_uint (node, "state", mp->state);
20246 api_sw_interface_span_dump (vat_main_t * vam)
20248 unformat_input_t *input = vam->input;
20249 vl_api_sw_interface_span_dump_t *mp;
20250 vl_api_control_ping_t *mp_ping;
20254 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20256 if (unformat (input, "l2"))
20262 M (SW_INTERFACE_SPAN_DUMP, mp);
20266 /* Use a control ping for synchronization */
20267 MPING (CONTROL_PING, mp_ping);
20275 api_pg_create_interface (vat_main_t * vam)
20277 unformat_input_t *input = vam->input;
20278 vl_api_pg_create_interface_t *mp;
20282 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20284 if (unformat (input, "if_id %d", &if_id))
20291 errmsg ("missing pg interface index");
20295 /* Construct the API message */
20296 M (PG_CREATE_INTERFACE, mp);
20298 mp->interface_id = ntohl (if_id);
20306 api_pg_capture (vat_main_t * vam)
20308 unformat_input_t *input = vam->input;
20309 vl_api_pg_capture_t *mp;
20314 u8 pcap_file_set = 0;
20317 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20319 if (unformat (input, "if_id %d", &if_id))
20321 else if (unformat (input, "pcap %s", &pcap_file))
20323 else if (unformat (input, "count %d", &count))
20325 else if (unformat (input, "disable"))
20332 errmsg ("missing pg interface index");
20335 if (pcap_file_set > 0)
20337 if (vec_len (pcap_file) > 255)
20339 errmsg ("pcap file name is too long");
20344 u32 name_len = vec_len (pcap_file);
20345 /* Construct the API message */
20346 M (PG_CAPTURE, mp);
20348 mp->interface_id = ntohl (if_id);
20349 mp->is_enabled = enable;
20350 mp->count = ntohl (count);
20351 mp->pcap_name_length = ntohl (name_len);
20352 if (pcap_file_set != 0)
20354 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20356 vec_free (pcap_file);
20364 api_pg_enable_disable (vat_main_t * vam)
20366 unformat_input_t *input = vam->input;
20367 vl_api_pg_enable_disable_t *mp;
20370 u8 stream_name_set = 0;
20371 u8 *stream_name = 0;
20373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20375 if (unformat (input, "stream %s", &stream_name))
20376 stream_name_set = 1;
20377 else if (unformat (input, "disable"))
20383 if (stream_name_set > 0)
20385 if (vec_len (stream_name) > 255)
20387 errmsg ("stream name too long");
20392 u32 name_len = vec_len (stream_name);
20393 /* Construct the API message */
20394 M (PG_ENABLE_DISABLE, mp);
20396 mp->is_enabled = enable;
20397 if (stream_name_set != 0)
20399 mp->stream_name_length = ntohl (name_len);
20400 clib_memcpy (mp->stream_name, stream_name, name_len);
20402 vec_free (stream_name);
20410 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20412 unformat_input_t *input = vam->input;
20413 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20415 u16 *low_ports = 0;
20416 u16 *high_ports = 0;
20419 ip4_address_t ip4_addr;
20420 ip6_address_t ip6_addr;
20429 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20431 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20437 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20442 else if (unformat (input, "vrf %d", &vrf_id))
20444 else if (unformat (input, "del"))
20446 else if (unformat (input, "port %d", &tmp))
20448 if (tmp == 0 || tmp > 65535)
20450 errmsg ("port %d out of range", tmp);
20454 this_hi = this_low + 1;
20455 vec_add1 (low_ports, this_low);
20456 vec_add1 (high_ports, this_hi);
20458 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20460 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20462 errmsg ("incorrect range parameters");
20466 /* Note: in debug CLI +1 is added to high before
20467 passing to real fn that does "the work"
20468 (ip_source_and_port_range_check_add_del).
20469 This fn is a wrapper around the binary API fn a
20470 control plane will call, which expects this increment
20471 to have occurred. Hence letting the binary API control
20472 plane fn do the increment for consistency between VAT
20473 and other control planes.
20476 vec_add1 (low_ports, this_low);
20477 vec_add1 (high_ports, this_hi);
20483 if (prefix_set == 0)
20485 errmsg ("<address>/<mask> not specified");
20491 errmsg ("VRF ID required, not specified");
20498 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20502 if (vec_len (low_ports) == 0)
20504 errmsg ("At least one port or port range required");
20508 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20510 mp->is_add = is_add;
20515 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20520 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20523 mp->mask_length = length;
20524 mp->number_of_ranges = vec_len (low_ports);
20526 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20527 vec_free (low_ports);
20529 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20530 vec_free (high_ports);
20532 mp->vrf_id = ntohl (vrf_id);
20540 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20542 unformat_input_t *input = vam->input;
20543 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20544 u32 sw_if_index = ~0;
20546 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20547 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20551 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20553 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20555 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20557 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20559 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20561 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20563 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20565 else if (unformat (input, "del"))
20571 if (sw_if_index == ~0)
20573 errmsg ("Interface required but not specified");
20579 errmsg ("VRF ID required but not specified");
20583 if (tcp_out_vrf_id == 0
20584 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20587 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20591 /* Construct the API message */
20592 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20594 mp->sw_if_index = ntohl (sw_if_index);
20595 mp->is_add = is_add;
20596 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20597 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20598 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20599 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20604 /* Wait for a reply... */
20610 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20612 unformat_input_t *i = vam->input;
20613 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20614 u32 local_sa_id = 0;
20615 u32 remote_sa_id = 0;
20616 ip4_address_t src_address;
20617 ip4_address_t dst_address;
20621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20623 if (unformat (i, "local_sa %d", &local_sa_id))
20625 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20627 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20629 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20631 else if (unformat (i, "del"))
20635 clib_warning ("parse error '%U'", format_unformat_error, i);
20640 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20642 mp->local_sa_id = ntohl (local_sa_id);
20643 mp->remote_sa_id = ntohl (remote_sa_id);
20644 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20645 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20646 mp->is_add = is_add;
20654 api_punt (vat_main_t * vam)
20656 unformat_input_t *i = vam->input;
20664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20666 if (unformat (i, "ip %d", &ipv))
20668 else if (unformat (i, "protocol %d", &protocol))
20670 else if (unformat (i, "port %d", &port))
20672 else if (unformat (i, "del"))
20676 clib_warning ("parse error '%U'", format_unformat_error, i);
20683 mp->is_add = (u8) is_add;
20684 mp->ipv = (u8) ipv;
20685 mp->l4_protocol = (u8) protocol;
20686 mp->l4_port = htons ((u16) port);
20693 static void vl_api_ipsec_gre_tunnel_details_t_handler
20694 (vl_api_ipsec_gre_tunnel_details_t * mp)
20696 vat_main_t *vam = &vat_main;
20698 print (vam->ofp, "%11d%15U%15U%14d%14d",
20699 ntohl (mp->sw_if_index),
20700 format_ip4_address, &mp->src_address,
20701 format_ip4_address, &mp->dst_address,
20702 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20705 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20706 (vl_api_ipsec_gre_tunnel_details_t * mp)
20708 vat_main_t *vam = &vat_main;
20709 vat_json_node_t *node = NULL;
20710 struct in_addr ip4;
20712 if (VAT_JSON_ARRAY != vam->json_tree.type)
20714 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20715 vat_json_init_array (&vam->json_tree);
20717 node = vat_json_array_add (&vam->json_tree);
20719 vat_json_init_object (node);
20720 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20721 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20722 vat_json_object_add_ip4 (node, "src_address", ip4);
20723 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20724 vat_json_object_add_ip4 (node, "dst_address", ip4);
20725 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20726 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20730 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20732 unformat_input_t *i = vam->input;
20733 vl_api_ipsec_gre_tunnel_dump_t *mp;
20734 vl_api_control_ping_t *mp_ping;
20736 u8 sw_if_index_set = 0;
20739 /* Parse args required to build the message */
20740 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20742 if (unformat (i, "sw_if_index %d", &sw_if_index))
20743 sw_if_index_set = 1;
20748 if (sw_if_index_set == 0)
20753 if (!vam->json_output)
20755 print (vam->ofp, "%11s%15s%15s%14s%14s",
20756 "sw_if_index", "src_address", "dst_address",
20757 "local_sa_id", "remote_sa_id");
20760 /* Get list of gre-tunnel interfaces */
20761 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20763 mp->sw_if_index = htonl (sw_if_index);
20767 /* Use a control ping for synchronization */
20768 MPING (CONTROL_PING, mp_ping);
20776 api_delete_subif (vat_main_t * vam)
20778 unformat_input_t *i = vam->input;
20779 vl_api_delete_subif_t *mp;
20780 u32 sw_if_index = ~0;
20783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20785 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20787 if (unformat (i, "sw_if_index %d", &sw_if_index))
20793 if (sw_if_index == ~0)
20795 errmsg ("missing sw_if_index");
20799 /* Construct the API message */
20800 M (DELETE_SUBIF, mp);
20801 mp->sw_if_index = ntohl (sw_if_index);
20808 #define foreach_pbb_vtr_op \
20809 _("disable", L2_VTR_DISABLED) \
20810 _("pop", L2_VTR_POP_2) \
20811 _("push", L2_VTR_PUSH_2)
20814 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20816 unformat_input_t *i = vam->input;
20817 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20818 u32 sw_if_index = ~0, vtr_op = ~0;
20819 u16 outer_tag = ~0;
20820 u8 dmac[6], smac[6];
20821 u8 dmac_set = 0, smac_set = 0;
20827 /* Shut up coverity */
20828 memset (dmac, 0, sizeof (dmac));
20829 memset (smac, 0, sizeof (smac));
20831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20833 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20835 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20837 else if (unformat (i, "vtr_op %d", &vtr_op))
20839 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20842 else if (unformat (i, "translate_pbb_stag"))
20844 if (unformat (i, "%d", &tmp))
20846 vtr_op = L2_VTR_TRANSLATE_2_1;
20852 ("translate_pbb_stag operation requires outer tag definition");
20856 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20858 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20860 else if (unformat (i, "sid %d", &sid))
20862 else if (unformat (i, "vlanid %d", &tmp))
20866 clib_warning ("parse error '%U'", format_unformat_error, i);
20871 if ((sw_if_index == ~0) || (vtr_op == ~0))
20873 errmsg ("missing sw_if_index or vtr operation");
20876 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20877 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20880 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20884 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20885 mp->sw_if_index = ntohl (sw_if_index);
20886 mp->vtr_op = ntohl (vtr_op);
20887 mp->outer_tag = ntohs (outer_tag);
20888 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20889 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20890 mp->b_vlanid = ntohs (vlanid);
20891 mp->i_sid = ntohl (sid);
20899 api_flow_classify_set_interface (vat_main_t * vam)
20901 unformat_input_t *i = vam->input;
20902 vl_api_flow_classify_set_interface_t *mp;
20904 int sw_if_index_set;
20905 u32 ip4_table_index = ~0;
20906 u32 ip6_table_index = ~0;
20910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20913 sw_if_index_set = 1;
20914 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20915 sw_if_index_set = 1;
20916 else if (unformat (i, "del"))
20918 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20920 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20924 clib_warning ("parse error '%U'", format_unformat_error, i);
20929 if (sw_if_index_set == 0)
20931 errmsg ("missing interface name or sw_if_index");
20935 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20937 mp->sw_if_index = ntohl (sw_if_index);
20938 mp->ip4_table_index = ntohl (ip4_table_index);
20939 mp->ip6_table_index = ntohl (ip6_table_index);
20940 mp->is_add = is_add;
20948 api_flow_classify_dump (vat_main_t * vam)
20950 unformat_input_t *i = vam->input;
20951 vl_api_flow_classify_dump_t *mp;
20952 vl_api_control_ping_t *mp_ping;
20953 u8 type = FLOW_CLASSIFY_N_TABLES;
20956 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20960 errmsg ("classify table type must be specified");
20964 if (!vam->json_output)
20966 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20969 M (FLOW_CLASSIFY_DUMP, mp);
20974 /* Use a control ping for synchronization */
20975 MPING (CONTROL_PING, mp_ping);
20978 /* Wait for a reply... */
20984 api_feature_enable_disable (vat_main_t * vam)
20986 unformat_input_t *i = vam->input;
20987 vl_api_feature_enable_disable_t *mp;
20989 u8 *feature_name = 0;
20990 u32 sw_if_index = ~0;
20994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20996 if (unformat (i, "arc_name %s", &arc_name))
20998 else if (unformat (i, "feature_name %s", &feature_name))
21001 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21003 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21005 else if (unformat (i, "disable"))
21013 errmsg ("missing arc name");
21016 if (vec_len (arc_name) > 63)
21018 errmsg ("arc name too long");
21021 if (feature_name == 0)
21023 errmsg ("missing feature name");
21026 if (vec_len (feature_name) > 63)
21028 errmsg ("feature name too long");
21031 if (sw_if_index == ~0)
21033 errmsg ("missing interface name or sw_if_index");
21037 /* Construct the API message */
21038 M (FEATURE_ENABLE_DISABLE, mp);
21039 mp->sw_if_index = ntohl (sw_if_index);
21040 mp->enable = enable;
21041 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21042 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21043 vec_free (arc_name);
21044 vec_free (feature_name);
21052 api_sw_interface_tag_add_del (vat_main_t * vam)
21054 unformat_input_t *i = vam->input;
21055 vl_api_sw_interface_tag_add_del_t *mp;
21056 u32 sw_if_index = ~0;
21061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21063 if (unformat (i, "tag %s", &tag))
21065 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21067 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21069 else if (unformat (i, "del"))
21075 if (sw_if_index == ~0)
21077 errmsg ("missing interface name or sw_if_index");
21081 if (enable && (tag == 0))
21083 errmsg ("no tag specified");
21087 /* Construct the API message */
21088 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21089 mp->sw_if_index = ntohl (sw_if_index);
21090 mp->is_add = enable;
21092 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21100 static void vl_api_l2_xconnect_details_t_handler
21101 (vl_api_l2_xconnect_details_t * mp)
21103 vat_main_t *vam = &vat_main;
21105 print (vam->ofp, "%15d%15d",
21106 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21109 static void vl_api_l2_xconnect_details_t_handler_json
21110 (vl_api_l2_xconnect_details_t * mp)
21112 vat_main_t *vam = &vat_main;
21113 vat_json_node_t *node = NULL;
21115 if (VAT_JSON_ARRAY != vam->json_tree.type)
21117 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21118 vat_json_init_array (&vam->json_tree);
21120 node = vat_json_array_add (&vam->json_tree);
21122 vat_json_init_object (node);
21123 vat_json_object_add_uint (node, "rx_sw_if_index",
21124 ntohl (mp->rx_sw_if_index));
21125 vat_json_object_add_uint (node, "tx_sw_if_index",
21126 ntohl (mp->tx_sw_if_index));
21130 api_l2_xconnect_dump (vat_main_t * vam)
21132 vl_api_l2_xconnect_dump_t *mp;
21133 vl_api_control_ping_t *mp_ping;
21136 if (!vam->json_output)
21138 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21141 M (L2_XCONNECT_DUMP, mp);
21145 /* Use a control ping for synchronization */
21146 MPING (CONTROL_PING, mp_ping);
21154 api_sw_interface_set_mtu (vat_main_t * vam)
21156 unformat_input_t *i = vam->input;
21157 vl_api_sw_interface_set_mtu_t *mp;
21158 u32 sw_if_index = ~0;
21162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21164 if (unformat (i, "mtu %d", &mtu))
21166 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21168 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21174 if (sw_if_index == ~0)
21176 errmsg ("missing interface name or sw_if_index");
21182 errmsg ("no mtu specified");
21186 /* Construct the API message */
21187 M (SW_INTERFACE_SET_MTU, mp);
21188 mp->sw_if_index = ntohl (sw_if_index);
21189 mp->mtu = ntohs ((u16) mtu);
21197 api_p2p_ethernet_add (vat_main_t * vam)
21199 unformat_input_t *i = vam->input;
21200 vl_api_p2p_ethernet_add_t *mp;
21201 u32 parent_if_index = ~0;
21207 memset (remote_mac, 0, sizeof (remote_mac));
21208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21210 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21212 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21216 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21218 else if (unformat (i, "sub_id %d", &sub_id))
21222 clib_warning ("parse error '%U'", format_unformat_error, i);
21227 if (parent_if_index == ~0)
21229 errmsg ("missing interface name or sw_if_index");
21234 errmsg ("missing remote mac address");
21239 errmsg ("missing sub-interface id");
21243 M (P2P_ETHERNET_ADD, mp);
21244 mp->parent_if_index = ntohl (parent_if_index);
21245 mp->subif_id = ntohl (sub_id);
21246 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21254 api_p2p_ethernet_del (vat_main_t * vam)
21256 unformat_input_t *i = vam->input;
21257 vl_api_p2p_ethernet_del_t *mp;
21258 u32 parent_if_index = ~0;
21263 memset (remote_mac, 0, sizeof (remote_mac));
21264 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21266 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21268 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21272 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21276 clib_warning ("parse error '%U'", format_unformat_error, i);
21281 if (parent_if_index == ~0)
21283 errmsg ("missing interface name or sw_if_index");
21288 errmsg ("missing remote mac address");
21292 M (P2P_ETHERNET_DEL, mp);
21293 mp->parent_if_index = ntohl (parent_if_index);
21294 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21302 api_lldp_config (vat_main_t * vam)
21304 unformat_input_t *i = vam->input;
21305 vl_api_lldp_config_t *mp;
21307 int tx_interval = 0;
21308 u8 *sys_name = NULL;
21311 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21313 if (unformat (i, "system-name %s", &sys_name))
21315 else if (unformat (i, "tx-hold %d", &tx_hold))
21317 else if (unformat (i, "tx-interval %d", &tx_interval))
21321 clib_warning ("parse error '%U'", format_unformat_error, i);
21326 vec_add1 (sys_name, 0);
21328 M (LLDP_CONFIG, mp);
21329 mp->tx_hold = htonl (tx_hold);
21330 mp->tx_interval = htonl (tx_interval);
21331 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21332 vec_free (sys_name);
21340 api_sw_interface_set_lldp (vat_main_t * vam)
21342 unformat_input_t *i = vam->input;
21343 vl_api_sw_interface_set_lldp_t *mp;
21344 u32 sw_if_index = ~0;
21346 u8 *port_desc = NULL, *mgmt_oid = NULL;
21347 ip4_address_t ip4_addr;
21348 ip6_address_t ip6_addr;
21351 memset (&ip4_addr, 0, sizeof (ip4_addr));
21352 memset (&ip6_addr, 0, sizeof (ip6_addr));
21354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21356 if (unformat (i, "disable"))
21359 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21361 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21363 else if (unformat (i, "port-desc %s", &port_desc))
21365 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21367 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21369 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21375 if (sw_if_index == ~0)
21377 errmsg ("missing interface name or sw_if_index");
21381 /* Construct the API message */
21382 vec_add1 (port_desc, 0);
21383 vec_add1 (mgmt_oid, 0);
21384 M (SW_INTERFACE_SET_LLDP, mp);
21385 mp->sw_if_index = ntohl (sw_if_index);
21386 mp->enable = enable;
21387 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21388 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21389 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21390 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21391 vec_free (port_desc);
21392 vec_free (mgmt_oid);
21400 api_tcp_configure_src_addresses (vat_main_t * vam)
21402 vl_api_tcp_configure_src_addresses_t *mp;
21403 unformat_input_t *i = vam->input;
21404 ip4_address_t v4first, v4last;
21405 ip6_address_t v6first, v6last;
21410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21412 if (unformat (i, "%U - %U",
21413 unformat_ip4_address, &v4first,
21414 unformat_ip4_address, &v4last))
21418 errmsg ("one range per message (range already set)");
21423 else if (unformat (i, "%U - %U",
21424 unformat_ip6_address, &v6first,
21425 unformat_ip6_address, &v6last))
21429 errmsg ("one range per message (range already set)");
21434 else if (unformat (i, "vrf %d", &vrf_id))
21440 if (range_set == 0)
21442 errmsg ("address range not set");
21446 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21447 mp->vrf_id = ntohl (vrf_id);
21449 if (range_set == 2)
21452 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21453 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21458 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21459 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21467 api_app_namespace_add_del (vat_main_t * vam)
21469 vl_api_app_namespace_add_del_t *mp;
21470 unformat_input_t *i = vam->input;
21471 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21472 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21478 if (unformat (i, "id %_%v%_", &ns_id))
21480 else if (unformat (i, "secret %lu", &secret))
21482 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21483 sw_if_index_set = 1;
21484 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21486 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21491 if (!ns_id || !secret_set || !sw_if_index_set)
21493 errmsg ("namespace id, secret and sw_if_index must be set");
21496 if (vec_len (ns_id) > 64)
21498 errmsg ("namespace id too long");
21501 M (APP_NAMESPACE_ADD_DEL, mp);
21503 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21504 mp->namespace_id_len = vec_len (ns_id);
21505 mp->secret = clib_host_to_net_u64 (secret);
21506 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21507 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21508 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21516 api_memfd_segment_create (vat_main_t * vam)
21518 #if VPP_API_TEST_BUILTIN == 0
21519 unformat_input_t *i = vam->input;
21520 vl_api_memfd_segment_create_t *mp;
21521 u64 size = 64 << 20;
21524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21526 if (unformat (i, "size %U", unformat_memory_size, &size))
21532 M (MEMFD_SEGMENT_CREATE, mp);
21533 mp->requested_size = size;
21539 errmsg ("memfd_segment_create (builtin) not supported");
21545 api_dns_enable_disable (vat_main_t * vam)
21547 unformat_input_t *line_input = vam->input;
21548 vl_api_dns_enable_disable_t *mp;
21549 u8 enable_disable = 1;
21552 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21554 if (unformat (line_input, "disable"))
21555 enable_disable = 0;
21556 if (unformat (line_input, "enable"))
21557 enable_disable = 1;
21562 /* Construct the API message */
21563 M (DNS_ENABLE_DISABLE, mp);
21564 mp->enable = enable_disable;
21568 /* Wait for the reply */
21574 api_dns_resolve_name (vat_main_t * vam)
21576 unformat_input_t *line_input = vam->input;
21577 vl_api_dns_resolve_name_t *mp;
21581 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21583 if (unformat (line_input, "%s", &name))
21589 if (vec_len (name) > 127)
21591 errmsg ("name too long");
21595 /* Construct the API message */
21596 M (DNS_RESOLVE_NAME, mp);
21597 memcpy (mp->name, name, vec_len (name));
21602 /* Wait for the reply */
21608 api_dns_resolve_ip (vat_main_t * vam)
21610 unformat_input_t *line_input = vam->input;
21611 vl_api_dns_resolve_ip_t *mp;
21613 ip4_address_t addr4;
21614 ip6_address_t addr6;
21617 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21619 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21621 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21629 errmsg ("missing address");
21633 /* Construct the API message */
21634 M (DNS_RESOLVE_IP, mp);
21635 mp->is_ip6 = is_ip6;
21637 memcpy (mp->address, &addr6, sizeof (addr6));
21639 memcpy (mp->address, &addr4, sizeof (addr4));
21643 /* Wait for the reply */
21649 api_dns_name_server_add_del (vat_main_t * vam)
21651 unformat_input_t *i = vam->input;
21652 vl_api_dns_name_server_add_del_t *mp;
21654 ip6_address_t ip6_server;
21655 ip4_address_t ip4_server;
21660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21662 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21664 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21666 else if (unformat (i, "del"))
21670 clib_warning ("parse error '%U'", format_unformat_error, i);
21675 if (ip4_set && ip6_set)
21677 errmsg ("Only one server address allowed per message");
21680 if ((ip4_set + ip6_set) == 0)
21682 errmsg ("Server address required");
21686 /* Construct the API message */
21687 M (DNS_NAME_SERVER_ADD_DEL, mp);
21691 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21696 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21700 mp->is_add = is_add;
21705 /* Wait for a reply, return good/bad news */
21711 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21713 vat_main_t *vam = &vat_main;
21718 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21719 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21720 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21721 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21722 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21723 clib_net_to_host_u32 (mp->action_index), mp->tag);
21728 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21729 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21730 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21731 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21732 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21733 clib_net_to_host_u32 (mp->action_index), mp->tag);
21738 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21741 vat_main_t *vam = &vat_main;
21742 vat_json_node_t *node = NULL;
21743 struct in6_addr ip6;
21744 struct in_addr ip4;
21746 if (VAT_JSON_ARRAY != vam->json_tree.type)
21748 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21749 vat_json_init_array (&vam->json_tree);
21751 node = vat_json_array_add (&vam->json_tree);
21752 vat_json_init_object (node);
21754 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21755 vat_json_object_add_uint (node, "appns_index",
21756 clib_net_to_host_u32 (mp->appns_index));
21757 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21758 vat_json_object_add_uint (node, "scope", mp->scope);
21759 vat_json_object_add_uint (node, "action_index",
21760 clib_net_to_host_u32 (mp->action_index));
21761 vat_json_object_add_uint (node, "lcl_port",
21762 clib_net_to_host_u16 (mp->lcl_port));
21763 vat_json_object_add_uint (node, "rmt_port",
21764 clib_net_to_host_u16 (mp->rmt_port));
21765 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21766 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21767 vat_json_object_add_string_copy (node, "tag", mp->tag);
21770 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21771 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21772 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21773 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21777 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21778 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21779 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21780 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21785 api_session_rule_add_del (vat_main_t * vam)
21787 vl_api_session_rule_add_del_t *mp;
21788 unformat_input_t *i = vam->input;
21789 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21790 u32 appns_index = 0, scope = 0;
21791 ip4_address_t lcl_ip4, rmt_ip4;
21792 ip6_address_t lcl_ip6, rmt_ip6;
21793 u8 is_ip4 = 1, conn_set = 0;
21794 u8 is_add = 1, *tag = 0;
21797 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21799 if (unformat (i, "del"))
21801 else if (unformat (i, "add"))
21803 else if (unformat (i, "proto tcp"))
21805 else if (unformat (i, "proto udp"))
21807 else if (unformat (i, "appns %d", &appns_index))
21809 else if (unformat (i, "scope %d", &scope))
21811 else if (unformat (i, "tag %_%v%_", &tag))
21815 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21816 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21824 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21825 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21831 else if (unformat (i, "action %d", &action))
21836 if (proto == ~0 || !conn_set || action == ~0)
21838 errmsg ("transport proto, connection and action must be set");
21844 errmsg ("scope should be 0-3");
21848 M (SESSION_RULE_ADD_DEL, mp);
21850 mp->is_ip4 = is_ip4;
21851 mp->transport_proto = proto;
21852 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21853 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21854 mp->lcl_plen = lcl_plen;
21855 mp->rmt_plen = rmt_plen;
21856 mp->action_index = clib_host_to_net_u32 (action);
21857 mp->appns_index = clib_host_to_net_u32 (appns_index);
21859 mp->is_add = is_add;
21862 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21863 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21867 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21868 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21872 clib_memcpy (mp->tag, tag, vec_len (tag));
21882 api_session_rules_dump (vat_main_t * vam)
21884 vl_api_session_rules_dump_t *mp;
21885 vl_api_control_ping_t *mp_ping;
21888 if (!vam->json_output)
21890 print (vam->ofp, "%=20s", "Session Rules");
21893 M (SESSION_RULES_DUMP, mp);
21897 /* Use a control ping for synchronization */
21898 MPING (CONTROL_PING, mp_ping);
21901 /* Wait for a reply... */
21907 api_ip_container_proxy_add_del (vat_main_t * vam)
21909 vl_api_ip_container_proxy_add_del_t *mp;
21910 unformat_input_t *i = vam->input;
21911 u32 plen = ~0, sw_if_index = ~0;
21918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21920 if (unformat (i, "del"))
21922 else if (unformat (i, "add"))
21924 if (unformat (i, "%U", unformat_ip4_address, &ip4))
21929 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
21934 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21939 if (sw_if_index == ~0 || plen == ~0)
21941 errmsg ("address and sw_if_index must be set");
21945 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21947 mp->is_ip4 = is_ip4;
21948 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21950 mp->is_add = is_add;
21952 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
21954 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
21962 q_or_quit (vat_main_t * vam)
21964 #if VPP_API_TEST_BUILTIN == 0
21965 longjmp (vam->jump_buf, 1);
21967 return 0; /* not so much */
21971 q (vat_main_t * vam)
21973 return q_or_quit (vam);
21977 quit (vat_main_t * vam)
21979 return q_or_quit (vam);
21983 comment (vat_main_t * vam)
21989 cmd_cmp (void *a1, void *a2)
21994 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21998 help (vat_main_t * vam)
22003 unformat_input_t *i = vam->input;
22006 if (unformat (i, "%s", &name))
22010 vec_add1 (name, 0);
22012 hs = hash_get_mem (vam->help_by_name, name);
22014 print (vam->ofp, "usage: %s %s", name, hs[0]);
22016 print (vam->ofp, "No such msg / command '%s'", name);
22021 print (vam->ofp, "Help is available for the following:");
22024 hash_foreach_pair (p, vam->function_by_name,
22026 vec_add1 (cmds, (u8 *)(p->key));
22030 vec_sort_with_function (cmds, cmd_cmp);
22032 for (j = 0; j < vec_len (cmds); j++)
22033 print (vam->ofp, "%s", cmds[j]);
22040 set (vat_main_t * vam)
22042 u8 *name = 0, *value = 0;
22043 unformat_input_t *i = vam->input;
22045 if (unformat (i, "%s", &name))
22047 /* The input buffer is a vector, not a string. */
22048 value = vec_dup (i->buffer);
22049 vec_delete (value, i->index, 0);
22050 /* Almost certainly has a trailing newline */
22051 if (value[vec_len (value) - 1] == '\n')
22052 value[vec_len (value) - 1] = 0;
22053 /* Make sure it's a proper string, one way or the other */
22054 vec_add1 (value, 0);
22055 (void) clib_macro_set_value (&vam->macro_main,
22056 (char *) name, (char *) value);
22059 errmsg ("usage: set <name> <value>");
22067 unset (vat_main_t * vam)
22071 if (unformat (vam->input, "%s", &name))
22072 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22073 errmsg ("unset: %s wasn't set", name);
22086 macro_sort_cmp (void *a1, void *a2)
22088 macro_sort_t *s1 = a1;
22089 macro_sort_t *s2 = a2;
22091 return strcmp ((char *) (s1->name), (char *) (s2->name));
22095 dump_macro_table (vat_main_t * vam)
22097 macro_sort_t *sort_me = 0, *sm;
22102 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22104 vec_add2 (sort_me, sm, 1);
22105 sm->name = (u8 *)(p->key);
22106 sm->value = (u8 *) (p->value[0]);
22110 vec_sort_with_function (sort_me, macro_sort_cmp);
22112 if (vec_len (sort_me))
22113 print (vam->ofp, "%-15s%s", "Name", "Value");
22115 print (vam->ofp, "The macro table is empty...");
22117 for (i = 0; i < vec_len (sort_me); i++)
22118 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22123 dump_node_table (vat_main_t * vam)
22126 vlib_node_t *node, *next_node;
22128 if (vec_len (vam->graph_nodes) == 0)
22130 print (vam->ofp, "Node table empty, issue get_node_graph...");
22134 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22136 node = vam->graph_nodes[i];
22137 print (vam->ofp, "[%d] %s", i, node->name);
22138 for (j = 0; j < vec_len (node->next_nodes); j++)
22140 if (node->next_nodes[j] != ~0)
22142 next_node = vam->graph_nodes[node->next_nodes[j]];
22143 print (vam->ofp, " [%d] %s", j, next_node->name);
22151 value_sort_cmp (void *a1, void *a2)
22153 name_sort_t *n1 = a1;
22154 name_sort_t *n2 = a2;
22156 if (n1->value < n2->value)
22158 if (n1->value > n2->value)
22165 dump_msg_api_table (vat_main_t * vam)
22167 api_main_t *am = &api_main;
22168 name_sort_t *nses = 0, *ns;
22173 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22175 vec_add2 (nses, ns, 1);
22176 ns->name = (u8 *)(hp->key);
22177 ns->value = (u32) hp->value[0];
22181 vec_sort_with_function (nses, value_sort_cmp);
22183 for (i = 0; i < vec_len (nses); i++)
22184 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22190 get_msg_id (vat_main_t * vam)
22195 if (unformat (vam->input, "%s", &name_and_crc))
22197 message_index = vl_api_get_msg_index (name_and_crc);
22198 if (message_index == ~0)
22200 print (vam->ofp, " '%s' not found", name_and_crc);
22203 print (vam->ofp, " '%s' has message index %d",
22204 name_and_crc, message_index);
22207 errmsg ("name_and_crc required...");
22212 search_node_table (vat_main_t * vam)
22214 unformat_input_t *line_input = vam->input;
22217 vlib_node_t *node, *next_node;
22220 if (vam->graph_node_index_by_name == 0)
22222 print (vam->ofp, "Node table empty, issue get_node_graph...");
22226 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22228 if (unformat (line_input, "%s", &node_to_find))
22230 vec_add1 (node_to_find, 0);
22231 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22234 print (vam->ofp, "%s not found...", node_to_find);
22237 node = vam->graph_nodes[p[0]];
22238 print (vam->ofp, "[%d] %s", p[0], node->name);
22239 for (j = 0; j < vec_len (node->next_nodes); j++)
22241 if (node->next_nodes[j] != ~0)
22243 next_node = vam->graph_nodes[node->next_nodes[j]];
22244 print (vam->ofp, " [%d] %s", j, next_node->name);
22251 clib_warning ("parse error '%U'", format_unformat_error,
22257 vec_free (node_to_find);
22266 script (vat_main_t * vam)
22268 #if (VPP_API_TEST_BUILTIN==0)
22270 char *save_current_file;
22271 unformat_input_t save_input;
22272 jmp_buf save_jump_buf;
22273 u32 save_line_number;
22275 FILE *new_fp, *save_ifp;
22277 if (unformat (vam->input, "%s", &s))
22279 new_fp = fopen ((char *) s, "r");
22282 errmsg ("Couldn't open script file %s", s);
22289 errmsg ("Missing script name");
22293 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22294 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22295 save_ifp = vam->ifp;
22296 save_line_number = vam->input_line_number;
22297 save_current_file = (char *) vam->current_file;
22299 vam->input_line_number = 0;
22301 vam->current_file = s;
22304 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22305 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22306 vam->ifp = save_ifp;
22307 vam->input_line_number = save_line_number;
22308 vam->current_file = (u8 *) save_current_file;
22313 clib_warning ("use the exec command...");
22319 echo (vat_main_t * vam)
22321 print (vam->ofp, "%v", vam->input->buffer);
22325 /* List of API message constructors, CLI names map to api_xxx */
22326 #define foreach_vpe_api_msg \
22327 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22328 _(sw_interface_dump,"") \
22329 _(sw_interface_set_flags, \
22330 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22331 _(sw_interface_add_del_address, \
22332 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22333 _(sw_interface_set_rx_mode, \
22334 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22335 _(sw_interface_set_table, \
22336 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22337 _(sw_interface_set_mpls_enable, \
22338 "<intfc> | sw_if_index [disable | dis]") \
22339 _(sw_interface_set_vpath, \
22340 "<intfc> | sw_if_index <id> enable | disable") \
22341 _(sw_interface_set_vxlan_bypass, \
22342 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22343 _(sw_interface_set_geneve_bypass, \
22344 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22345 _(sw_interface_set_l2_xconnect, \
22346 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22347 "enable | disable") \
22348 _(sw_interface_set_l2_bridge, \
22349 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22350 "[shg <split-horizon-group>] [bvi]\n" \
22351 "enable | disable") \
22352 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22353 _(bridge_domain_add_del, \
22354 "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") \
22355 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22357 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22358 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22359 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22361 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22363 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22365 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22367 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22369 "<vpp-if-name> | sw_if_index <id>") \
22370 _(sw_interface_tap_dump, "") \
22371 _(ip_table_add_del, \
22372 "table-id <n> [ipv6]\n") \
22373 _(ip_add_del_route, \
22374 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22375 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22376 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22377 "[multipath] [count <n>]") \
22378 _(ip_mroute_add_del, \
22379 "<src> <grp>/<mask> [table-id <n>]\n" \
22380 "[<intfc> | sw_if_index <id>] [local] [del]") \
22381 _(mpls_table_add_del, \
22382 "table-id <n>\n") \
22383 _(mpls_route_add_del, \
22384 "<label> <eos> via <addr> [table-id <n>]\n" \
22385 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22386 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22387 "[multipath] [count <n>]") \
22388 _(mpls_ip_bind_unbind, \
22389 "<label> <addr/len>") \
22390 _(mpls_tunnel_add_del, \
22391 " via <addr> [table-id <n>]\n" \
22392 "sw_if_index <id>] [l2] [del]") \
22393 _(bier_table_add_del, \
22394 "<label> <sub-domain> <set> <bsl> [del]") \
22395 _(bier_route_add_del, \
22396 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22397 "[<intfc> | sw_if_index <id>]" \
22398 "[weight <n>] [del] [multipath]") \
22399 _(proxy_arp_add_del, \
22400 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22401 _(proxy_arp_intfc_enable_disable, \
22402 "<intfc> | sw_if_index <id> enable | disable") \
22403 _(sw_interface_set_unnumbered, \
22404 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22405 _(ip_neighbor_add_del, \
22406 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22407 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22408 _(reset_vrf, "vrf <id> [ipv6]") \
22409 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22410 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22411 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22412 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22413 "[outer_vlan_id_any][inner_vlan_id_any]") \
22414 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22415 _(reset_fib, "vrf <n> [ipv6]") \
22416 _(dhcp_proxy_config, \
22417 "svr <v46-address> src <v46-address>\n" \
22418 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22419 _(dhcp_proxy_set_vss, \
22420 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
22421 _(dhcp_proxy_dump, "ip6") \
22422 _(dhcp_client_config, \
22423 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22424 _(set_ip_flow_hash, \
22425 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22426 _(sw_interface_ip6_enable_disable, \
22427 "<intfc> | sw_if_index <id> enable | disable") \
22428 _(sw_interface_ip6_set_link_local_address, \
22429 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22430 _(ip6nd_proxy_add_del, \
22431 "<intfc> | sw_if_index <id> <ip6-address>") \
22432 _(ip6nd_proxy_dump, "") \
22433 _(sw_interface_ip6nd_ra_prefix, \
22434 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22435 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22436 "[nolink] [isno]") \
22437 _(sw_interface_ip6nd_ra_config, \
22438 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22439 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22440 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22441 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22442 _(l2_patch_add_del, \
22443 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22444 "enable | disable") \
22445 _(sr_localsid_add_del, \
22446 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22447 "fib-table <num> (end.psp) sw_if_index <num>") \
22448 _(classify_add_del_table, \
22449 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22450 " [del] [del-chain] mask <mask-value>\n" \
22451 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22452 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22453 _(classify_add_del_session, \
22454 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22455 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22456 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22457 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22458 _(classify_set_interface_ip_table, \
22459 "<intfc> | sw_if_index <nn> table <nn>") \
22460 _(classify_set_interface_l2_tables, \
22461 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22462 " [other-table <nn>]") \
22463 _(get_node_index, "node <node-name") \
22464 _(add_node_next, "node <node-name> next <next-node-name>") \
22465 _(l2tpv3_create_tunnel, \
22466 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22467 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22468 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22469 _(l2tpv3_set_tunnel_cookies, \
22470 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22471 "[new_remote_cookie <nn>]\n") \
22472 _(l2tpv3_interface_enable_disable, \
22473 "<intfc> | sw_if_index <nn> enable | disable") \
22474 _(l2tpv3_set_lookup_key, \
22475 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22476 _(sw_if_l2tpv3_tunnel_dump, "") \
22477 _(vxlan_add_del_tunnel, \
22478 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22479 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22480 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22481 _(geneve_add_del_tunnel, \
22482 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22483 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22484 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22485 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22486 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22487 _(gre_add_del_tunnel, \
22488 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22489 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22490 _(l2_fib_clear_table, "") \
22491 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22492 _(l2_interface_vlan_tag_rewrite, \
22493 "<intfc> | sw_if_index <nn> \n" \
22494 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22495 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22496 _(create_vhost_user_if, \
22497 "socket <filename> [server] [renumber <dev_instance>] " \
22498 "[mac <mac_address>]") \
22499 _(modify_vhost_user_if, \
22500 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22501 "[server] [renumber <dev_instance>]") \
22502 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22503 _(sw_interface_vhost_user_dump, "") \
22504 _(show_version, "") \
22505 _(vxlan_gpe_add_del_tunnel, \
22506 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22507 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22508 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22509 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22510 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22511 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22512 _(interface_name_renumber, \
22513 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22514 _(input_acl_set_interface, \
22515 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22516 " [l2-table <nn>] [del]") \
22517 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22518 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22519 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22520 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22521 _(ip_dump, "ipv4 | ipv6") \
22522 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22523 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22525 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22526 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22527 " integ_alg <alg> integ_key <hex>") \
22528 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22529 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22530 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22531 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22532 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22533 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22534 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22535 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22536 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22537 _(ipsec_sa_dump, "[sa_id <n>]") \
22538 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22539 " <alg> <hex>\n") \
22540 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22541 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22542 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22543 "(auth_data 0x<data> | auth_data <data>)") \
22544 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22545 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22546 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22547 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22548 "(local|remote)") \
22549 _(ikev2_set_local_key, "file <absolute_file_path>") \
22550 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22551 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22552 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22553 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22554 _(ikev2_initiate_sa_init, "<profile_name>") \
22555 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22556 _(ikev2_initiate_del_child_sa, "<ispi>") \
22557 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22558 _(delete_loopback,"sw_if_index <nn>") \
22559 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22560 _(map_add_domain, \
22561 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22562 "ip6-src <ip6addr> " \
22563 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22564 _(map_del_domain, "index <n>") \
22565 _(map_add_del_rule, \
22566 "index <n> psid <n> dst <ip6addr> [del]") \
22567 _(map_domain_dump, "") \
22568 _(map_rule_dump, "index <map-domain>") \
22569 _(want_interface_events, "enable|disable") \
22570 _(want_stats,"enable|disable") \
22571 _(get_first_msg_id, "client <name>") \
22572 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22573 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22574 "fib-id <nn> [ip4][ip6][default]") \
22575 _(get_node_graph, " ") \
22576 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22577 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22578 _(ioam_disable, "") \
22579 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22580 " sw_if_index <sw_if_index> p <priority> " \
22581 "w <weight>] [del]") \
22582 _(one_add_del_locator, "locator-set <locator_name> " \
22583 "iface <intf> | sw_if_index <sw_if_index> " \
22584 "p <priority> w <weight> [del]") \
22585 _(one_add_del_local_eid,"vni <vni> eid " \
22586 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22587 "locator-set <locator_name> [del]" \
22588 "[key-id sha1|sha256 secret-key <secret-key>]")\
22589 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22590 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22591 _(one_enable_disable, "enable|disable") \
22592 _(one_map_register_enable_disable, "enable|disable") \
22593 _(one_map_register_fallback_threshold, "<value>") \
22594 _(one_rloc_probe_enable_disable, "enable|disable") \
22595 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22597 "rloc <locator> p <prio> " \
22598 "w <weight> [rloc <loc> ... ] " \
22599 "action <action> [del-all]") \
22600 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22602 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22603 _(one_use_petr, "ip-address> | disable") \
22604 _(one_map_request_mode, "src-dst|dst-only") \
22605 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22606 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22607 _(one_locator_set_dump, "[local | remote]") \
22608 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22609 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22610 "[local] | [remote]") \
22611 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22612 _(one_ndp_bd_get, "") \
22613 _(one_ndp_entries_get, "bd <bridge-domain>") \
22614 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22615 _(one_l2_arp_bd_get, "") \
22616 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22617 _(one_stats_enable_disable, "enable|disalbe") \
22618 _(show_one_stats_enable_disable, "") \
22619 _(one_eid_table_vni_dump, "") \
22620 _(one_eid_table_map_dump, "l2|l3") \
22621 _(one_map_resolver_dump, "") \
22622 _(one_map_server_dump, "") \
22623 _(one_adjacencies_get, "vni <vni>") \
22624 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22625 _(show_one_rloc_probe_state, "") \
22626 _(show_one_map_register_state, "") \
22627 _(show_one_status, "") \
22628 _(one_stats_dump, "") \
22629 _(one_stats_flush, "") \
22630 _(one_get_map_request_itr_rlocs, "") \
22631 _(one_map_register_set_ttl, "<ttl>") \
22632 _(one_set_transport_protocol, "udp|api") \
22633 _(one_get_transport_protocol, "") \
22634 _(one_enable_disable_xtr_mode, "enable|disable") \
22635 _(one_show_xtr_mode, "") \
22636 _(one_enable_disable_pitr_mode, "enable|disable") \
22637 _(one_show_pitr_mode, "") \
22638 _(one_enable_disable_petr_mode, "enable|disable") \
22639 _(one_show_petr_mode, "") \
22640 _(show_one_nsh_mapping, "") \
22641 _(show_one_pitr, "") \
22642 _(show_one_use_petr, "") \
22643 _(show_one_map_request_mode, "") \
22644 _(show_one_map_register_ttl, "") \
22645 _(show_one_map_register_fallback_threshold, "") \
22646 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22647 " sw_if_index <sw_if_index> p <priority> " \
22648 "w <weight>] [del]") \
22649 _(lisp_add_del_locator, "locator-set <locator_name> " \
22650 "iface <intf> | sw_if_index <sw_if_index> " \
22651 "p <priority> w <weight> [del]") \
22652 _(lisp_add_del_local_eid,"vni <vni> eid " \
22653 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22654 "locator-set <locator_name> [del]" \
22655 "[key-id sha1|sha256 secret-key <secret-key>]") \
22656 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22657 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22658 _(lisp_enable_disable, "enable|disable") \
22659 _(lisp_map_register_enable_disable, "enable|disable") \
22660 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22661 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22663 "rloc <locator> p <prio> " \
22664 "w <weight> [rloc <loc> ... ] " \
22665 "action <action> [del-all]") \
22666 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22668 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22669 _(lisp_use_petr, "<ip-address> | disable") \
22670 _(lisp_map_request_mode, "src-dst|dst-only") \
22671 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22672 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22673 _(lisp_locator_set_dump, "[local | remote]") \
22674 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22675 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22676 "[local] | [remote]") \
22677 _(lisp_eid_table_vni_dump, "") \
22678 _(lisp_eid_table_map_dump, "l2|l3") \
22679 _(lisp_map_resolver_dump, "") \
22680 _(lisp_map_server_dump, "") \
22681 _(lisp_adjacencies_get, "vni <vni>") \
22682 _(gpe_fwd_entry_vnis_get, "") \
22683 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22684 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22685 "[table <table-id>]") \
22686 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22687 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22688 _(gpe_set_encap_mode, "lisp|vxlan") \
22689 _(gpe_get_encap_mode, "") \
22690 _(lisp_gpe_add_del_iface, "up|down") \
22691 _(lisp_gpe_enable_disable, "enable|disable") \
22692 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22693 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22694 _(show_lisp_rloc_probe_state, "") \
22695 _(show_lisp_map_register_state, "") \
22696 _(show_lisp_status, "") \
22697 _(lisp_get_map_request_itr_rlocs, "") \
22698 _(show_lisp_pitr, "") \
22699 _(show_lisp_use_petr, "") \
22700 _(show_lisp_map_request_mode, "") \
22701 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22702 _(af_packet_delete, "name <host interface name>") \
22703 _(policer_add_del, "name <policer name> <params> [del]") \
22704 _(policer_dump, "[name <policer name>]") \
22705 _(policer_classify_set_interface, \
22706 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22707 " [l2-table <nn>] [del]") \
22708 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22709 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22710 "[master|slave]") \
22711 _(netmap_delete, "name <interface name>") \
22712 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22713 _(mpls_fib_dump, "") \
22714 _(classify_table_ids, "") \
22715 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22716 _(classify_table_info, "table_id <nn>") \
22717 _(classify_session_dump, "table_id <nn>") \
22718 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22719 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22720 "[template_interval <nn>] [udp_checksum]") \
22721 _(ipfix_exporter_dump, "") \
22722 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22723 _(ipfix_classify_stream_dump, "") \
22724 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22725 _(ipfix_classify_table_dump, "") \
22726 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22727 _(sw_interface_span_dump, "[l2]") \
22728 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22729 _(pg_create_interface, "if_id <nn>") \
22730 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22731 _(pg_enable_disable, "[stream <id>] disable") \
22732 _(ip_source_and_port_range_check_add_del, \
22733 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22734 _(ip_source_and_port_range_check_interface_add_del, \
22735 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22736 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22737 _(ipsec_gre_add_del_tunnel, \
22738 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22739 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22740 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22741 _(l2_interface_pbb_tag_rewrite, \
22742 "<intfc> | sw_if_index <nn> \n" \
22743 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22744 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22745 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22746 _(flow_classify_set_interface, \
22747 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22748 _(flow_classify_dump, "type [ip4|ip6]") \
22749 _(ip_fib_dump, "") \
22750 _(ip_mfib_dump, "") \
22751 _(ip6_fib_dump, "") \
22752 _(ip6_mfib_dump, "") \
22753 _(feature_enable_disable, "arc_name <arc_name> " \
22754 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22755 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22757 _(l2_xconnect_dump, "") \
22758 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
22759 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22760 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22761 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22762 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22763 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22764 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22765 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22766 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22767 _(memfd_segment_create,"size <nnn>") \
22768 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22769 _(dns_enable_disable, "[enable][disable]") \
22770 _(dns_name_server_add_del, "<ip-address> [del]") \
22771 _(dns_resolve_name, "<hostname>") \
22772 _(dns_resolve_ip, "<ip4|ip6>") \
22773 _(dns_name_server_add_del, "<ip-address> [del]") \
22774 _(dns_resolve_name, "<hostname>") \
22775 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22776 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22777 _(session_rules_dump, "") \
22778 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22780 /* List of command functions, CLI names map directly to functions */
22781 #define foreach_cli_function \
22782 _(comment, "usage: comment <ignore-rest-of-line>") \
22783 _(dump_interface_table, "usage: dump_interface_table") \
22784 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22785 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22786 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22787 _(dump_stats_table, "usage: dump_stats_table") \
22788 _(dump_macro_table, "usage: dump_macro_table ") \
22789 _(dump_node_table, "usage: dump_node_table") \
22790 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22791 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22792 _(echo, "usage: echo <message>") \
22793 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22794 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22795 _(help, "usage: help") \
22796 _(q, "usage: quit") \
22797 _(quit, "usage: quit") \
22798 _(search_node_table, "usage: search_node_table <name>...") \
22799 _(set, "usage: set <variable-name> <value>") \
22800 _(script, "usage: script <file-name>") \
22801 _(unset, "usage: unset <variable-name>")
22803 static void vl_api_##n##_t_handler_uni \
22804 (vl_api_##n##_t * mp) \
22806 vat_main_t * vam = &vat_main; \
22807 if (vam->json_output) { \
22808 vl_api_##n##_t_handler_json(mp); \
22810 vl_api_##n##_t_handler(mp); \
22813 foreach_vpe_api_reply_msg;
22814 #if VPP_API_TEST_BUILTIN == 0
22815 foreach_standalone_reply_msg;
22820 vat_api_hookup (vat_main_t * vam)
22823 vl_msg_api_set_handlers(VL_API_##N, #n, \
22824 vl_api_##n##_t_handler_uni, \
22826 vl_api_##n##_t_endian, \
22827 vl_api_##n##_t_print, \
22828 sizeof(vl_api_##n##_t), 1);
22829 foreach_vpe_api_reply_msg;
22830 #if VPP_API_TEST_BUILTIN == 0
22831 foreach_standalone_reply_msg;
22835 #if (VPP_API_TEST_BUILTIN==0)
22836 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22838 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22840 vam->function_by_name = hash_create_string (0, sizeof (uword));
22842 vam->help_by_name = hash_create_string (0, sizeof (uword));
22845 /* API messages we can send */
22846 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22847 foreach_vpe_api_msg;
22851 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22852 foreach_vpe_api_msg;
22855 /* CLI functions */
22856 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22857 foreach_cli_function;
22861 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22862 foreach_cli_function;
22866 #if VPP_API_TEST_BUILTIN
22867 static clib_error_t *
22868 vat_api_hookup_shim (vlib_main_t * vm)
22870 vat_api_hookup (&vat_main);
22874 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22878 * fd.io coding-style-patch-verification: ON
22881 * eval: (c-set-style "gnu")