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 (u64 * mac)
725 tmp = clib_net_to_host_u64 (tmp);
726 tmp += 1 << 16; /* skip unused (least significant) octets */
727 tmp = clib_host_to_net_u64 (tmp);
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_show_one_use_petr_reply_t_handler
4243 (vl_api_show_one_use_petr_reply_t * mp)
4245 vat_main_t *vam = &vat_main;
4246 i32 retval = ntohl (mp->retval);
4250 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4253 print (vam->ofp, "Proxy-ETR address; %U",
4254 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4259 vam->retval = retval;
4260 vam->result_ready = 1;
4264 vl_api_show_one_use_petr_reply_t_handler_json
4265 (vl_api_show_one_use_petr_reply_t * mp)
4267 vat_main_t *vam = &vat_main;
4268 vat_json_node_t node;
4271 struct in6_addr ip6;
4273 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4274 vec_add1 (status, 0);
4276 vat_json_init_object (&node);
4277 vat_json_object_add_string_copy (&node, "status", status);
4282 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4283 vat_json_object_add_ip6 (&node, "address", ip6);
4287 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4288 vat_json_object_add_ip4 (&node, "address", ip4);
4294 vat_json_print (vam->ofp, &node);
4295 vat_json_free (&node);
4297 vam->retval = ntohl (mp->retval);
4298 vam->result_ready = 1;
4302 vl_api_show_one_nsh_mapping_reply_t_handler
4303 (vl_api_show_one_nsh_mapping_reply_t * mp)
4305 vat_main_t *vam = &vat_main;
4306 i32 retval = ntohl (mp->retval);
4310 print (vam->ofp, "%-20s%-16s",
4311 mp->is_set ? "set" : "not-set",
4312 mp->is_set ? (char *) mp->locator_set_name : "");
4315 vam->retval = retval;
4316 vam->result_ready = 1;
4320 vl_api_show_one_nsh_mapping_reply_t_handler_json
4321 (vl_api_show_one_nsh_mapping_reply_t * mp)
4323 vat_main_t *vam = &vat_main;
4324 vat_json_node_t node;
4327 status = format (0, "%s", mp->is_set ? "yes" : "no");
4328 vec_add1 (status, 0);
4330 vat_json_init_object (&node);
4331 vat_json_object_add_string_copy (&node, "is_set", status);
4334 vat_json_object_add_string_copy (&node, "locator_set",
4335 mp->locator_set_name);
4340 vat_json_print (vam->ofp, &node);
4341 vat_json_free (&node);
4343 vam->retval = ntohl (mp->retval);
4344 vam->result_ready = 1;
4348 vl_api_show_one_map_register_ttl_reply_t_handler
4349 (vl_api_show_one_map_register_ttl_reply_t * mp)
4351 vat_main_t *vam = &vat_main;
4352 i32 retval = ntohl (mp->retval);
4354 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4358 print (vam->ofp, "ttl: %u", mp->ttl);
4361 vam->retval = retval;
4362 vam->result_ready = 1;
4366 vl_api_show_one_map_register_ttl_reply_t_handler_json
4367 (vl_api_show_one_map_register_ttl_reply_t * mp)
4369 vat_main_t *vam = &vat_main;
4370 vat_json_node_t node;
4372 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4373 vat_json_init_object (&node);
4374 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4376 vat_json_print (vam->ofp, &node);
4377 vat_json_free (&node);
4379 vam->retval = ntohl (mp->retval);
4380 vam->result_ready = 1;
4384 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4386 vat_main_t *vam = &vat_main;
4387 i32 retval = ntohl (mp->retval);
4391 print (vam->ofp, "%-20s%-16s",
4392 mp->status ? "enabled" : "disabled",
4393 mp->status ? (char *) mp->locator_set_name : "");
4396 vam->retval = retval;
4397 vam->result_ready = 1;
4401 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4403 vat_main_t *vam = &vat_main;
4404 vat_json_node_t node;
4407 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4408 vec_add1 (status, 0);
4410 vat_json_init_object (&node);
4411 vat_json_object_add_string_copy (&node, "status", status);
4414 vat_json_object_add_string_copy (&node, "locator_set",
4415 mp->locator_set_name);
4420 vat_json_print (vam->ofp, &node);
4421 vat_json_free (&node);
4423 vam->retval = ntohl (mp->retval);
4424 vam->result_ready = 1;
4428 format_policer_type (u8 * s, va_list * va)
4430 u32 i = va_arg (*va, u32);
4432 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4433 s = format (s, "1r2c");
4434 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4435 s = format (s, "1r3c");
4436 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4437 s = format (s, "2r3c-2698");
4438 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4439 s = format (s, "2r3c-4115");
4440 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4441 s = format (s, "2r3c-mef5cf1");
4443 s = format (s, "ILLEGAL");
4448 format_policer_rate_type (u8 * s, va_list * va)
4450 u32 i = va_arg (*va, u32);
4452 if (i == SSE2_QOS_RATE_KBPS)
4453 s = format (s, "kbps");
4454 else if (i == SSE2_QOS_RATE_PPS)
4455 s = format (s, "pps");
4457 s = format (s, "ILLEGAL");
4462 format_policer_round_type (u8 * s, va_list * va)
4464 u32 i = va_arg (*va, u32);
4466 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4467 s = format (s, "closest");
4468 else if (i == SSE2_QOS_ROUND_TO_UP)
4469 s = format (s, "up");
4470 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4471 s = format (s, "down");
4473 s = format (s, "ILLEGAL");
4478 format_policer_action_type (u8 * s, va_list * va)
4480 u32 i = va_arg (*va, u32);
4482 if (i == SSE2_QOS_ACTION_DROP)
4483 s = format (s, "drop");
4484 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4485 s = format (s, "transmit");
4486 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4487 s = format (s, "mark-and-transmit");
4489 s = format (s, "ILLEGAL");
4494 format_dscp (u8 * s, va_list * va)
4496 u32 i = va_arg (*va, u32);
4501 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4505 return format (s, "ILLEGAL");
4507 s = format (s, "%s", t);
4512 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4514 vat_main_t *vam = &vat_main;
4515 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4517 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4518 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4520 conform_dscp_str = format (0, "");
4522 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4523 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4525 exceed_dscp_str = format (0, "");
4527 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4528 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4530 violate_dscp_str = format (0, "");
4532 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4533 "rate type %U, round type %U, %s rate, %s color-aware, "
4534 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4535 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4536 "conform action %U%s, exceed action %U%s, violate action %U%s",
4538 format_policer_type, mp->type,
4541 clib_net_to_host_u64 (mp->cb),
4542 clib_net_to_host_u64 (mp->eb),
4543 format_policer_rate_type, mp->rate_type,
4544 format_policer_round_type, mp->round_type,
4545 mp->single_rate ? "single" : "dual",
4546 mp->color_aware ? "is" : "not",
4547 ntohl (mp->cir_tokens_per_period),
4548 ntohl (mp->pir_tokens_per_period),
4550 ntohl (mp->current_limit),
4551 ntohl (mp->current_bucket),
4552 ntohl (mp->extended_limit),
4553 ntohl (mp->extended_bucket),
4554 clib_net_to_host_u64 (mp->last_update_time),
4555 format_policer_action_type, mp->conform_action_type,
4557 format_policer_action_type, mp->exceed_action_type,
4559 format_policer_action_type, mp->violate_action_type,
4562 vec_free (conform_dscp_str);
4563 vec_free (exceed_dscp_str);
4564 vec_free (violate_dscp_str);
4567 static void vl_api_policer_details_t_handler_json
4568 (vl_api_policer_details_t * mp)
4570 vat_main_t *vam = &vat_main;
4571 vat_json_node_t *node;
4572 u8 *rate_type_str, *round_type_str, *type_str;
4573 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4575 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4577 format (0, "%U", format_policer_round_type, mp->round_type);
4578 type_str = format (0, "%U", format_policer_type, mp->type);
4579 conform_action_str = format (0, "%U", format_policer_action_type,
4580 mp->conform_action_type);
4581 exceed_action_str = format (0, "%U", format_policer_action_type,
4582 mp->exceed_action_type);
4583 violate_action_str = format (0, "%U", format_policer_action_type,
4584 mp->violate_action_type);
4586 if (VAT_JSON_ARRAY != vam->json_tree.type)
4588 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4589 vat_json_init_array (&vam->json_tree);
4591 node = vat_json_array_add (&vam->json_tree);
4593 vat_json_init_object (node);
4594 vat_json_object_add_string_copy (node, "name", mp->name);
4595 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4596 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4597 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4598 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4599 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4600 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4601 vat_json_object_add_string_copy (node, "type", type_str);
4602 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4603 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4604 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4605 vat_json_object_add_uint (node, "cir_tokens_per_period",
4606 ntohl (mp->cir_tokens_per_period));
4607 vat_json_object_add_uint (node, "eir_tokens_per_period",
4608 ntohl (mp->pir_tokens_per_period));
4609 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4610 vat_json_object_add_uint (node, "current_bucket",
4611 ntohl (mp->current_bucket));
4612 vat_json_object_add_uint (node, "extended_limit",
4613 ntohl (mp->extended_limit));
4614 vat_json_object_add_uint (node, "extended_bucket",
4615 ntohl (mp->extended_bucket));
4616 vat_json_object_add_uint (node, "last_update_time",
4617 ntohl (mp->last_update_time));
4618 vat_json_object_add_string_copy (node, "conform_action",
4619 conform_action_str);
4620 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4622 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4623 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4624 vec_free (dscp_str);
4626 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4627 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4629 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4630 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4631 vec_free (dscp_str);
4633 vat_json_object_add_string_copy (node, "violate_action",
4634 violate_action_str);
4635 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4637 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4638 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4639 vec_free (dscp_str);
4642 vec_free (rate_type_str);
4643 vec_free (round_type_str);
4644 vec_free (type_str);
4645 vec_free (conform_action_str);
4646 vec_free (exceed_action_str);
4647 vec_free (violate_action_str);
4651 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4654 vat_main_t *vam = &vat_main;
4655 int i, count = ntohl (mp->count);
4658 print (vam->ofp, "classify table ids (%d) : ", count);
4659 for (i = 0; i < count; i++)
4661 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4662 print (vam->ofp, (i < count - 1) ? "," : "");
4664 vam->retval = ntohl (mp->retval);
4665 vam->result_ready = 1;
4669 vl_api_classify_table_ids_reply_t_handler_json
4670 (vl_api_classify_table_ids_reply_t * mp)
4672 vat_main_t *vam = &vat_main;
4673 int i, count = ntohl (mp->count);
4677 vat_json_node_t node;
4679 vat_json_init_object (&node);
4680 for (i = 0; i < count; i++)
4682 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4684 vat_json_print (vam->ofp, &node);
4685 vat_json_free (&node);
4687 vam->retval = ntohl (mp->retval);
4688 vam->result_ready = 1;
4692 vl_api_classify_table_by_interface_reply_t_handler
4693 (vl_api_classify_table_by_interface_reply_t * mp)
4695 vat_main_t *vam = &vat_main;
4698 table_id = ntohl (mp->l2_table_id);
4700 print (vam->ofp, "l2 table id : %d", table_id);
4702 print (vam->ofp, "l2 table id : No input ACL tables configured");
4703 table_id = ntohl (mp->ip4_table_id);
4705 print (vam->ofp, "ip4 table id : %d", table_id);
4707 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4708 table_id = ntohl (mp->ip6_table_id);
4710 print (vam->ofp, "ip6 table id : %d", table_id);
4712 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4713 vam->retval = ntohl (mp->retval);
4714 vam->result_ready = 1;
4718 vl_api_classify_table_by_interface_reply_t_handler_json
4719 (vl_api_classify_table_by_interface_reply_t * mp)
4721 vat_main_t *vam = &vat_main;
4722 vat_json_node_t node;
4724 vat_json_init_object (&node);
4726 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4727 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4728 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4730 vat_json_print (vam->ofp, &node);
4731 vat_json_free (&node);
4733 vam->retval = ntohl (mp->retval);
4734 vam->result_ready = 1;
4737 static void vl_api_policer_add_del_reply_t_handler
4738 (vl_api_policer_add_del_reply_t * mp)
4740 vat_main_t *vam = &vat_main;
4741 i32 retval = ntohl (mp->retval);
4742 if (vam->async_mode)
4744 vam->async_errors += (retval < 0);
4748 vam->retval = retval;
4749 vam->result_ready = 1;
4750 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4752 * Note: this is just barely thread-safe, depends on
4753 * the main thread spinning waiting for an answer...
4755 errmsg ("policer index %d", ntohl (mp->policer_index));
4759 static void vl_api_policer_add_del_reply_t_handler_json
4760 (vl_api_policer_add_del_reply_t * mp)
4762 vat_main_t *vam = &vat_main;
4763 vat_json_node_t node;
4765 vat_json_init_object (&node);
4766 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4767 vat_json_object_add_uint (&node, "policer_index",
4768 ntohl (mp->policer_index));
4770 vat_json_print (vam->ofp, &node);
4771 vat_json_free (&node);
4773 vam->retval = ntohl (mp->retval);
4774 vam->result_ready = 1;
4777 /* Format hex dump. */
4779 format_hex_bytes (u8 * s, va_list * va)
4781 u8 *bytes = va_arg (*va, u8 *);
4782 int n_bytes = va_arg (*va, int);
4785 /* Print short or long form depending on byte count. */
4786 uword short_form = n_bytes <= 32;
4787 u32 indent = format_get_indent (s);
4792 for (i = 0; i < n_bytes; i++)
4794 if (!short_form && (i % 32) == 0)
4795 s = format (s, "%08x: ", i);
4796 s = format (s, "%02x", bytes[i]);
4797 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4798 s = format (s, "\n%U", format_white_space, indent);
4805 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4808 vat_main_t *vam = &vat_main;
4809 i32 retval = ntohl (mp->retval);
4812 print (vam->ofp, "classify table info :");
4813 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4814 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4815 ntohl (mp->miss_next_index));
4816 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4817 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4818 ntohl (mp->match_n_vectors));
4819 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4820 ntohl (mp->mask_length));
4822 vam->retval = retval;
4823 vam->result_ready = 1;
4827 vl_api_classify_table_info_reply_t_handler_json
4828 (vl_api_classify_table_info_reply_t * mp)
4830 vat_main_t *vam = &vat_main;
4831 vat_json_node_t node;
4833 i32 retval = ntohl (mp->retval);
4836 vat_json_init_object (&node);
4838 vat_json_object_add_int (&node, "sessions",
4839 ntohl (mp->active_sessions));
4840 vat_json_object_add_int (&node, "nexttbl",
4841 ntohl (mp->next_table_index));
4842 vat_json_object_add_int (&node, "nextnode",
4843 ntohl (mp->miss_next_index));
4844 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4845 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4846 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4847 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4848 ntohl (mp->mask_length), 0);
4849 vat_json_object_add_string_copy (&node, "mask", s);
4851 vat_json_print (vam->ofp, &node);
4852 vat_json_free (&node);
4854 vam->retval = ntohl (mp->retval);
4855 vam->result_ready = 1;
4859 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4862 vat_main_t *vam = &vat_main;
4864 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4865 ntohl (mp->hit_next_index), ntohl (mp->advance),
4866 ntohl (mp->opaque_index));
4867 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4868 ntohl (mp->match_length));
4872 vl_api_classify_session_details_t_handler_json
4873 (vl_api_classify_session_details_t * mp)
4875 vat_main_t *vam = &vat_main;
4876 vat_json_node_t *node = NULL;
4878 if (VAT_JSON_ARRAY != vam->json_tree.type)
4880 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4881 vat_json_init_array (&vam->json_tree);
4883 node = vat_json_array_add (&vam->json_tree);
4885 vat_json_init_object (node);
4886 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4887 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4888 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4890 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4892 vat_json_object_add_string_copy (node, "match", s);
4895 static void vl_api_pg_create_interface_reply_t_handler
4896 (vl_api_pg_create_interface_reply_t * mp)
4898 vat_main_t *vam = &vat_main;
4900 vam->retval = ntohl (mp->retval);
4901 vam->result_ready = 1;
4904 static void vl_api_pg_create_interface_reply_t_handler_json
4905 (vl_api_pg_create_interface_reply_t * mp)
4907 vat_main_t *vam = &vat_main;
4908 vat_json_node_t node;
4910 i32 retval = ntohl (mp->retval);
4913 vat_json_init_object (&node);
4915 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4917 vat_json_print (vam->ofp, &node);
4918 vat_json_free (&node);
4920 vam->retval = ntohl (mp->retval);
4921 vam->result_ready = 1;
4924 static void vl_api_policer_classify_details_t_handler
4925 (vl_api_policer_classify_details_t * mp)
4927 vat_main_t *vam = &vat_main;
4929 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4930 ntohl (mp->table_index));
4933 static void vl_api_policer_classify_details_t_handler_json
4934 (vl_api_policer_classify_details_t * mp)
4936 vat_main_t *vam = &vat_main;
4937 vat_json_node_t *node;
4939 if (VAT_JSON_ARRAY != vam->json_tree.type)
4941 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4942 vat_json_init_array (&vam->json_tree);
4944 node = vat_json_array_add (&vam->json_tree);
4946 vat_json_init_object (node);
4947 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4948 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4951 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
4952 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4954 vat_main_t *vam = &vat_main;
4955 i32 retval = ntohl (mp->retval);
4956 if (vam->async_mode)
4958 vam->async_errors += (retval < 0);
4962 vam->retval = retval;
4963 vam->sw_if_index = ntohl (mp->sw_if_index);
4964 vam->result_ready = 1;
4968 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
4969 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
4971 vat_main_t *vam = &vat_main;
4972 vat_json_node_t node;
4974 vat_json_init_object (&node);
4975 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4976 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
4978 vat_json_print (vam->ofp, &node);
4979 vat_json_free (&node);
4981 vam->retval = ntohl (mp->retval);
4982 vam->result_ready = 1;
4985 static void vl_api_flow_classify_details_t_handler
4986 (vl_api_flow_classify_details_t * mp)
4988 vat_main_t *vam = &vat_main;
4990 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4991 ntohl (mp->table_index));
4994 static void vl_api_flow_classify_details_t_handler_json
4995 (vl_api_flow_classify_details_t * mp)
4997 vat_main_t *vam = &vat_main;
4998 vat_json_node_t *node;
5000 if (VAT_JSON_ARRAY != vam->json_tree.type)
5002 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5003 vat_json_init_array (&vam->json_tree);
5005 node = vat_json_array_add (&vam->json_tree);
5007 vat_json_init_object (node);
5008 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5009 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5012 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5013 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5014 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5015 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5016 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5017 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5018 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5019 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5020 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5021 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5022 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5023 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5024 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5025 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5026 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5027 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5028 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5029 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5030 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5031 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5032 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5033 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5036 * Generate boilerplate reply handlers, which
5037 * dig the return value out of the xxx_reply_t API message,
5038 * stick it into vam->retval, and set vam->result_ready
5040 * Could also do this by pointing N message decode slots at
5041 * a single function, but that could break in subtle ways.
5044 #define foreach_standard_reply_retval_handler \
5045 _(sw_interface_set_flags_reply) \
5046 _(sw_interface_add_del_address_reply) \
5047 _(sw_interface_set_table_reply) \
5048 _(sw_interface_set_mpls_enable_reply) \
5049 _(sw_interface_set_vpath_reply) \
5050 _(sw_interface_set_vxlan_bypass_reply) \
5051 _(sw_interface_set_geneve_bypass_reply) \
5052 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5053 _(sw_interface_set_l2_bridge_reply) \
5054 _(bridge_domain_add_del_reply) \
5055 _(sw_interface_set_l2_xconnect_reply) \
5056 _(l2fib_add_del_reply) \
5057 _(l2fib_flush_int_reply) \
5058 _(l2fib_flush_bd_reply) \
5059 _(ip_add_del_route_reply) \
5060 _(ip_table_add_del_reply) \
5061 _(ip_mroute_add_del_reply) \
5062 _(mpls_route_add_del_reply) \
5063 _(mpls_table_add_del_reply) \
5064 _(mpls_ip_bind_unbind_reply) \
5065 _(proxy_arp_add_del_reply) \
5066 _(proxy_arp_intfc_enable_disable_reply) \
5067 _(sw_interface_set_unnumbered_reply) \
5068 _(ip_neighbor_add_del_reply) \
5069 _(reset_vrf_reply) \
5070 _(oam_add_del_reply) \
5071 _(reset_fib_reply) \
5072 _(dhcp_proxy_config_reply) \
5073 _(dhcp_proxy_set_vss_reply) \
5074 _(dhcp_client_config_reply) \
5075 _(set_ip_flow_hash_reply) \
5076 _(sw_interface_ip6_enable_disable_reply) \
5077 _(sw_interface_ip6_set_link_local_address_reply) \
5078 _(ip6nd_proxy_add_del_reply) \
5079 _(sw_interface_ip6nd_ra_prefix_reply) \
5080 _(sw_interface_ip6nd_ra_config_reply) \
5081 _(set_arp_neighbor_limit_reply) \
5082 _(l2_patch_add_del_reply) \
5083 _(sr_policy_add_reply) \
5084 _(sr_policy_mod_reply) \
5085 _(sr_policy_del_reply) \
5086 _(sr_localsid_add_del_reply) \
5087 _(sr_steering_add_del_reply) \
5088 _(classify_add_del_session_reply) \
5089 _(classify_set_interface_ip_table_reply) \
5090 _(classify_set_interface_l2_tables_reply) \
5091 _(l2tpv3_set_tunnel_cookies_reply) \
5092 _(l2tpv3_interface_enable_disable_reply) \
5093 _(l2tpv3_set_lookup_key_reply) \
5094 _(l2_fib_clear_table_reply) \
5095 _(l2_interface_efp_filter_reply) \
5096 _(l2_interface_vlan_tag_rewrite_reply) \
5097 _(modify_vhost_user_if_reply) \
5098 _(delete_vhost_user_if_reply) \
5099 _(want_ip4_arp_events_reply) \
5100 _(want_ip6_nd_events_reply) \
5101 _(want_l2_macs_events_reply) \
5102 _(input_acl_set_interface_reply) \
5103 _(ipsec_spd_add_del_reply) \
5104 _(ipsec_interface_add_del_spd_reply) \
5105 _(ipsec_spd_add_del_entry_reply) \
5106 _(ipsec_sad_add_del_entry_reply) \
5107 _(ipsec_sa_set_key_reply) \
5108 _(ipsec_tunnel_if_add_del_reply) \
5109 _(ipsec_tunnel_if_set_key_reply) \
5110 _(ipsec_tunnel_if_set_sa_reply) \
5111 _(ikev2_profile_add_del_reply) \
5112 _(ikev2_profile_set_auth_reply) \
5113 _(ikev2_profile_set_id_reply) \
5114 _(ikev2_profile_set_ts_reply) \
5115 _(ikev2_set_local_key_reply) \
5116 _(ikev2_set_responder_reply) \
5117 _(ikev2_set_ike_transforms_reply) \
5118 _(ikev2_set_esp_transforms_reply) \
5119 _(ikev2_set_sa_lifetime_reply) \
5120 _(ikev2_initiate_sa_init_reply) \
5121 _(ikev2_initiate_del_ike_sa_reply) \
5122 _(ikev2_initiate_del_child_sa_reply) \
5123 _(ikev2_initiate_rekey_child_sa_reply) \
5124 _(delete_loopback_reply) \
5125 _(bd_ip_mac_add_del_reply) \
5126 _(map_del_domain_reply) \
5127 _(map_add_del_rule_reply) \
5128 _(want_interface_events_reply) \
5129 _(want_stats_reply) \
5130 _(cop_interface_enable_disable_reply) \
5131 _(cop_whitelist_enable_disable_reply) \
5132 _(sw_interface_clear_stats_reply) \
5133 _(ioam_enable_reply) \
5134 _(ioam_disable_reply) \
5135 _(one_add_del_locator_reply) \
5136 _(one_add_del_local_eid_reply) \
5137 _(one_add_del_remote_mapping_reply) \
5138 _(one_add_del_adjacency_reply) \
5139 _(one_add_del_map_resolver_reply) \
5140 _(one_add_del_map_server_reply) \
5141 _(one_enable_disable_reply) \
5142 _(one_rloc_probe_enable_disable_reply) \
5143 _(one_map_register_enable_disable_reply) \
5144 _(one_map_register_set_ttl_reply) \
5145 _(one_set_transport_protocol_reply) \
5146 _(one_map_register_fallback_threshold_reply) \
5147 _(one_pitr_set_locator_set_reply) \
5148 _(one_map_request_mode_reply) \
5149 _(one_add_del_map_request_itr_rlocs_reply) \
5150 _(one_eid_table_add_del_map_reply) \
5151 _(one_use_petr_reply) \
5152 _(one_stats_enable_disable_reply) \
5153 _(one_add_del_l2_arp_entry_reply) \
5154 _(one_add_del_ndp_entry_reply) \
5155 _(one_stats_flush_reply) \
5156 _(gpe_enable_disable_reply) \
5157 _(gpe_set_encap_mode_reply) \
5158 _(gpe_add_del_iface_reply) \
5159 _(gpe_add_del_native_fwd_rpath_reply) \
5160 _(af_packet_delete_reply) \
5161 _(policer_classify_set_interface_reply) \
5162 _(netmap_create_reply) \
5163 _(netmap_delete_reply) \
5164 _(set_ipfix_exporter_reply) \
5165 _(set_ipfix_classify_stream_reply) \
5166 _(ipfix_classify_table_add_del_reply) \
5167 _(flow_classify_set_interface_reply) \
5168 _(sw_interface_span_enable_disable_reply) \
5169 _(pg_capture_reply) \
5170 _(pg_enable_disable_reply) \
5171 _(ip_source_and_port_range_check_add_del_reply) \
5172 _(ip_source_and_port_range_check_interface_add_del_reply)\
5173 _(delete_subif_reply) \
5174 _(l2_interface_pbb_tag_rewrite_reply) \
5176 _(feature_enable_disable_reply) \
5177 _(sw_interface_tag_add_del_reply) \
5178 _(sw_interface_set_mtu_reply) \
5179 _(p2p_ethernet_add_reply) \
5180 _(p2p_ethernet_del_reply) \
5181 _(lldp_config_reply) \
5182 _(sw_interface_set_lldp_reply) \
5183 _(tcp_configure_src_addresses_reply) \
5184 _(app_namespace_add_del_reply) \
5185 _(dns_enable_disable_reply) \
5186 _(dns_name_server_add_del_reply) \
5187 _(session_rule_add_del_reply)
5190 static void vl_api_##n##_t_handler \
5191 (vl_api_##n##_t * mp) \
5193 vat_main_t * vam = &vat_main; \
5194 i32 retval = ntohl(mp->retval); \
5195 if (vam->async_mode) { \
5196 vam->async_errors += (retval < 0); \
5198 vam->retval = retval; \
5199 vam->result_ready = 1; \
5202 foreach_standard_reply_retval_handler;
5206 static void vl_api_##n##_t_handler_json \
5207 (vl_api_##n##_t * mp) \
5209 vat_main_t * vam = &vat_main; \
5210 vat_json_node_t node; \
5211 vat_json_init_object(&node); \
5212 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5213 vat_json_print(vam->ofp, &node); \
5214 vam->retval = ntohl(mp->retval); \
5215 vam->result_ready = 1; \
5217 foreach_standard_reply_retval_handler;
5221 * Table of message reply handlers, must include boilerplate handlers
5225 #define foreach_vpe_api_reply_msg \
5226 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5227 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5228 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5229 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5230 _(CONTROL_PING_REPLY, control_ping_reply) \
5231 _(CLI_REPLY, cli_reply) \
5232 _(CLI_INBAND_REPLY, cli_inband_reply) \
5233 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5234 sw_interface_add_del_address_reply) \
5235 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5236 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5237 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5238 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5239 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5240 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5241 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5242 sw_interface_set_l2_xconnect_reply) \
5243 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5244 sw_interface_set_l2_bridge_reply) \
5245 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5246 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5247 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5248 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5249 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5250 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5251 _(L2_FLAGS_REPLY, l2_flags_reply) \
5252 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5253 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5254 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5255 _(TAP_DELETE_REPLY, tap_delete_reply) \
5256 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5257 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5258 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5259 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5260 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5261 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5262 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5263 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5264 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5265 proxy_arp_intfc_enable_disable_reply) \
5266 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5267 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5268 sw_interface_set_unnumbered_reply) \
5269 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5270 _(RESET_VRF_REPLY, reset_vrf_reply) \
5271 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5272 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5273 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5274 _(RESET_FIB_REPLY, reset_fib_reply) \
5275 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5276 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5277 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5278 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5279 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5280 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5281 sw_interface_ip6_enable_disable_reply) \
5282 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5283 sw_interface_ip6_set_link_local_address_reply) \
5284 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5285 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5286 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5287 sw_interface_ip6nd_ra_prefix_reply) \
5288 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5289 sw_interface_ip6nd_ra_config_reply) \
5290 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5291 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5292 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5293 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5294 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5295 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5296 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5297 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5298 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5299 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5300 classify_set_interface_ip_table_reply) \
5301 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5302 classify_set_interface_l2_tables_reply) \
5303 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5304 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5305 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5306 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5307 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5308 l2tpv3_interface_enable_disable_reply) \
5309 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5310 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5311 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5312 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5313 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5314 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5315 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5316 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5317 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5318 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5319 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5320 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5321 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5322 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5323 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5324 _(SHOW_VERSION_REPLY, show_version_reply) \
5325 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5326 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5327 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5328 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5329 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5330 _(IP4_ARP_EVENT, ip4_arp_event) \
5331 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5332 _(IP6_ND_EVENT, ip6_nd_event) \
5333 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5334 _(L2_MACS_EVENT, l2_macs_event) \
5335 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5336 _(IP_ADDRESS_DETAILS, ip_address_details) \
5337 _(IP_DETAILS, ip_details) \
5338 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5339 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5340 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5341 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5342 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5343 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5344 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5345 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5346 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5347 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5348 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5349 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5350 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5351 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5352 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5353 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5354 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5355 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5356 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5357 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5358 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5359 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5360 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5361 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5362 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5363 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5364 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5365 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5366 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5367 _(MAP_RULE_DETAILS, map_rule_details) \
5368 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5369 _(WANT_STATS_REPLY, want_stats_reply) \
5370 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5371 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5372 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5373 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5374 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5375 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5376 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5377 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5378 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5379 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5380 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5381 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5382 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5383 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5384 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5385 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5386 one_map_register_enable_disable_reply) \
5387 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5388 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5389 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5390 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5391 one_map_register_fallback_threshold_reply) \
5392 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5393 one_rloc_probe_enable_disable_reply) \
5394 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5395 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5396 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5397 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5398 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5399 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5400 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5401 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5402 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5403 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5404 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5405 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5406 _(ONE_STATS_DETAILS, one_stats_details) \
5407 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5408 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5409 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5410 show_one_stats_enable_disable_reply) \
5411 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5412 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5413 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5414 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5415 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5416 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5417 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5418 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5419 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5420 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5421 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5422 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5423 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5424 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5425 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5426 gpe_add_del_native_fwd_rpath_reply) \
5427 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5428 gpe_fwd_entry_path_details) \
5429 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5430 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5431 one_add_del_map_request_itr_rlocs_reply) \
5432 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5433 one_get_map_request_itr_rlocs_reply) \
5434 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5435 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5436 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5437 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5438 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5439 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5440 show_one_map_register_state_reply) \
5441 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5442 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5443 show_one_map_register_fallback_threshold_reply) \
5444 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5445 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5446 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5447 _(POLICER_DETAILS, policer_details) \
5448 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5449 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5450 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5451 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5452 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5453 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5454 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5455 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5456 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5457 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5458 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5459 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5460 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5461 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5462 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5463 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5464 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5465 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5466 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5467 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5468 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5469 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5470 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5471 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5472 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5473 ip_source_and_port_range_check_add_del_reply) \
5474 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5475 ip_source_and_port_range_check_interface_add_del_reply) \
5476 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5477 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5478 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5479 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5480 _(PUNT_REPLY, punt_reply) \
5481 _(IP_FIB_DETAILS, ip_fib_details) \
5482 _(IP6_FIB_DETAILS, ip6_fib_details) \
5483 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5484 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5485 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5486 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5487 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5488 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5489 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5490 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5491 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5492 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5493 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5494 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5495 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5496 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5497 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5498 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5499 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply)
5501 #define foreach_standalone_reply_msg \
5502 _(SW_INTERFACE_EVENT, sw_interface_event) \
5503 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5504 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5505 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5506 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5507 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5508 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
5509 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
5518 #define STR_VTR_OP_CASE(op) \
5519 case L2_VTR_ ## op: \
5523 str_vtr_op (u32 vtr_op)
5527 STR_VTR_OP_CASE (DISABLED);
5528 STR_VTR_OP_CASE (PUSH_1);
5529 STR_VTR_OP_CASE (PUSH_2);
5530 STR_VTR_OP_CASE (POP_1);
5531 STR_VTR_OP_CASE (POP_2);
5532 STR_VTR_OP_CASE (TRANSLATE_1_1);
5533 STR_VTR_OP_CASE (TRANSLATE_1_2);
5534 STR_VTR_OP_CASE (TRANSLATE_2_1);
5535 STR_VTR_OP_CASE (TRANSLATE_2_2);
5542 dump_sub_interface_table (vat_main_t * vam)
5544 const sw_interface_subif_t *sub = NULL;
5546 if (vam->json_output)
5549 ("JSON output supported only for VPE API calls and dump_stats_table");
5554 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5555 "Interface", "sw_if_index",
5556 "sub id", "dot1ad", "tags", "outer id",
5557 "inner id", "exact", "default", "outer any", "inner any");
5559 vec_foreach (sub, vam->sw_if_subif_table)
5562 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5563 sub->interface_name,
5565 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5566 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5567 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5568 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5569 if (sub->vtr_op != L2_VTR_DISABLED)
5572 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5573 "tag1: %d tag2: %d ]",
5574 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5575 sub->vtr_tag1, sub->vtr_tag2);
5583 name_sort_cmp (void *a1, void *a2)
5585 name_sort_t *n1 = a1;
5586 name_sort_t *n2 = a2;
5588 return strcmp ((char *) n1->name, (char *) n2->name);
5592 dump_interface_table (vat_main_t * vam)
5595 name_sort_t *nses = 0, *ns;
5597 if (vam->json_output)
5600 ("JSON output supported only for VPE API calls and dump_stats_table");
5605 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5607 vec_add2 (nses, ns, 1);
5608 ns->name = (u8 *)(p->key);
5609 ns->value = (u32) p->value[0];
5613 vec_sort_with_function (nses, name_sort_cmp);
5615 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5616 vec_foreach (ns, nses)
5618 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5625 dump_ip_table (vat_main_t * vam, int is_ipv6)
5627 const ip_details_t *det = NULL;
5628 const ip_address_details_t *address = NULL;
5631 print (vam->ofp, "%-12s", "sw_if_index");
5633 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5640 print (vam->ofp, "%-12d", i);
5641 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5646 vec_foreach (address, det->addr)
5650 is_ipv6 ? format_ip6_address : format_ip4_address,
5651 address->ip, address->prefix_length);
5659 dump_ipv4_table (vat_main_t * vam)
5661 if (vam->json_output)
5664 ("JSON output supported only for VPE API calls and dump_stats_table");
5668 return dump_ip_table (vam, 0);
5672 dump_ipv6_table (vat_main_t * vam)
5674 if (vam->json_output)
5677 ("JSON output supported only for VPE API calls and dump_stats_table");
5681 return dump_ip_table (vam, 1);
5685 counter_type_to_str (u8 counter_type, u8 is_combined)
5689 switch (counter_type)
5691 case VNET_INTERFACE_COUNTER_DROP:
5693 case VNET_INTERFACE_COUNTER_PUNT:
5695 case VNET_INTERFACE_COUNTER_IP4:
5697 case VNET_INTERFACE_COUNTER_IP6:
5699 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5701 case VNET_INTERFACE_COUNTER_RX_MISS:
5703 case VNET_INTERFACE_COUNTER_RX_ERROR:
5705 case VNET_INTERFACE_COUNTER_TX_ERROR:
5708 return "INVALID-COUNTER-TYPE";
5713 switch (counter_type)
5715 case VNET_INTERFACE_COUNTER_RX:
5717 case VNET_INTERFACE_COUNTER_TX:
5720 return "INVALID-COUNTER-TYPE";
5726 dump_stats_table (vat_main_t * vam)
5728 vat_json_node_t node;
5729 vat_json_node_t *msg_array;
5730 vat_json_node_t *msg;
5731 vat_json_node_t *counter_array;
5732 vat_json_node_t *counter;
5733 interface_counter_t c;
5735 ip4_fib_counter_t *c4;
5736 ip6_fib_counter_t *c6;
5737 ip4_nbr_counter_t *n4;
5738 ip6_nbr_counter_t *n6;
5741 if (!vam->json_output)
5743 clib_warning ("dump_stats_table supported only in JSON format");
5747 vat_json_init_object (&node);
5749 /* interface counters */
5750 msg_array = vat_json_object_add (&node, "interface_counters");
5751 vat_json_init_array (msg_array);
5752 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5754 msg = vat_json_array_add (msg_array);
5755 vat_json_init_object (msg);
5756 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5757 (u8 *) counter_type_to_str (i, 0));
5758 vat_json_object_add_int (msg, "is_combined", 0);
5759 counter_array = vat_json_object_add (msg, "data");
5760 vat_json_init_array (counter_array);
5761 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5763 packets = vam->simple_interface_counters[i][j];
5764 vat_json_array_add_uint (counter_array, packets);
5767 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5769 msg = vat_json_array_add (msg_array);
5770 vat_json_init_object (msg);
5771 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5772 (u8 *) counter_type_to_str (i, 1));
5773 vat_json_object_add_int (msg, "is_combined", 1);
5774 counter_array = vat_json_object_add (msg, "data");
5775 vat_json_init_array (counter_array);
5776 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5778 c = vam->combined_interface_counters[i][j];
5779 counter = vat_json_array_add (counter_array);
5780 vat_json_init_object (counter);
5781 vat_json_object_add_uint (counter, "packets", c.packets);
5782 vat_json_object_add_uint (counter, "bytes", c.bytes);
5786 /* ip4 fib counters */
5787 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5788 vat_json_init_array (msg_array);
5789 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5791 msg = vat_json_array_add (msg_array);
5792 vat_json_init_object (msg);
5793 vat_json_object_add_uint (msg, "vrf_id",
5794 vam->ip4_fib_counters_vrf_id_by_index[i]);
5795 counter_array = vat_json_object_add (msg, "c");
5796 vat_json_init_array (counter_array);
5797 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
5799 counter = vat_json_array_add (counter_array);
5800 vat_json_init_object (counter);
5801 c4 = &vam->ip4_fib_counters[i][j];
5802 vat_json_object_add_ip4 (counter, "address", c4->address);
5803 vat_json_object_add_uint (counter, "address_length",
5804 c4->address_length);
5805 vat_json_object_add_uint (counter, "packets", c4->packets);
5806 vat_json_object_add_uint (counter, "bytes", c4->bytes);
5810 /* ip6 fib counters */
5811 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
5812 vat_json_init_array (msg_array);
5813 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
5815 msg = vat_json_array_add (msg_array);
5816 vat_json_init_object (msg);
5817 vat_json_object_add_uint (msg, "vrf_id",
5818 vam->ip6_fib_counters_vrf_id_by_index[i]);
5819 counter_array = vat_json_object_add (msg, "c");
5820 vat_json_init_array (counter_array);
5821 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
5823 counter = vat_json_array_add (counter_array);
5824 vat_json_init_object (counter);
5825 c6 = &vam->ip6_fib_counters[i][j];
5826 vat_json_object_add_ip6 (counter, "address", c6->address);
5827 vat_json_object_add_uint (counter, "address_length",
5828 c6->address_length);
5829 vat_json_object_add_uint (counter, "packets", c6->packets);
5830 vat_json_object_add_uint (counter, "bytes", c6->bytes);
5834 /* ip4 nbr counters */
5835 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
5836 vat_json_init_array (msg_array);
5837 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
5839 msg = vat_json_array_add (msg_array);
5840 vat_json_init_object (msg);
5841 vat_json_object_add_uint (msg, "sw_if_index", i);
5842 counter_array = vat_json_object_add (msg, "c");
5843 vat_json_init_array (counter_array);
5844 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
5846 counter = vat_json_array_add (counter_array);
5847 vat_json_init_object (counter);
5848 n4 = &vam->ip4_nbr_counters[i][j];
5849 vat_json_object_add_ip4 (counter, "address", n4->address);
5850 vat_json_object_add_uint (counter, "link-type", n4->linkt);
5851 vat_json_object_add_uint (counter, "packets", n4->packets);
5852 vat_json_object_add_uint (counter, "bytes", n4->bytes);
5856 /* ip6 nbr counters */
5857 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
5858 vat_json_init_array (msg_array);
5859 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
5861 msg = vat_json_array_add (msg_array);
5862 vat_json_init_object (msg);
5863 vat_json_object_add_uint (msg, "sw_if_index", i);
5864 counter_array = vat_json_object_add (msg, "c");
5865 vat_json_init_array (counter_array);
5866 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
5868 counter = vat_json_array_add (counter_array);
5869 vat_json_init_object (counter);
5870 n6 = &vam->ip6_nbr_counters[i][j];
5871 vat_json_object_add_ip6 (counter, "address", n6->address);
5872 vat_json_object_add_uint (counter, "packets", n6->packets);
5873 vat_json_object_add_uint (counter, "bytes", n6->bytes);
5877 vat_json_print (vam->ofp, &node);
5878 vat_json_free (&node);
5884 * Pass CLI buffers directly in the CLI_INBAND API message,
5885 * instead of an additional shared memory area.
5888 exec_inband (vat_main_t * vam)
5890 vl_api_cli_inband_t *mp;
5891 unformat_input_t *i = vam->input;
5894 if (vec_len (i->buffer) == 0)
5897 if (vam->exec_mode == 0 && unformat (i, "mode"))
5902 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5909 * In order for the CLI command to work, it
5910 * must be a vector ending in \n, not a C-string ending
5913 u32 len = vec_len (vam->input->buffer);
5914 M2 (CLI_INBAND, mp, len);
5915 clib_memcpy (mp->cmd, vam->input->buffer, len);
5916 mp->length = htonl (len);
5920 /* json responses may or may not include a useful reply... */
5921 if (vec_len (vam->cmd_reply))
5922 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5927 exec (vat_main_t * vam)
5929 return exec_inband (vam);
5933 api_create_loopback (vat_main_t * vam)
5935 unformat_input_t *i = vam->input;
5936 vl_api_create_loopback_t *mp;
5937 vl_api_create_loopback_instance_t *mp_lbi;
5940 u8 is_specified = 0;
5941 u32 user_instance = 0;
5944 memset (mac_address, 0, sizeof (mac_address));
5946 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5948 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5950 if (unformat (i, "instance %d", &user_instance))
5958 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5959 mp_lbi->is_specified = is_specified;
5961 mp_lbi->user_instance = htonl (user_instance);
5963 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5968 /* Construct the API message */
5969 M (CREATE_LOOPBACK, mp);
5971 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5980 api_delete_loopback (vat_main_t * vam)
5982 unformat_input_t *i = vam->input;
5983 vl_api_delete_loopback_t *mp;
5984 u32 sw_if_index = ~0;
5987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5989 if (unformat (i, "sw_if_index %d", &sw_if_index))
5995 if (sw_if_index == ~0)
5997 errmsg ("missing sw_if_index");
6001 /* Construct the API message */
6002 M (DELETE_LOOPBACK, mp);
6003 mp->sw_if_index = ntohl (sw_if_index);
6011 api_want_stats (vat_main_t * vam)
6013 unformat_input_t *i = vam->input;
6014 vl_api_want_stats_t *mp;
6018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6020 if (unformat (i, "enable"))
6022 else if (unformat (i, "disable"))
6030 errmsg ("missing enable|disable");
6035 mp->enable_disable = enable;
6043 api_want_interface_events (vat_main_t * vam)
6045 unformat_input_t *i = vam->input;
6046 vl_api_want_interface_events_t *mp;
6050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6052 if (unformat (i, "enable"))
6054 else if (unformat (i, "disable"))
6062 errmsg ("missing enable|disable");
6066 M (WANT_INTERFACE_EVENTS, mp);
6067 mp->enable_disable = enable;
6069 vam->interface_event_display = enable;
6077 /* Note: non-static, called once to set up the initial intfc table */
6079 api_sw_interface_dump (vat_main_t * vam)
6081 vl_api_sw_interface_dump_t *mp;
6082 vl_api_control_ping_t *mp_ping;
6084 name_sort_t *nses = 0, *ns;
6085 sw_interface_subif_t *sub = NULL;
6088 /* Toss the old name table */
6090 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6092 vec_add2 (nses, ns, 1);
6093 ns->name = (u8 *)(p->key);
6094 ns->value = (u32) p->value[0];
6098 hash_free (vam->sw_if_index_by_interface_name);
6100 vec_foreach (ns, nses) vec_free (ns->name);
6104 vec_foreach (sub, vam->sw_if_subif_table)
6106 vec_free (sub->interface_name);
6108 vec_free (vam->sw_if_subif_table);
6110 /* recreate the interface name hash table */
6111 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6113 /* Get list of ethernets */
6114 M (SW_INTERFACE_DUMP, mp);
6115 mp->name_filter_valid = 1;
6116 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
6119 /* and local / loopback interfaces */
6120 M (SW_INTERFACE_DUMP, mp);
6121 mp->name_filter_valid = 1;
6122 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
6125 /* and packet-generator interfaces */
6126 M (SW_INTERFACE_DUMP, mp);
6127 mp->name_filter_valid = 1;
6128 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
6131 /* and vxlan-gpe tunnel interfaces */
6132 M (SW_INTERFACE_DUMP, mp);
6133 mp->name_filter_valid = 1;
6134 strncpy ((char *) mp->name_filter, "vxlan_gpe",
6135 sizeof (mp->name_filter) - 1);
6138 /* and vxlan tunnel interfaces */
6139 M (SW_INTERFACE_DUMP, mp);
6140 mp->name_filter_valid = 1;
6141 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
6144 /* and geneve tunnel interfaces */
6145 M (SW_INTERFACE_DUMP, mp);
6146 mp->name_filter_valid = 1;
6147 strncpy ((char *) mp->name_filter, "geneve", sizeof (mp->name_filter) - 1);
6150 /* and host (af_packet) interfaces */
6151 M (SW_INTERFACE_DUMP, mp);
6152 mp->name_filter_valid = 1;
6153 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
6156 /* and l2tpv3 tunnel interfaces */
6157 M (SW_INTERFACE_DUMP, mp);
6158 mp->name_filter_valid = 1;
6159 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
6160 sizeof (mp->name_filter) - 1);
6163 /* and GRE tunnel interfaces */
6164 M (SW_INTERFACE_DUMP, mp);
6165 mp->name_filter_valid = 1;
6166 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
6169 /* and LISP-GPE interfaces */
6170 M (SW_INTERFACE_DUMP, mp);
6171 mp->name_filter_valid = 1;
6172 strncpy ((char *) mp->name_filter, "lisp_gpe",
6173 sizeof (mp->name_filter) - 1);
6176 /* and IPSEC tunnel interfaces */
6177 M (SW_INTERFACE_DUMP, mp);
6178 mp->name_filter_valid = 1;
6179 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
6182 /* Use a control ping for synchronization */
6183 MPING (CONTROL_PING, mp_ping);
6191 api_sw_interface_set_flags (vat_main_t * vam)
6193 unformat_input_t *i = vam->input;
6194 vl_api_sw_interface_set_flags_t *mp;
6196 u8 sw_if_index_set = 0;
6200 /* Parse args required to build the message */
6201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6203 if (unformat (i, "admin-up"))
6205 else if (unformat (i, "admin-down"))
6208 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6209 sw_if_index_set = 1;
6210 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6211 sw_if_index_set = 1;
6216 if (sw_if_index_set == 0)
6218 errmsg ("missing interface name or sw_if_index");
6222 /* Construct the API message */
6223 M (SW_INTERFACE_SET_FLAGS, mp);
6224 mp->sw_if_index = ntohl (sw_if_index);
6225 mp->admin_up_down = admin_up;
6230 /* Wait for a reply, return the good/bad news... */
6236 api_sw_interface_clear_stats (vat_main_t * vam)
6238 unformat_input_t *i = vam->input;
6239 vl_api_sw_interface_clear_stats_t *mp;
6241 u8 sw_if_index_set = 0;
6244 /* Parse args required to build the message */
6245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6247 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6248 sw_if_index_set = 1;
6249 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6250 sw_if_index_set = 1;
6255 /* Construct the API message */
6256 M (SW_INTERFACE_CLEAR_STATS, mp);
6258 if (sw_if_index_set == 1)
6259 mp->sw_if_index = ntohl (sw_if_index);
6261 mp->sw_if_index = ~0;
6266 /* Wait for a reply, return the good/bad news... */
6272 api_sw_interface_add_del_address (vat_main_t * vam)
6274 unformat_input_t *i = vam->input;
6275 vl_api_sw_interface_add_del_address_t *mp;
6277 u8 sw_if_index_set = 0;
6278 u8 is_add = 1, del_all = 0;
6279 u32 address_length = 0;
6280 u8 v4_address_set = 0;
6281 u8 v6_address_set = 0;
6282 ip4_address_t v4address;
6283 ip6_address_t v6address;
6286 /* Parse args required to build the message */
6287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6289 if (unformat (i, "del-all"))
6291 else if (unformat (i, "del"))
6294 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6295 sw_if_index_set = 1;
6296 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6297 sw_if_index_set = 1;
6298 else if (unformat (i, "%U/%d",
6299 unformat_ip4_address, &v4address, &address_length))
6301 else if (unformat (i, "%U/%d",
6302 unformat_ip6_address, &v6address, &address_length))
6308 if (sw_if_index_set == 0)
6310 errmsg ("missing interface name or sw_if_index");
6313 if (v4_address_set && v6_address_set)
6315 errmsg ("both v4 and v6 addresses set");
6318 if (!v4_address_set && !v6_address_set && !del_all)
6320 errmsg ("no addresses set");
6324 /* Construct the API message */
6325 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6327 mp->sw_if_index = ntohl (sw_if_index);
6328 mp->is_add = is_add;
6329 mp->del_all = del_all;
6333 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6337 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6339 mp->address_length = address_length;
6344 /* Wait for a reply, return good/bad news */
6350 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6352 unformat_input_t *i = vam->input;
6353 vl_api_sw_interface_set_mpls_enable_t *mp;
6355 u8 sw_if_index_set = 0;
6359 /* Parse args required to build the message */
6360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6362 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6363 sw_if_index_set = 1;
6364 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6365 sw_if_index_set = 1;
6366 else if (unformat (i, "disable"))
6368 else if (unformat (i, "dis"))
6374 if (sw_if_index_set == 0)
6376 errmsg ("missing interface name or sw_if_index");
6380 /* Construct the API message */
6381 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6383 mp->sw_if_index = ntohl (sw_if_index);
6384 mp->enable = enable;
6389 /* Wait for a reply... */
6395 api_sw_interface_set_table (vat_main_t * vam)
6397 unformat_input_t *i = vam->input;
6398 vl_api_sw_interface_set_table_t *mp;
6399 u32 sw_if_index, vrf_id = 0;
6400 u8 sw_if_index_set = 0;
6404 /* Parse args required to build the message */
6405 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6407 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6408 sw_if_index_set = 1;
6409 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6410 sw_if_index_set = 1;
6411 else if (unformat (i, "vrf %d", &vrf_id))
6413 else if (unformat (i, "ipv6"))
6419 if (sw_if_index_set == 0)
6421 errmsg ("missing interface name or sw_if_index");
6425 /* Construct the API message */
6426 M (SW_INTERFACE_SET_TABLE, mp);
6428 mp->sw_if_index = ntohl (sw_if_index);
6429 mp->is_ipv6 = is_ipv6;
6430 mp->vrf_id = ntohl (vrf_id);
6435 /* Wait for a reply... */
6440 static void vl_api_sw_interface_get_table_reply_t_handler
6441 (vl_api_sw_interface_get_table_reply_t * mp)
6443 vat_main_t *vam = &vat_main;
6445 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6447 vam->retval = ntohl (mp->retval);
6448 vam->result_ready = 1;
6452 static void vl_api_sw_interface_get_table_reply_t_handler_json
6453 (vl_api_sw_interface_get_table_reply_t * mp)
6455 vat_main_t *vam = &vat_main;
6456 vat_json_node_t node;
6458 vat_json_init_object (&node);
6459 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6460 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6462 vat_json_print (vam->ofp, &node);
6463 vat_json_free (&node);
6465 vam->retval = ntohl (mp->retval);
6466 vam->result_ready = 1;
6470 api_sw_interface_get_table (vat_main_t * vam)
6472 unformat_input_t *i = vam->input;
6473 vl_api_sw_interface_get_table_t *mp;
6475 u8 sw_if_index_set = 0;
6479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6481 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6482 sw_if_index_set = 1;
6483 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6484 sw_if_index_set = 1;
6485 else if (unformat (i, "ipv6"))
6491 if (sw_if_index_set == 0)
6493 errmsg ("missing interface name or sw_if_index");
6497 M (SW_INTERFACE_GET_TABLE, mp);
6498 mp->sw_if_index = htonl (sw_if_index);
6499 mp->is_ipv6 = is_ipv6;
6507 api_sw_interface_set_vpath (vat_main_t * vam)
6509 unformat_input_t *i = vam->input;
6510 vl_api_sw_interface_set_vpath_t *mp;
6511 u32 sw_if_index = 0;
6512 u8 sw_if_index_set = 0;
6516 /* Parse args required to build the message */
6517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6519 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6520 sw_if_index_set = 1;
6521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6522 sw_if_index_set = 1;
6523 else if (unformat (i, "enable"))
6525 else if (unformat (i, "disable"))
6531 if (sw_if_index_set == 0)
6533 errmsg ("missing interface name or sw_if_index");
6537 /* Construct the API message */
6538 M (SW_INTERFACE_SET_VPATH, mp);
6540 mp->sw_if_index = ntohl (sw_if_index);
6541 mp->enable = is_enable;
6546 /* Wait for a reply... */
6552 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6554 unformat_input_t *i = vam->input;
6555 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6556 u32 sw_if_index = 0;
6557 u8 sw_if_index_set = 0;
6562 /* Parse args required to build the message */
6563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6565 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6566 sw_if_index_set = 1;
6567 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6568 sw_if_index_set = 1;
6569 else if (unformat (i, "enable"))
6571 else if (unformat (i, "disable"))
6573 else if (unformat (i, "ip4"))
6575 else if (unformat (i, "ip6"))
6581 if (sw_if_index_set == 0)
6583 errmsg ("missing interface name or sw_if_index");
6587 /* Construct the API message */
6588 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6590 mp->sw_if_index = ntohl (sw_if_index);
6591 mp->enable = is_enable;
6592 mp->is_ipv6 = is_ipv6;
6597 /* Wait for a reply... */
6603 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6605 unformat_input_t *i = vam->input;
6606 vl_api_sw_interface_set_geneve_bypass_t *mp;
6607 u32 sw_if_index = 0;
6608 u8 sw_if_index_set = 0;
6613 /* Parse args required to build the message */
6614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6616 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6617 sw_if_index_set = 1;
6618 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6619 sw_if_index_set = 1;
6620 else if (unformat (i, "enable"))
6622 else if (unformat (i, "disable"))
6624 else if (unformat (i, "ip4"))
6626 else if (unformat (i, "ip6"))
6632 if (sw_if_index_set == 0)
6634 errmsg ("missing interface name or sw_if_index");
6638 /* Construct the API message */
6639 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6641 mp->sw_if_index = ntohl (sw_if_index);
6642 mp->enable = is_enable;
6643 mp->is_ipv6 = is_ipv6;
6648 /* Wait for a reply... */
6654 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6656 unformat_input_t *i = vam->input;
6657 vl_api_sw_interface_set_l2_xconnect_t *mp;
6659 u8 rx_sw_if_index_set = 0;
6661 u8 tx_sw_if_index_set = 0;
6665 /* Parse args required to build the message */
6666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6668 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6669 rx_sw_if_index_set = 1;
6670 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6671 tx_sw_if_index_set = 1;
6672 else if (unformat (i, "rx"))
6674 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6676 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6678 rx_sw_if_index_set = 1;
6683 else if (unformat (i, "tx"))
6685 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6687 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6689 tx_sw_if_index_set = 1;
6694 else if (unformat (i, "enable"))
6696 else if (unformat (i, "disable"))
6702 if (rx_sw_if_index_set == 0)
6704 errmsg ("missing rx interface name or rx_sw_if_index");
6708 if (enable && (tx_sw_if_index_set == 0))
6710 errmsg ("missing tx interface name or tx_sw_if_index");
6714 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6716 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6717 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6718 mp->enable = enable;
6726 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6728 unformat_input_t *i = vam->input;
6729 vl_api_sw_interface_set_l2_bridge_t *mp;
6731 u8 rx_sw_if_index_set = 0;
6739 /* Parse args required to build the message */
6740 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6742 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6743 rx_sw_if_index_set = 1;
6744 else if (unformat (i, "bd_id %d", &bd_id))
6748 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6749 rx_sw_if_index_set = 1;
6750 else if (unformat (i, "shg %d", &shg))
6752 else if (unformat (i, "bvi"))
6754 else if (unformat (i, "enable"))
6756 else if (unformat (i, "disable"))
6762 if (rx_sw_if_index_set == 0)
6764 errmsg ("missing rx interface name or sw_if_index");
6768 if (enable && (bd_id_set == 0))
6770 errmsg ("missing bridge domain");
6774 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6776 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6777 mp->bd_id = ntohl (bd_id);
6780 mp->enable = enable;
6788 api_bridge_domain_dump (vat_main_t * vam)
6790 unformat_input_t *i = vam->input;
6791 vl_api_bridge_domain_dump_t *mp;
6792 vl_api_control_ping_t *mp_ping;
6796 /* Parse args required to build the message */
6797 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6799 if (unformat (i, "bd_id %d", &bd_id))
6805 M (BRIDGE_DOMAIN_DUMP, mp);
6806 mp->bd_id = ntohl (bd_id);
6809 /* Use a control ping for synchronization */
6810 MPING (CONTROL_PING, mp_ping);
6818 api_bridge_domain_add_del (vat_main_t * vam)
6820 unformat_input_t *i = vam->input;
6821 vl_api_bridge_domain_add_del_t *mp;
6824 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6829 /* Parse args required to build the message */
6830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6832 if (unformat (i, "bd_id %d", &bd_id))
6834 else if (unformat (i, "flood %d", &flood))
6836 else if (unformat (i, "uu-flood %d", &uu_flood))
6838 else if (unformat (i, "forward %d", &forward))
6840 else if (unformat (i, "learn %d", &learn))
6842 else if (unformat (i, "arp-term %d", &arp_term))
6844 else if (unformat (i, "mac-age %d", &mac_age))
6846 else if (unformat (i, "bd-tag %s", &bd_tag))
6848 else if (unformat (i, "del"))
6851 flood = uu_flood = forward = learn = 0;
6859 errmsg ("missing bridge domain");
6866 errmsg ("mac age must be less than 256 ");
6871 if ((bd_tag) && (strlen ((char *) bd_tag) > 63))
6873 errmsg ("bd-tag cannot be longer than 63");
6878 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6880 mp->bd_id = ntohl (bd_id);
6882 mp->uu_flood = uu_flood;
6883 mp->forward = forward;
6885 mp->arp_term = arp_term;
6886 mp->is_add = is_add;
6887 mp->mac_age = (u8) mac_age;
6889 strcpy ((char *) mp->bd_tag, (char *) bd_tag);
6900 api_l2fib_flush_bd (vat_main_t * vam)
6902 unformat_input_t *i = vam->input;
6903 vl_api_l2fib_flush_bd_t *mp;
6907 /* Parse args required to build the message */
6908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6910 if (unformat (i, "bd_id %d", &bd_id));
6917 errmsg ("missing bridge domain");
6921 M (L2FIB_FLUSH_BD, mp);
6923 mp->bd_id = htonl (bd_id);
6931 api_l2fib_flush_int (vat_main_t * vam)
6933 unformat_input_t *i = vam->input;
6934 vl_api_l2fib_flush_int_t *mp;
6935 u32 sw_if_index = ~0;
6938 /* Parse args required to build the message */
6939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6941 if (unformat (i, "sw_if_index %d", &sw_if_index));
6943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6948 if (sw_if_index == ~0)
6950 errmsg ("missing interface name or sw_if_index");
6954 M (L2FIB_FLUSH_INT, mp);
6956 mp->sw_if_index = ntohl (sw_if_index);
6964 api_l2fib_add_del (vat_main_t * vam)
6966 unformat_input_t *i = vam->input;
6967 vl_api_l2fib_add_del_t *mp;
6973 u32 sw_if_index = ~0;
6974 u8 sw_if_index_set = 0;
6983 /* Parse args required to build the message */
6984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6986 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
6988 else if (unformat (i, "bd_id %d", &bd_id))
6990 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6991 sw_if_index_set = 1;
6992 else if (unformat (i, "sw_if"))
6994 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6997 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6998 sw_if_index_set = 1;
7003 else if (unformat (i, "static"))
7005 else if (unformat (i, "filter"))
7010 else if (unformat (i, "bvi"))
7015 else if (unformat (i, "del"))
7017 else if (unformat (i, "count %d", &count))
7025 errmsg ("missing mac address");
7031 errmsg ("missing bridge domain");
7035 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7037 errmsg ("missing interface name or sw_if_index");
7043 /* Turn on async mode */
7044 vam->async_mode = 1;
7045 vam->async_errors = 0;
7046 before = vat_time_now (vam);
7049 for (j = 0; j < count; j++)
7051 M (L2FIB_ADD_DEL, mp);
7054 mp->bd_id = ntohl (bd_id);
7055 mp->is_add = is_add;
7059 mp->sw_if_index = ntohl (sw_if_index);
7060 mp->static_mac = static_mac;
7061 mp->filter_mac = filter_mac;
7062 mp->bvi_mac = bvi_mac;
7064 increment_mac_address (&mac);
7071 vl_api_control_ping_t *mp_ping;
7074 /* Shut off async mode */
7075 vam->async_mode = 0;
7077 MPING (CONTROL_PING, mp_ping);
7080 timeout = vat_time_now (vam) + 1.0;
7081 while (vat_time_now (vam) < timeout)
7082 if (vam->result_ready == 1)
7087 if (vam->retval == -99)
7090 if (vam->async_errors > 0)
7092 errmsg ("%d asynchronous errors", vam->async_errors);
7095 vam->async_errors = 0;
7096 after = vat_time_now (vam);
7098 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7099 count, after - before, count / (after - before));
7105 /* Wait for a reply... */
7109 /* Return the good/bad news */
7110 return (vam->retval);
7114 api_bridge_domain_set_mac_age (vat_main_t * vam)
7116 unformat_input_t *i = vam->input;
7117 vl_api_bridge_domain_set_mac_age_t *mp;
7122 /* Parse args required to build the message */
7123 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7125 if (unformat (i, "bd_id %d", &bd_id));
7126 else if (unformat (i, "mac-age %d", &mac_age));
7133 errmsg ("missing bridge domain");
7139 errmsg ("mac age must be less than 256 ");
7143 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7145 mp->bd_id = htonl (bd_id);
7146 mp->mac_age = (u8) mac_age;
7154 api_l2_flags (vat_main_t * vam)
7156 unformat_input_t *i = vam->input;
7157 vl_api_l2_flags_t *mp;
7160 u8 sw_if_index_set = 0;
7164 /* Parse args required to build the message */
7165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7167 if (unformat (i, "sw_if_index %d", &sw_if_index))
7168 sw_if_index_set = 1;
7169 else if (unformat (i, "sw_if"))
7171 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7174 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7175 sw_if_index_set = 1;
7180 else if (unformat (i, "learn"))
7182 else if (unformat (i, "forward"))
7184 else if (unformat (i, "flood"))
7186 else if (unformat (i, "uu-flood"))
7187 flags |= L2_UU_FLOOD;
7188 else if (unformat (i, "arp-term"))
7189 flags |= L2_ARP_TERM;
7190 else if (unformat (i, "off"))
7192 else if (unformat (i, "disable"))
7198 if (sw_if_index_set == 0)
7200 errmsg ("missing interface name or sw_if_index");
7206 mp->sw_if_index = ntohl (sw_if_index);
7207 mp->feature_bitmap = ntohl (flags);
7208 mp->is_set = is_set;
7216 api_bridge_flags (vat_main_t * vam)
7218 unformat_input_t *i = vam->input;
7219 vl_api_bridge_flags_t *mp;
7226 /* Parse args required to build the message */
7227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7229 if (unformat (i, "bd_id %d", &bd_id))
7231 else if (unformat (i, "learn"))
7233 else if (unformat (i, "forward"))
7235 else if (unformat (i, "flood"))
7237 else if (unformat (i, "uu-flood"))
7238 flags |= L2_UU_FLOOD;
7239 else if (unformat (i, "arp-term"))
7240 flags |= L2_ARP_TERM;
7241 else if (unformat (i, "off"))
7243 else if (unformat (i, "disable"))
7251 errmsg ("missing bridge domain");
7255 M (BRIDGE_FLAGS, mp);
7257 mp->bd_id = ntohl (bd_id);
7258 mp->feature_bitmap = ntohl (flags);
7259 mp->is_set = is_set;
7267 api_bd_ip_mac_add_del (vat_main_t * vam)
7269 unformat_input_t *i = vam->input;
7270 vl_api_bd_ip_mac_add_del_t *mp;
7277 ip4_address_t v4addr;
7278 ip6_address_t v6addr;
7283 /* Parse args required to build the message */
7284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7286 if (unformat (i, "bd_id %d", &bd_id))
7290 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7294 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7299 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7303 else if (unformat (i, "del"))
7311 errmsg ("missing bridge domain");
7314 else if (ip_set == 0)
7316 errmsg ("missing IP address");
7319 else if (mac_set == 0)
7321 errmsg ("missing MAC address");
7325 M (BD_IP_MAC_ADD_DEL, mp);
7327 mp->bd_id = ntohl (bd_id);
7328 mp->is_ipv6 = is_ipv6;
7329 mp->is_add = is_add;
7331 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7333 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7334 clib_memcpy (mp->mac_address, macaddr, 6);
7341 api_tap_connect (vat_main_t * vam)
7343 unformat_input_t *i = vam->input;
7344 vl_api_tap_connect_t *mp;
7350 ip4_address_t ip4_address;
7352 int ip4_address_set = 0;
7353 ip6_address_t ip6_address;
7355 int ip6_address_set = 0;
7358 memset (mac_address, 0, sizeof (mac_address));
7360 /* Parse args required to build the message */
7361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7363 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7367 else if (unformat (i, "random-mac"))
7369 else if (unformat (i, "tapname %s", &tap_name))
7371 else if (unformat (i, "tag %s", &tag))
7373 else if (unformat (i, "address %U/%d",
7374 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7375 ip4_address_set = 1;
7376 else if (unformat (i, "address %U/%d",
7377 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7378 ip6_address_set = 1;
7385 errmsg ("missing tap name");
7388 if (vec_len (tap_name) > 63)
7390 errmsg ("tap name too long");
7393 vec_add1 (tap_name, 0);
7395 if (vec_len (tag) > 63)
7397 errmsg ("tag too long");
7401 /* Construct the API message */
7402 M (TAP_CONNECT, mp);
7404 mp->use_random_mac = random_mac;
7405 clib_memcpy (mp->mac_address, mac_address, 6);
7406 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7408 clib_memcpy (mp->tag, tag, vec_len (tag));
7410 if (ip4_address_set)
7412 mp->ip4_address_set = 1;
7413 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7414 mp->ip4_mask_width = ip4_mask_width;
7416 if (ip6_address_set)
7418 mp->ip6_address_set = 1;
7419 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7420 mp->ip6_mask_width = ip6_mask_width;
7423 vec_free (tap_name);
7429 /* Wait for a reply... */
7435 api_tap_modify (vat_main_t * vam)
7437 unformat_input_t *i = vam->input;
7438 vl_api_tap_modify_t *mp;
7443 u32 sw_if_index = ~0;
7444 u8 sw_if_index_set = 0;
7447 memset (mac_address, 0, sizeof (mac_address));
7449 /* Parse args required to build the message */
7450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7452 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7453 sw_if_index_set = 1;
7454 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7455 sw_if_index_set = 1;
7456 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7460 else if (unformat (i, "random-mac"))
7462 else if (unformat (i, "tapname %s", &tap_name))
7468 if (sw_if_index_set == 0)
7470 errmsg ("missing vpp interface name");
7475 errmsg ("missing tap name");
7478 if (vec_len (tap_name) > 63)
7480 errmsg ("tap name too long");
7482 vec_add1 (tap_name, 0);
7484 /* Construct the API message */
7487 mp->use_random_mac = random_mac;
7488 mp->sw_if_index = ntohl (sw_if_index);
7489 clib_memcpy (mp->mac_address, mac_address, 6);
7490 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7491 vec_free (tap_name);
7496 /* Wait for a reply... */
7502 api_tap_delete (vat_main_t * vam)
7504 unformat_input_t *i = vam->input;
7505 vl_api_tap_delete_t *mp;
7506 u32 sw_if_index = ~0;
7507 u8 sw_if_index_set = 0;
7510 /* Parse args required to build the message */
7511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7514 sw_if_index_set = 1;
7515 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7516 sw_if_index_set = 1;
7521 if (sw_if_index_set == 0)
7523 errmsg ("missing vpp interface name");
7527 /* Construct the API message */
7530 mp->sw_if_index = ntohl (sw_if_index);
7535 /* Wait for a reply... */
7541 api_ip_table_add_del (vat_main_t * vam)
7543 unformat_input_t *i = vam->input;
7544 vl_api_ip_table_add_del_t *mp;
7550 /* Parse args required to build the message */
7551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7553 if (unformat (i, "ipv6"))
7555 else if (unformat (i, "del"))
7557 else if (unformat (i, "add"))
7559 else if (unformat (i, "table %d", &table_id))
7563 clib_warning ("parse error '%U'", format_unformat_error, i);
7570 errmsg ("missing table-ID");
7574 /* Construct the API message */
7575 M (IP_TABLE_ADD_DEL, mp);
7577 mp->table_id = ntohl (table_id);
7578 mp->is_ipv6 = is_ipv6;
7579 mp->is_add = is_add;
7584 /* Wait for a reply... */
7591 api_ip_add_del_route (vat_main_t * vam)
7593 unformat_input_t *i = vam->input;
7594 vl_api_ip_add_del_route_t *mp;
7595 u32 sw_if_index = ~0, vrf_id = 0;
7597 u8 is_local = 0, is_drop = 0;
7598 u8 is_unreach = 0, is_prohibit = 0;
7599 u8 create_vrf_if_needed = 0;
7601 u32 next_hop_weight = 1;
7602 u8 is_multipath = 0;
7604 u8 address_length_set = 0;
7605 u32 next_hop_table_id = 0;
7606 u32 resolve_attempts = 0;
7607 u32 dst_address_length = 0;
7608 u8 next_hop_set = 0;
7609 ip4_address_t v4_dst_address, v4_next_hop_address;
7610 ip6_address_t v6_dst_address, v6_next_hop_address;
7614 u32 random_add_del = 0;
7615 u32 *random_vector = 0;
7617 u32 random_seed = 0xdeaddabe;
7618 u32 classify_table_index = ~0;
7620 u8 resolve_host = 0, resolve_attached = 0;
7621 mpls_label_t *next_hop_out_label_stack = NULL;
7622 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
7623 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
7625 /* Parse args required to build the message */
7626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7628 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7630 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7632 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
7637 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
7642 else if (unformat (i, "/%d", &dst_address_length))
7644 address_length_set = 1;
7647 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
7648 &v4_next_hop_address))
7652 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
7653 &v6_next_hop_address))
7657 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
7659 else if (unformat (i, "weight %d", &next_hop_weight))
7661 else if (unformat (i, "drop"))
7665 else if (unformat (i, "null-send-unreach"))
7669 else if (unformat (i, "null-send-prohibit"))
7673 else if (unformat (i, "local"))
7677 else if (unformat (i, "classify %d", &classify_table_index))
7681 else if (unformat (i, "del"))
7683 else if (unformat (i, "add"))
7685 else if (unformat (i, "resolve-via-host"))
7687 else if (unformat (i, "resolve-via-attached"))
7688 resolve_attached = 1;
7689 else if (unformat (i, "multipath"))
7691 else if (unformat (i, "vrf %d", &vrf_id))
7693 else if (unformat (i, "create-vrf"))
7694 create_vrf_if_needed = 1;
7695 else if (unformat (i, "count %d", &count))
7697 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
7699 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7701 else if (unformat (i, "out-label %d", &next_hop_out_label))
7702 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
7703 else if (unformat (i, "via-label %d", &next_hop_via_label))
7705 else if (unformat (i, "random"))
7707 else if (unformat (i, "seed %d", &random_seed))
7711 clib_warning ("parse error '%U'", format_unformat_error, i);
7716 if (!next_hop_set && !is_drop && !is_local &&
7717 !is_classify && !is_unreach && !is_prohibit &&
7718 MPLS_LABEL_INVALID == next_hop_via_label)
7721 ("next hop / local / drop / unreach / prohibit / classify not set");
7725 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
7727 errmsg ("next hop and next-hop via label set");
7730 if (address_set == 0)
7732 errmsg ("missing addresses");
7736 if (address_length_set == 0)
7738 errmsg ("missing address length");
7742 /* Generate a pile of unique, random routes */
7745 u32 this_random_address;
7746 random_hash = hash_create (count, sizeof (uword));
7748 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
7749 for (j = 0; j <= count; j++)
7753 this_random_address = random_u32 (&random_seed);
7754 this_random_address =
7755 clib_host_to_net_u32 (this_random_address);
7757 while (hash_get (random_hash, this_random_address));
7758 vec_add1 (random_vector, this_random_address);
7759 hash_set (random_hash, this_random_address, 1);
7761 hash_free (random_hash);
7762 v4_dst_address.as_u32 = random_vector[0];
7767 /* Turn on async mode */
7768 vam->async_mode = 1;
7769 vam->async_errors = 0;
7770 before = vat_time_now (vam);
7773 for (j = 0; j < count; j++)
7775 /* Construct the API message */
7776 M2 (IP_ADD_DEL_ROUTE, mp,
7777 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
7779 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7780 mp->table_id = ntohl (vrf_id);
7781 mp->create_vrf_if_needed = create_vrf_if_needed;
7783 mp->is_add = is_add;
7784 mp->is_drop = is_drop;
7785 mp->is_unreach = is_unreach;
7786 mp->is_prohibit = is_prohibit;
7787 mp->is_ipv6 = is_ipv6;
7788 mp->is_local = is_local;
7789 mp->is_classify = is_classify;
7790 mp->is_multipath = is_multipath;
7791 mp->is_resolve_host = resolve_host;
7792 mp->is_resolve_attached = resolve_attached;
7793 mp->next_hop_weight = next_hop_weight;
7794 mp->dst_address_length = dst_address_length;
7795 mp->next_hop_table_id = ntohl (next_hop_table_id);
7796 mp->classify_table_index = ntohl (classify_table_index);
7797 mp->next_hop_via_label = ntohl (next_hop_via_label);
7798 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
7799 if (0 != mp->next_hop_n_out_labels)
7801 memcpy (mp->next_hop_out_label_stack,
7802 next_hop_out_label_stack,
7803 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
7804 vec_free (next_hop_out_label_stack);
7809 clib_memcpy (mp->dst_address, &v6_dst_address,
7810 sizeof (v6_dst_address));
7812 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
7813 sizeof (v6_next_hop_address));
7814 increment_v6_address (&v6_dst_address);
7818 clib_memcpy (mp->dst_address, &v4_dst_address,
7819 sizeof (v4_dst_address));
7821 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
7822 sizeof (v4_next_hop_address));
7824 v4_dst_address.as_u32 = random_vector[j + 1];
7826 increment_v4_address (&v4_dst_address);
7830 /* If we receive SIGTERM, stop now... */
7835 /* When testing multiple add/del ops, use a control-ping to sync */
7838 vl_api_control_ping_t *mp_ping;
7842 /* Shut off async mode */
7843 vam->async_mode = 0;
7845 MPING (CONTROL_PING, mp_ping);
7848 timeout = vat_time_now (vam) + 1.0;
7849 while (vat_time_now (vam) < timeout)
7850 if (vam->result_ready == 1)
7855 if (vam->retval == -99)
7858 if (vam->async_errors > 0)
7860 errmsg ("%d asynchronous errors", vam->async_errors);
7863 vam->async_errors = 0;
7864 after = vat_time_now (vam);
7866 /* slim chance, but we might have eaten SIGTERM on the first iteration */
7870 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7871 count, after - before, count / (after - before));
7877 /* Wait for a reply... */
7882 /* Return the good/bad news */
7883 return (vam->retval);
7887 api_ip_mroute_add_del (vat_main_t * vam)
7889 unformat_input_t *i = vam->input;
7890 vl_api_ip_mroute_add_del_t *mp;
7891 u32 sw_if_index = ~0, vrf_id = 0;
7894 u8 create_vrf_if_needed = 0;
7897 u32 grp_address_length = 0;
7898 ip4_address_t v4_grp_address, v4_src_address;
7899 ip6_address_t v6_grp_address, v6_src_address;
7900 mfib_itf_flags_t iflags = 0;
7901 mfib_entry_flags_t eflags = 0;
7904 /* Parse args required to build the message */
7905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7907 if (unformat (i, "sw_if_index %d", &sw_if_index))
7909 else if (unformat (i, "%U %U",
7910 unformat_ip4_address, &v4_src_address,
7911 unformat_ip4_address, &v4_grp_address))
7913 grp_address_length = 64;
7917 else if (unformat (i, "%U %U",
7918 unformat_ip6_address, &v6_src_address,
7919 unformat_ip6_address, &v6_grp_address))
7921 grp_address_length = 256;
7925 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
7927 memset (&v4_src_address, 0, sizeof (v4_src_address));
7928 grp_address_length = 32;
7932 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
7934 memset (&v6_src_address, 0, sizeof (v6_src_address));
7935 grp_address_length = 128;
7939 else if (unformat (i, "/%d", &grp_address_length))
7941 else if (unformat (i, "local"))
7945 else if (unformat (i, "del"))
7947 else if (unformat (i, "add"))
7949 else if (unformat (i, "vrf %d", &vrf_id))
7951 else if (unformat (i, "create-vrf"))
7952 create_vrf_if_needed = 1;
7953 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
7955 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
7959 clib_warning ("parse error '%U'", format_unformat_error, i);
7964 if (address_set == 0)
7966 errmsg ("missing addresses\n");
7970 /* Construct the API message */
7971 M (IP_MROUTE_ADD_DEL, mp);
7973 mp->next_hop_sw_if_index = ntohl (sw_if_index);
7974 mp->table_id = ntohl (vrf_id);
7975 mp->create_vrf_if_needed = create_vrf_if_needed;
7977 mp->is_add = is_add;
7978 mp->is_ipv6 = is_ipv6;
7979 mp->is_local = is_local;
7980 mp->itf_flags = ntohl (iflags);
7981 mp->entry_flags = ntohl (eflags);
7982 mp->grp_address_length = grp_address_length;
7983 mp->grp_address_length = ntohs (mp->grp_address_length);
7987 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
7988 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
7992 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
7993 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
7999 /* Wait for a reply... */
8005 api_mpls_table_add_del (vat_main_t * vam)
8007 unformat_input_t *i = vam->input;
8008 vl_api_mpls_table_add_del_t *mp;
8013 /* Parse args required to build the message */
8014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8016 if (unformat (i, "table %d", &table_id))
8018 else if (unformat (i, "del"))
8020 else if (unformat (i, "add"))
8024 clib_warning ("parse error '%U'", format_unformat_error, i);
8031 errmsg ("missing table-ID");
8035 /* Construct the API message */
8036 M (MPLS_TABLE_ADD_DEL, mp);
8038 mp->mt_table_id = ntohl (table_id);
8039 mp->mt_is_add = is_add;
8044 /* Wait for a reply... */
8051 api_mpls_route_add_del (vat_main_t * vam)
8053 unformat_input_t *i = vam->input;
8054 vl_api_mpls_route_add_del_t *mp;
8055 u32 sw_if_index = ~0, table_id = 0;
8056 u8 create_table_if_needed = 0;
8058 u32 next_hop_weight = 1;
8059 u8 is_multipath = 0;
8060 u32 next_hop_table_id = 0;
8061 u8 next_hop_set = 0;
8062 ip4_address_t v4_next_hop_address = {
8065 ip6_address_t v6_next_hop_address = { {0} };
8069 u32 classify_table_index = ~0;
8071 u8 resolve_host = 0, resolve_attached = 0;
8072 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8073 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8074 mpls_label_t *next_hop_out_label_stack = NULL;
8075 mpls_label_t local_label = MPLS_LABEL_INVALID;
8077 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8079 /* Parse args required to build the message */
8080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8082 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8084 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8086 else if (unformat (i, "%d", &local_label))
8088 else if (unformat (i, "eos"))
8090 else if (unformat (i, "non-eos"))
8092 else if (unformat (i, "via %U", unformat_ip4_address,
8093 &v4_next_hop_address))
8096 next_hop_proto = DPO_PROTO_IP4;
8098 else if (unformat (i, "via %U", unformat_ip6_address,
8099 &v6_next_hop_address))
8102 next_hop_proto = DPO_PROTO_IP6;
8104 else if (unformat (i, "weight %d", &next_hop_weight))
8106 else if (unformat (i, "create-table"))
8107 create_table_if_needed = 1;
8108 else if (unformat (i, "classify %d", &classify_table_index))
8112 else if (unformat (i, "del"))
8114 else if (unformat (i, "add"))
8116 else if (unformat (i, "resolve-via-host"))
8118 else if (unformat (i, "resolve-via-attached"))
8119 resolve_attached = 1;
8120 else if (unformat (i, "multipath"))
8122 else if (unformat (i, "count %d", &count))
8124 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8127 next_hop_proto = DPO_PROTO_IP4;
8129 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8132 next_hop_proto = DPO_PROTO_IP6;
8134 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8136 else if (unformat (i, "via-label %d", &next_hop_via_label))
8138 else if (unformat (i, "out-label %d", &next_hop_out_label))
8139 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8142 clib_warning ("parse error '%U'", format_unformat_error, i);
8147 if (!next_hop_set && !is_classify)
8149 errmsg ("next hop / classify not set");
8153 if (MPLS_LABEL_INVALID == local_label)
8155 errmsg ("missing label");
8161 /* Turn on async mode */
8162 vam->async_mode = 1;
8163 vam->async_errors = 0;
8164 before = vat_time_now (vam);
8167 for (j = 0; j < count; j++)
8169 /* Construct the API message */
8170 M2 (MPLS_ROUTE_ADD_DEL, mp,
8171 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8173 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8174 mp->mr_table_id = ntohl (table_id);
8175 mp->mr_create_table_if_needed = create_table_if_needed;
8177 mp->mr_is_add = is_add;
8178 mp->mr_next_hop_proto = next_hop_proto;
8179 mp->mr_is_classify = is_classify;
8180 mp->mr_is_multipath = is_multipath;
8181 mp->mr_is_resolve_host = resolve_host;
8182 mp->mr_is_resolve_attached = resolve_attached;
8183 mp->mr_next_hop_weight = next_hop_weight;
8184 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8185 mp->mr_classify_table_index = ntohl (classify_table_index);
8186 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8187 mp->mr_label = ntohl (local_label);
8188 mp->mr_eos = is_eos;
8190 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8191 if (0 != mp->mr_next_hop_n_out_labels)
8193 memcpy (mp->mr_next_hop_out_label_stack,
8194 next_hop_out_label_stack,
8195 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8196 vec_free (next_hop_out_label_stack);
8201 if (DPO_PROTO_IP4 == next_hop_proto)
8203 clib_memcpy (mp->mr_next_hop,
8204 &v4_next_hop_address,
8205 sizeof (v4_next_hop_address));
8207 else if (DPO_PROTO_IP6 == next_hop_proto)
8210 clib_memcpy (mp->mr_next_hop,
8211 &v6_next_hop_address,
8212 sizeof (v6_next_hop_address));
8219 /* If we receive SIGTERM, stop now... */
8224 /* When testing multiple add/del ops, use a control-ping to sync */
8227 vl_api_control_ping_t *mp_ping;
8231 /* Shut off async mode */
8232 vam->async_mode = 0;
8234 MPING (CONTROL_PING, mp_ping);
8237 timeout = vat_time_now (vam) + 1.0;
8238 while (vat_time_now (vam) < timeout)
8239 if (vam->result_ready == 1)
8244 if (vam->retval == -99)
8247 if (vam->async_errors > 0)
8249 errmsg ("%d asynchronous errors", vam->async_errors);
8252 vam->async_errors = 0;
8253 after = vat_time_now (vam);
8255 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8259 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8260 count, after - before, count / (after - before));
8266 /* Wait for a reply... */
8271 /* Return the good/bad news */
8272 return (vam->retval);
8276 api_mpls_ip_bind_unbind (vat_main_t * vam)
8278 unformat_input_t *i = vam->input;
8279 vl_api_mpls_ip_bind_unbind_t *mp;
8280 u32 ip_table_id = 0;
8281 u8 create_table_if_needed = 0;
8284 ip4_address_t v4_address;
8285 ip6_address_t v6_address;
8288 mpls_label_t local_label = MPLS_LABEL_INVALID;
8291 /* Parse args required to build the message */
8292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8294 if (unformat (i, "%U/%d", unformat_ip4_address,
8295 &v4_address, &address_length))
8300 else if (unformat (i, "%U/%d", unformat_ip6_address,
8301 &v6_address, &address_length))
8306 else if (unformat (i, "%d", &local_label))
8308 else if (unformat (i, "create-table"))
8309 create_table_if_needed = 1;
8310 else if (unformat (i, "table-id %d", &ip_table_id))
8312 else if (unformat (i, "unbind"))
8314 else if (unformat (i, "bind"))
8318 clib_warning ("parse error '%U'", format_unformat_error, i);
8325 errmsg ("IP addres not set");
8329 if (MPLS_LABEL_INVALID == local_label)
8331 errmsg ("missing label");
8335 /* Construct the API message */
8336 M (MPLS_IP_BIND_UNBIND, mp);
8338 mp->mb_create_table_if_needed = create_table_if_needed;
8339 mp->mb_is_bind = is_bind;
8340 mp->mb_is_ip4 = is_ip4;
8341 mp->mb_ip_table_id = ntohl (ip_table_id);
8342 mp->mb_mpls_table_id = 0;
8343 mp->mb_label = ntohl (local_label);
8344 mp->mb_address_length = address_length;
8347 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8349 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8354 /* Wait for a reply... */
8360 api_proxy_arp_add_del (vat_main_t * vam)
8362 unformat_input_t *i = vam->input;
8363 vl_api_proxy_arp_add_del_t *mp;
8366 ip4_address_t lo, hi;
8370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8372 if (unformat (i, "vrf %d", &vrf_id))
8374 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8375 unformat_ip4_address, &hi))
8377 else if (unformat (i, "del"))
8381 clib_warning ("parse error '%U'", format_unformat_error, i);
8388 errmsg ("address range not set");
8392 M (PROXY_ARP_ADD_DEL, mp);
8394 mp->vrf_id = ntohl (vrf_id);
8395 mp->is_add = is_add;
8396 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8397 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8405 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8407 unformat_input_t *i = vam->input;
8408 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8411 u8 sw_if_index_set = 0;
8414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8416 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8417 sw_if_index_set = 1;
8418 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8419 sw_if_index_set = 1;
8420 else if (unformat (i, "enable"))
8422 else if (unformat (i, "disable"))
8426 clib_warning ("parse error '%U'", format_unformat_error, i);
8431 if (sw_if_index_set == 0)
8433 errmsg ("missing interface name or sw_if_index");
8437 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8439 mp->sw_if_index = ntohl (sw_if_index);
8440 mp->enable_disable = enable;
8448 api_mpls_tunnel_add_del (vat_main_t * vam)
8450 unformat_input_t *i = vam->input;
8451 vl_api_mpls_tunnel_add_del_t *mp;
8455 u32 sw_if_index = ~0;
8456 u32 next_hop_sw_if_index = ~0;
8457 u32 next_hop_proto_is_ip4 = 1;
8459 u32 next_hop_table_id = 0;
8460 ip4_address_t v4_next_hop_address = {
8463 ip6_address_t v6_next_hop_address = { {0} };
8464 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
8467 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8469 if (unformat (i, "add"))
8471 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8473 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
8475 else if (unformat (i, "via %U",
8476 unformat_ip4_address, &v4_next_hop_address))
8478 next_hop_proto_is_ip4 = 1;
8480 else if (unformat (i, "via %U",
8481 unformat_ip6_address, &v6_next_hop_address))
8483 next_hop_proto_is_ip4 = 0;
8485 else if (unformat (i, "l2-only"))
8487 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8489 else if (unformat (i, "out-label %d", &next_hop_out_label))
8490 vec_add1 (labels, ntohl (next_hop_out_label));
8493 clib_warning ("parse error '%U'", format_unformat_error, i);
8498 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
8500 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
8501 mp->mt_sw_if_index = ntohl (sw_if_index);
8502 mp->mt_is_add = is_add;
8503 mp->mt_l2_only = l2_only;
8504 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
8505 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
8507 mp->mt_next_hop_n_out_labels = vec_len (labels);
8509 if (0 != mp->mt_next_hop_n_out_labels)
8511 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
8512 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
8516 if (next_hop_proto_is_ip4)
8518 clib_memcpy (mp->mt_next_hop,
8519 &v4_next_hop_address, sizeof (v4_next_hop_address));
8523 clib_memcpy (mp->mt_next_hop,
8524 &v6_next_hop_address, sizeof (v6_next_hop_address));
8533 api_sw_interface_set_unnumbered (vat_main_t * vam)
8535 unformat_input_t *i = vam->input;
8536 vl_api_sw_interface_set_unnumbered_t *mp;
8538 u32 unnum_sw_index = ~0;
8540 u8 sw_if_index_set = 0;
8543 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8545 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8546 sw_if_index_set = 1;
8547 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8548 sw_if_index_set = 1;
8549 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8551 else if (unformat (i, "del"))
8555 clib_warning ("parse error '%U'", format_unformat_error, i);
8560 if (sw_if_index_set == 0)
8562 errmsg ("missing interface name or sw_if_index");
8566 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8568 mp->sw_if_index = ntohl (sw_if_index);
8569 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8570 mp->is_add = is_add;
8578 api_ip_neighbor_add_del (vat_main_t * vam)
8580 unformat_input_t *i = vam->input;
8581 vl_api_ip_neighbor_add_del_t *mp;
8583 u8 sw_if_index_set = 0;
8586 u8 is_no_fib_entry = 0;
8589 u8 v4_address_set = 0;
8590 u8 v6_address_set = 0;
8591 ip4_address_t v4address;
8592 ip6_address_t v6address;
8595 memset (mac_address, 0, sizeof (mac_address));
8597 /* Parse args required to build the message */
8598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8600 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8604 else if (unformat (i, "del"))
8607 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8608 sw_if_index_set = 1;
8609 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8610 sw_if_index_set = 1;
8611 else if (unformat (i, "is_static"))
8613 else if (unformat (i, "no-fib-entry"))
8614 is_no_fib_entry = 1;
8615 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
8617 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
8621 clib_warning ("parse error '%U'", format_unformat_error, i);
8626 if (sw_if_index_set == 0)
8628 errmsg ("missing interface name or sw_if_index");
8631 if (v4_address_set && v6_address_set)
8633 errmsg ("both v4 and v6 addresses set");
8636 if (!v4_address_set && !v6_address_set)
8638 errmsg ("no address set");
8642 /* Construct the API message */
8643 M (IP_NEIGHBOR_ADD_DEL, mp);
8645 mp->sw_if_index = ntohl (sw_if_index);
8646 mp->is_add = is_add;
8647 mp->is_static = is_static;
8648 mp->is_no_adj_fib = is_no_fib_entry;
8650 clib_memcpy (mp->mac_address, mac_address, 6);
8654 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
8658 /* mp->is_ipv6 = 0; via memset in M macro above */
8659 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
8665 /* Wait for a reply, return good/bad news */
8671 api_reset_vrf (vat_main_t * vam)
8673 unformat_input_t *i = vam->input;
8674 vl_api_reset_vrf_t *mp;
8680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8682 if (unformat (i, "vrf %d", &vrf_id))
8684 else if (unformat (i, "ipv6"))
8688 clib_warning ("parse error '%U'", format_unformat_error, i);
8693 if (vrf_id_set == 0)
8695 errmsg ("missing vrf id");
8701 mp->vrf_id = ntohl (vrf_id);
8702 mp->is_ipv6 = is_ipv6;
8710 api_create_vlan_subif (vat_main_t * vam)
8712 unformat_input_t *i = vam->input;
8713 vl_api_create_vlan_subif_t *mp;
8715 u8 sw_if_index_set = 0;
8720 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8722 if (unformat (i, "sw_if_index %d", &sw_if_index))
8723 sw_if_index_set = 1;
8725 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8726 sw_if_index_set = 1;
8727 else if (unformat (i, "vlan %d", &vlan_id))
8731 clib_warning ("parse error '%U'", format_unformat_error, i);
8736 if (sw_if_index_set == 0)
8738 errmsg ("missing interface name or sw_if_index");
8742 if (vlan_id_set == 0)
8744 errmsg ("missing vlan_id");
8747 M (CREATE_VLAN_SUBIF, mp);
8749 mp->sw_if_index = ntohl (sw_if_index);
8750 mp->vlan_id = ntohl (vlan_id);
8757 #define foreach_create_subif_bit \
8764 _(outer_vlan_id_any) \
8765 _(inner_vlan_id_any)
8768 api_create_subif (vat_main_t * vam)
8770 unformat_input_t *i = vam->input;
8771 vl_api_create_subif_t *mp;
8773 u8 sw_if_index_set = 0;
8780 u32 exact_match = 0;
8781 u32 default_sub = 0;
8782 u32 outer_vlan_id_any = 0;
8783 u32 inner_vlan_id_any = 0;
8785 u16 outer_vlan_id = 0;
8786 u16 inner_vlan_id = 0;
8789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8791 if (unformat (i, "sw_if_index %d", &sw_if_index))
8792 sw_if_index_set = 1;
8794 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8795 sw_if_index_set = 1;
8796 else if (unformat (i, "sub_id %d", &sub_id))
8798 else if (unformat (i, "outer_vlan_id %d", &tmp))
8799 outer_vlan_id = tmp;
8800 else if (unformat (i, "inner_vlan_id %d", &tmp))
8801 inner_vlan_id = tmp;
8803 #define _(a) else if (unformat (i, #a)) a = 1 ;
8804 foreach_create_subif_bit
8808 clib_warning ("parse error '%U'", format_unformat_error, i);
8813 if (sw_if_index_set == 0)
8815 errmsg ("missing interface name or sw_if_index");
8819 if (sub_id_set == 0)
8821 errmsg ("missing sub_id");
8824 M (CREATE_SUBIF, mp);
8826 mp->sw_if_index = ntohl (sw_if_index);
8827 mp->sub_id = ntohl (sub_id);
8829 #define _(a) mp->a = a;
8830 foreach_create_subif_bit;
8833 mp->outer_vlan_id = ntohs (outer_vlan_id);
8834 mp->inner_vlan_id = ntohs (inner_vlan_id);
8842 api_oam_add_del (vat_main_t * vam)
8844 unformat_input_t *i = vam->input;
8845 vl_api_oam_add_del_t *mp;
8848 ip4_address_t src, dst;
8853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8855 if (unformat (i, "vrf %d", &vrf_id))
8857 else if (unformat (i, "src %U", unformat_ip4_address, &src))
8859 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
8861 else if (unformat (i, "del"))
8865 clib_warning ("parse error '%U'", format_unformat_error, i);
8872 errmsg ("missing src addr");
8878 errmsg ("missing dst addr");
8882 M (OAM_ADD_DEL, mp);
8884 mp->vrf_id = ntohl (vrf_id);
8885 mp->is_add = is_add;
8886 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
8887 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
8895 api_reset_fib (vat_main_t * vam)
8897 unformat_input_t *i = vam->input;
8898 vl_api_reset_fib_t *mp;
8904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8906 if (unformat (i, "vrf %d", &vrf_id))
8908 else if (unformat (i, "ipv6"))
8912 clib_warning ("parse error '%U'", format_unformat_error, i);
8917 if (vrf_id_set == 0)
8919 errmsg ("missing vrf id");
8925 mp->vrf_id = ntohl (vrf_id);
8926 mp->is_ipv6 = is_ipv6;
8934 api_dhcp_proxy_config (vat_main_t * vam)
8936 unformat_input_t *i = vam->input;
8937 vl_api_dhcp_proxy_config_t *mp;
8939 u32 server_vrf_id = 0;
8941 u8 v4_address_set = 0;
8942 u8 v6_address_set = 0;
8943 ip4_address_t v4address;
8944 ip6_address_t v6address;
8945 u8 v4_src_address_set = 0;
8946 u8 v6_src_address_set = 0;
8947 ip4_address_t v4srcaddress;
8948 ip6_address_t v6srcaddress;
8951 /* Parse args required to build the message */
8952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8954 if (unformat (i, "del"))
8956 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
8958 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
8960 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
8962 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
8964 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
8965 v4_src_address_set = 1;
8966 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
8967 v6_src_address_set = 1;
8972 if (v4_address_set && v6_address_set)
8974 errmsg ("both v4 and v6 server addresses set");
8977 if (!v4_address_set && !v6_address_set)
8979 errmsg ("no server addresses set");
8983 if (v4_src_address_set && v6_src_address_set)
8985 errmsg ("both v4 and v6 src addresses set");
8988 if (!v4_src_address_set && !v6_src_address_set)
8990 errmsg ("no src addresses set");
8994 if (!(v4_src_address_set && v4_address_set) &&
8995 !(v6_src_address_set && v6_address_set))
8997 errmsg ("no matching server and src addresses set");
9001 /* Construct the API message */
9002 M (DHCP_PROXY_CONFIG, mp);
9004 mp->is_add = is_add;
9005 mp->rx_vrf_id = ntohl (rx_vrf_id);
9006 mp->server_vrf_id = ntohl (server_vrf_id);
9010 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9011 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9015 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9016 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9022 /* Wait for a reply, return good/bad news */
9027 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9028 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9031 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9033 vat_main_t *vam = &vat_main;
9034 u32 i, count = mp->count;
9035 vl_api_dhcp_server_t *s;
9039 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9040 ntohl (mp->rx_vrf_id),
9041 format_ip6_address, mp->dhcp_src_address,
9042 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9045 "RX Table-ID %d, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
9046 ntohl (mp->rx_vrf_id),
9047 format_ip4_address, mp->dhcp_src_address,
9048 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9050 for (i = 0; i < count; i++)
9052 s = &mp->servers[i];
9056 " Server Table-ID %d, Server Address %U",
9057 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9060 " Server Table-ID %d, Server Address %U",
9061 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9065 static void vl_api_dhcp_proxy_details_t_handler_json
9066 (vl_api_dhcp_proxy_details_t * mp)
9068 vat_main_t *vam = &vat_main;
9069 vat_json_node_t *node = NULL;
9070 u32 i, count = mp->count;
9072 struct in6_addr ip6;
9073 vl_api_dhcp_server_t *s;
9075 if (VAT_JSON_ARRAY != vam->json_tree.type)
9077 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9078 vat_json_init_array (&vam->json_tree);
9080 node = vat_json_array_add (&vam->json_tree);
9082 vat_json_init_object (node);
9083 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9084 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9085 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9089 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9090 vat_json_object_add_ip6 (node, "src_address", ip6);
9094 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9095 vat_json_object_add_ip4 (node, "src_address", ip4);
9098 for (i = 0; i < count; i++)
9100 s = &mp->servers[i];
9102 vat_json_object_add_uint (node, "server-table-id",
9103 ntohl (s->server_vrf_id));
9107 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9108 vat_json_object_add_ip4 (node, "src_address", ip4);
9112 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9113 vat_json_object_add_ip6 (node, "server_address", ip6);
9119 api_dhcp_proxy_dump (vat_main_t * vam)
9121 unformat_input_t *i = vam->input;
9122 vl_api_control_ping_t *mp_ping;
9123 vl_api_dhcp_proxy_dump_t *mp;
9127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9129 if (unformat (i, "ipv6"))
9133 clib_warning ("parse error '%U'", format_unformat_error, i);
9138 M (DHCP_PROXY_DUMP, mp);
9140 mp->is_ip6 = is_ipv6;
9143 /* Use a control ping for synchronization */
9144 MPING (CONTROL_PING, mp_ping);
9152 api_dhcp_proxy_set_vss (vat_main_t * vam)
9154 unformat_input_t *i = vam->input;
9155 vl_api_dhcp_proxy_set_vss_t *mp;
9166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9168 if (unformat (i, "tbl_id %d", &tbl_id))
9170 if (unformat (i, "fib_id %d", &fib_id))
9172 if (unformat (i, "oui %d", &oui))
9174 else if (unformat (i, "ipv6"))
9176 else if (unformat (i, "del"))
9180 clib_warning ("parse error '%U'", format_unformat_error, i);
9185 if (tbl_id_set == 0)
9187 errmsg ("missing tbl id");
9191 if (fib_id_set == 0)
9193 errmsg ("missing fib id");
9198 errmsg ("missing oui");
9202 M (DHCP_PROXY_SET_VSS, mp);
9203 mp->tbl_id = ntohl (tbl_id);
9204 mp->fib_id = ntohl (fib_id);
9205 mp->oui = ntohl (oui);
9206 mp->is_ipv6 = is_ipv6;
9207 mp->is_add = is_add;
9215 api_dhcp_client_config (vat_main_t * vam)
9217 unformat_input_t *i = vam->input;
9218 vl_api_dhcp_client_config_t *mp;
9220 u8 sw_if_index_set = 0;
9223 u8 disable_event = 0;
9226 /* Parse args required to build the message */
9227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9229 if (unformat (i, "del"))
9232 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9233 sw_if_index_set = 1;
9234 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9235 sw_if_index_set = 1;
9236 else if (unformat (i, "hostname %s", &hostname))
9238 else if (unformat (i, "disable_event"))
9244 if (sw_if_index_set == 0)
9246 errmsg ("missing interface name or sw_if_index");
9250 if (vec_len (hostname) > 63)
9252 errmsg ("hostname too long");
9254 vec_add1 (hostname, 0);
9256 /* Construct the API message */
9257 M (DHCP_CLIENT_CONFIG, mp);
9259 mp->sw_if_index = htonl (sw_if_index);
9260 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9261 vec_free (hostname);
9262 mp->is_add = is_add;
9263 mp->want_dhcp_event = disable_event ? 0 : 1;
9264 mp->pid = htonl (getpid ());
9269 /* Wait for a reply, return good/bad news */
9275 api_set_ip_flow_hash (vat_main_t * vam)
9277 unformat_input_t *i = vam->input;
9278 vl_api_set_ip_flow_hash_t *mp;
9290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9292 if (unformat (i, "vrf %d", &vrf_id))
9294 else if (unformat (i, "ipv6"))
9296 else if (unformat (i, "src"))
9298 else if (unformat (i, "dst"))
9300 else if (unformat (i, "sport"))
9302 else if (unformat (i, "dport"))
9304 else if (unformat (i, "proto"))
9306 else if (unformat (i, "reverse"))
9311 clib_warning ("parse error '%U'", format_unformat_error, i);
9316 if (vrf_id_set == 0)
9318 errmsg ("missing vrf id");
9322 M (SET_IP_FLOW_HASH, mp);
9328 mp->reverse = reverse;
9329 mp->vrf_id = ntohl (vrf_id);
9330 mp->is_ipv6 = is_ipv6;
9338 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9340 unformat_input_t *i = vam->input;
9341 vl_api_sw_interface_ip6_enable_disable_t *mp;
9343 u8 sw_if_index_set = 0;
9347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9349 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9350 sw_if_index_set = 1;
9351 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9352 sw_if_index_set = 1;
9353 else if (unformat (i, "enable"))
9355 else if (unformat (i, "disable"))
9359 clib_warning ("parse error '%U'", format_unformat_error, i);
9364 if (sw_if_index_set == 0)
9366 errmsg ("missing interface name or sw_if_index");
9370 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9372 mp->sw_if_index = ntohl (sw_if_index);
9373 mp->enable = enable;
9381 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9383 unformat_input_t *i = vam->input;
9384 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9386 u8 sw_if_index_set = 0;
9387 u8 v6_address_set = 0;
9388 ip6_address_t v6address;
9391 /* Parse args required to build the message */
9392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9394 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9395 sw_if_index_set = 1;
9396 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9397 sw_if_index_set = 1;
9398 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9404 if (sw_if_index_set == 0)
9406 errmsg ("missing interface name or sw_if_index");
9409 if (!v6_address_set)
9411 errmsg ("no address set");
9415 /* Construct the API message */
9416 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9418 mp->sw_if_index = ntohl (sw_if_index);
9419 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9424 /* Wait for a reply, return good/bad news */
9430 api_ip6nd_proxy_add_del (vat_main_t * vam)
9432 unformat_input_t *i = vam->input;
9433 vl_api_ip6nd_proxy_add_del_t *mp;
9434 u32 sw_if_index = ~0;
9435 u8 v6_address_set = 0;
9436 ip6_address_t v6address;
9440 /* Parse args required to build the message */
9441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9443 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9445 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9447 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9449 if (unformat (i, "del"))
9453 clib_warning ("parse error '%U'", format_unformat_error, i);
9458 if (sw_if_index == ~0)
9460 errmsg ("missing interface name or sw_if_index");
9463 if (!v6_address_set)
9465 errmsg ("no address set");
9469 /* Construct the API message */
9470 M (IP6ND_PROXY_ADD_DEL, mp);
9472 mp->is_del = is_del;
9473 mp->sw_if_index = ntohl (sw_if_index);
9474 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9479 /* Wait for a reply, return good/bad news */
9485 api_ip6nd_proxy_dump (vat_main_t * vam)
9487 vl_api_ip6nd_proxy_dump_t *mp;
9488 vl_api_control_ping_t *mp_ping;
9491 M (IP6ND_PROXY_DUMP, mp);
9495 /* Use a control ping for synchronization */
9496 MPING (CONTROL_PING, mp_ping);
9503 static void vl_api_ip6nd_proxy_details_t_handler
9504 (vl_api_ip6nd_proxy_details_t * mp)
9506 vat_main_t *vam = &vat_main;
9508 print (vam->ofp, "host %U sw_if_index %d",
9509 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
9512 static void vl_api_ip6nd_proxy_details_t_handler_json
9513 (vl_api_ip6nd_proxy_details_t * mp)
9515 vat_main_t *vam = &vat_main;
9516 struct in6_addr ip6;
9517 vat_json_node_t *node = NULL;
9519 if (VAT_JSON_ARRAY != vam->json_tree.type)
9521 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9522 vat_json_init_array (&vam->json_tree);
9524 node = vat_json_array_add (&vam->json_tree);
9526 vat_json_init_object (node);
9527 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9529 clib_memcpy (&ip6, mp->address, sizeof (ip6));
9530 vat_json_object_add_ip6 (node, "host", ip6);
9534 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9536 unformat_input_t *i = vam->input;
9537 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9539 u8 sw_if_index_set = 0;
9540 u32 address_length = 0;
9541 u8 v6_address_set = 0;
9542 ip6_address_t v6address;
9544 u8 no_advertise = 0;
9546 u8 no_autoconfig = 0;
9549 u32 val_lifetime = 0;
9550 u32 pref_lifetime = 0;
9553 /* Parse args required to build the message */
9554 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9556 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9557 sw_if_index_set = 1;
9558 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9559 sw_if_index_set = 1;
9560 else if (unformat (i, "%U/%d",
9561 unformat_ip6_address, &v6address, &address_length))
9563 else if (unformat (i, "val_life %d", &val_lifetime))
9565 else if (unformat (i, "pref_life %d", &pref_lifetime))
9567 else if (unformat (i, "def"))
9569 else if (unformat (i, "noadv"))
9571 else if (unformat (i, "offl"))
9573 else if (unformat (i, "noauto"))
9575 else if (unformat (i, "nolink"))
9577 else if (unformat (i, "isno"))
9581 clib_warning ("parse error '%U'", format_unformat_error, i);
9586 if (sw_if_index_set == 0)
9588 errmsg ("missing interface name or sw_if_index");
9591 if (!v6_address_set)
9593 errmsg ("no address set");
9597 /* Construct the API message */
9598 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9600 mp->sw_if_index = ntohl (sw_if_index);
9601 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9602 mp->address_length = address_length;
9603 mp->use_default = use_default;
9604 mp->no_advertise = no_advertise;
9605 mp->off_link = off_link;
9606 mp->no_autoconfig = no_autoconfig;
9607 mp->no_onlink = no_onlink;
9609 mp->val_lifetime = ntohl (val_lifetime);
9610 mp->pref_lifetime = ntohl (pref_lifetime);
9615 /* Wait for a reply, return good/bad news */
9621 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9623 unformat_input_t *i = vam->input;
9624 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9626 u8 sw_if_index_set = 0;
9631 u8 send_unicast = 0;
9634 u8 default_router = 0;
9635 u32 max_interval = 0;
9636 u32 min_interval = 0;
9638 u32 initial_count = 0;
9639 u32 initial_interval = 0;
9643 /* Parse args required to build the message */
9644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9646 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9647 sw_if_index_set = 1;
9648 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9649 sw_if_index_set = 1;
9650 else if (unformat (i, "maxint %d", &max_interval))
9652 else if (unformat (i, "minint %d", &min_interval))
9654 else if (unformat (i, "life %d", &lifetime))
9656 else if (unformat (i, "count %d", &initial_count))
9658 else if (unformat (i, "interval %d", &initial_interval))
9660 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9662 else if (unformat (i, "managed"))
9664 else if (unformat (i, "other"))
9666 else if (unformat (i, "ll"))
9668 else if (unformat (i, "send"))
9670 else if (unformat (i, "cease"))
9672 else if (unformat (i, "isno"))
9674 else if (unformat (i, "def"))
9678 clib_warning ("parse error '%U'", format_unformat_error, i);
9683 if (sw_if_index_set == 0)
9685 errmsg ("missing interface name or sw_if_index");
9689 /* Construct the API message */
9690 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9692 mp->sw_if_index = ntohl (sw_if_index);
9693 mp->max_interval = ntohl (max_interval);
9694 mp->min_interval = ntohl (min_interval);
9695 mp->lifetime = ntohl (lifetime);
9696 mp->initial_count = ntohl (initial_count);
9697 mp->initial_interval = ntohl (initial_interval);
9698 mp->suppress = suppress;
9699 mp->managed = managed;
9701 mp->ll_option = ll_option;
9702 mp->send_unicast = send_unicast;
9705 mp->default_router = default_router;
9710 /* Wait for a reply, return good/bad news */
9716 api_set_arp_neighbor_limit (vat_main_t * vam)
9718 unformat_input_t *i = vam->input;
9719 vl_api_set_arp_neighbor_limit_t *mp;
9725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9727 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9729 else if (unformat (i, "ipv6"))
9733 clib_warning ("parse error '%U'", format_unformat_error, i);
9740 errmsg ("missing limit value");
9744 M (SET_ARP_NEIGHBOR_LIMIT, mp);
9746 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
9747 mp->is_ipv6 = is_ipv6;
9755 api_l2_patch_add_del (vat_main_t * vam)
9757 unformat_input_t *i = vam->input;
9758 vl_api_l2_patch_add_del_t *mp;
9760 u8 rx_sw_if_index_set = 0;
9762 u8 tx_sw_if_index_set = 0;
9766 /* Parse args required to build the message */
9767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9769 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9770 rx_sw_if_index_set = 1;
9771 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9772 tx_sw_if_index_set = 1;
9773 else if (unformat (i, "rx"))
9775 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9777 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9779 rx_sw_if_index_set = 1;
9784 else if (unformat (i, "tx"))
9786 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9788 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9790 tx_sw_if_index_set = 1;
9795 else if (unformat (i, "del"))
9801 if (rx_sw_if_index_set == 0)
9803 errmsg ("missing rx interface name or rx_sw_if_index");
9807 if (tx_sw_if_index_set == 0)
9809 errmsg ("missing tx interface name or tx_sw_if_index");
9813 M (L2_PATCH_ADD_DEL, mp);
9815 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9816 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9817 mp->is_add = is_add;
9825 u8 localsid_addr[16];
9834 api_sr_localsid_add_del (vat_main_t * vam)
9836 unformat_input_t *i = vam->input;
9837 vl_api_sr_localsid_add_del_t *mp;
9840 ip6_address_t localsid;
9844 u32 fib_table = ~(u32) 0;
9845 ip6_address_t next_hop;
9847 bool nexthop_set = 0;
9851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9853 if (unformat (i, "del"))
9855 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9856 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
9858 else if (unformat (i, "behavior %u", &behavior));
9859 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9860 else if (unformat (i, "fib-table %u", &fib_table));
9861 else if (unformat (i, "end.psp %u", &behavior));
9866 M (SR_LOCALSID_ADD_DEL, mp);
9868 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
9870 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
9871 mp->behavior = behavior;
9872 mp->sw_if_index = ntohl (sw_if_index);
9873 mp->fib_table = ntohl (fib_table);
9874 mp->end_psp = end_psp;
9875 mp->is_del = is_del;
9883 api_ioam_enable (vat_main_t * vam)
9885 unformat_input_t *input = vam->input;
9886 vl_api_ioam_enable_t *mp;
9888 int has_trace_option = 0;
9889 int has_pot_option = 0;
9890 int has_seqno_option = 0;
9891 int has_analyse_option = 0;
9894 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9896 if (unformat (input, "trace"))
9897 has_trace_option = 1;
9898 else if (unformat (input, "pot"))
9900 else if (unformat (input, "seqno"))
9901 has_seqno_option = 1;
9902 else if (unformat (input, "analyse"))
9903 has_analyse_option = 1;
9907 M (IOAM_ENABLE, mp);
9908 mp->id = htons (id);
9909 mp->seqno = has_seqno_option;
9910 mp->analyse = has_analyse_option;
9911 mp->pot_enable = has_pot_option;
9912 mp->trace_enable = has_trace_option;
9921 api_ioam_disable (vat_main_t * vam)
9923 vl_api_ioam_disable_t *mp;
9926 M (IOAM_DISABLE, mp);
9932 #define foreach_tcp_proto_field \
9936 #define foreach_udp_proto_field \
9940 #define foreach_ip4_proto_field \
9952 u16 src_port, dst_port;
9955 #if VPP_API_TEST_BUILTIN == 0
9957 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9959 u8 **maskp = va_arg (*args, u8 **);
9961 u8 found_something = 0;
9964 #define _(a) u8 a=0;
9965 foreach_tcp_proto_field;
9968 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9971 #define _(a) else if (unformat (input, #a)) a=1;
9972 foreach_tcp_proto_field
9978 #define _(a) found_something += a;
9979 foreach_tcp_proto_field;
9982 if (found_something == 0)
9985 vec_validate (mask, sizeof (*tcp) - 1);
9987 tcp = (tcp_header_t *) mask;
9989 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
9990 foreach_tcp_proto_field;
9998 unformat_udp_mask (unformat_input_t * input, va_list * args)
10000 u8 **maskp = va_arg (*args, u8 **);
10002 u8 found_something = 0;
10005 #define _(a) u8 a=0;
10006 foreach_udp_proto_field;
10009 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10012 #define _(a) else if (unformat (input, #a)) a=1;
10013 foreach_udp_proto_field
10019 #define _(a) found_something += a;
10020 foreach_udp_proto_field;
10023 if (found_something == 0)
10026 vec_validate (mask, sizeof (*udp) - 1);
10028 udp = (udp_header_t *) mask;
10030 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10031 foreach_udp_proto_field;
10039 unformat_l4_mask (unformat_input_t * input, va_list * args)
10041 u8 **maskp = va_arg (*args, u8 **);
10042 u16 src_port = 0, dst_port = 0;
10043 tcpudp_header_t *tcpudp;
10045 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10047 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10049 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10051 else if (unformat (input, "src_port"))
10053 else if (unformat (input, "dst_port"))
10059 if (!src_port && !dst_port)
10063 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10065 tcpudp = (tcpudp_header_t *) mask;
10066 tcpudp->src_port = src_port;
10067 tcpudp->dst_port = dst_port;
10075 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10077 u8 **maskp = va_arg (*args, u8 **);
10079 u8 found_something = 0;
10082 #define _(a) u8 a=0;
10083 foreach_ip4_proto_field;
10089 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10091 if (unformat (input, "version"))
10093 else if (unformat (input, "hdr_length"))
10095 else if (unformat (input, "src"))
10097 else if (unformat (input, "dst"))
10099 else if (unformat (input, "proto"))
10102 #define _(a) else if (unformat (input, #a)) a=1;
10103 foreach_ip4_proto_field
10109 #define _(a) found_something += a;
10110 foreach_ip4_proto_field;
10113 if (found_something == 0)
10116 vec_validate (mask, sizeof (*ip) - 1);
10118 ip = (ip4_header_t *) mask;
10120 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10121 foreach_ip4_proto_field;
10124 ip->ip_version_and_header_length = 0;
10127 ip->ip_version_and_header_length |= 0xF0;
10130 ip->ip_version_and_header_length |= 0x0F;
10136 #define foreach_ip6_proto_field \
10139 _(payload_length) \
10144 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10146 u8 **maskp = va_arg (*args, u8 **);
10148 u8 found_something = 0;
10150 u32 ip_version_traffic_class_and_flow_label;
10152 #define _(a) u8 a=0;
10153 foreach_ip6_proto_field;
10156 u8 traffic_class = 0;
10159 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10161 if (unformat (input, "version"))
10163 else if (unformat (input, "traffic-class"))
10165 else if (unformat (input, "flow-label"))
10167 else if (unformat (input, "src"))
10169 else if (unformat (input, "dst"))
10171 else if (unformat (input, "proto"))
10174 #define _(a) else if (unformat (input, #a)) a=1;
10175 foreach_ip6_proto_field
10181 #define _(a) found_something += a;
10182 foreach_ip6_proto_field;
10185 if (found_something == 0)
10188 vec_validate (mask, sizeof (*ip) - 1);
10190 ip = (ip6_header_t *) mask;
10192 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10193 foreach_ip6_proto_field;
10196 ip_version_traffic_class_and_flow_label = 0;
10199 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10202 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10205 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10207 ip->ip_version_traffic_class_and_flow_label =
10208 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10215 unformat_l3_mask (unformat_input_t * input, va_list * args)
10217 u8 **maskp = va_arg (*args, u8 **);
10219 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10221 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10223 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10232 unformat_l2_mask (unformat_input_t * input, va_list * args)
10234 u8 **maskp = va_arg (*args, u8 **);
10241 u8 ignore_tag1 = 0;
10242 u8 ignore_tag2 = 0;
10249 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10251 if (unformat (input, "src"))
10253 else if (unformat (input, "dst"))
10255 else if (unformat (input, "proto"))
10257 else if (unformat (input, "tag1"))
10259 else if (unformat (input, "tag2"))
10261 else if (unformat (input, "ignore-tag1"))
10263 else if (unformat (input, "ignore-tag2"))
10265 else if (unformat (input, "cos1"))
10267 else if (unformat (input, "cos2"))
10269 else if (unformat (input, "dot1q"))
10271 else if (unformat (input, "dot1ad"))
10276 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10277 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10280 if (tag1 || ignore_tag1 || cos1 || dot1q)
10282 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10285 vec_validate (mask, len - 1);
10288 memset (mask, 0xff, 6);
10291 memset (mask + 6, 0xff, 6);
10293 if (tag2 || dot1ad)
10295 /* inner vlan tag */
10304 mask[21] = mask[20] = 0xff;
10325 mask[16] = mask[17] = 0xff;
10335 mask[12] = mask[13] = 0xff;
10342 unformat_classify_mask (unformat_input_t * input, va_list * args)
10344 u8 **maskp = va_arg (*args, u8 **);
10345 u32 *skipp = va_arg (*args, u32 *);
10346 u32 *matchp = va_arg (*args, u32 *);
10354 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10356 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10358 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10360 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10362 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10376 if (mask || l2 || l3 || l4)
10378 if (l2 || l3 || l4)
10380 /* "With a free Ethernet header in every package" */
10382 vec_validate (l2, 13);
10386 vec_append (mask, l3);
10391 vec_append (mask, l4);
10396 /* Scan forward looking for the first significant mask octet */
10397 for (i = 0; i < vec_len (mask); i++)
10401 /* compute (skip, match) params */
10402 *skipp = i / sizeof (u32x4);
10403 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10405 /* Pad mask to an even multiple of the vector size */
10406 while (vec_len (mask) % sizeof (u32x4))
10407 vec_add1 (mask, 0);
10409 match = vec_len (mask) / sizeof (u32x4);
10411 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10413 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10414 if (*tmp || *(tmp + 1))
10419 clib_warning ("BUG: match 0");
10421 _vec_len (mask) = match * sizeof (u32x4);
10431 #endif /* VPP_API_TEST_BUILTIN */
10433 #define foreach_l2_next \
10435 _(ethernet, ETHERNET_INPUT) \
10436 _(ip4, IP4_INPUT) \
10440 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10442 u32 *miss_next_indexp = va_arg (*args, u32 *);
10443 u32 next_index = 0;
10447 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10451 if (unformat (input, "%d", &tmp))
10460 *miss_next_indexp = next_index;
10464 #define foreach_ip_next \
10467 _(rewrite, REWRITE)
10470 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10472 u32 *miss_next_indexp = va_arg (*args, u32 *);
10473 u32 next_index = 0;
10477 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10481 if (unformat (input, "%d", &tmp))
10490 *miss_next_indexp = next_index;
10494 #define foreach_acl_next \
10498 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10500 u32 *miss_next_indexp = va_arg (*args, u32 *);
10501 u32 next_index = 0;
10505 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10509 if (unformat (input, "permit"))
10514 else if (unformat (input, "%d", &tmp))
10523 *miss_next_indexp = next_index;
10528 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10530 u32 *r = va_arg (*args, u32 *);
10532 if (unformat (input, "conform-color"))
10533 *r = POLICE_CONFORM;
10534 else if (unformat (input, "exceed-color"))
10535 *r = POLICE_EXCEED;
10543 api_classify_add_del_table (vat_main_t * vam)
10545 unformat_input_t *i = vam->input;
10546 vl_api_classify_add_del_table_t *mp;
10553 u32 table_index = ~0;
10554 u32 next_table_index = ~0;
10555 u32 miss_next_index = ~0;
10556 u32 memory_size = 32 << 20;
10558 u32 current_data_flag = 0;
10559 int current_data_offset = 0;
10562 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10564 if (unformat (i, "del"))
10566 else if (unformat (i, "del-chain"))
10571 else if (unformat (i, "buckets %d", &nbuckets))
10573 else if (unformat (i, "memory_size %d", &memory_size))
10575 else if (unformat (i, "skip %d", &skip))
10577 else if (unformat (i, "match %d", &match))
10579 else if (unformat (i, "table %d", &table_index))
10581 else if (unformat (i, "mask %U", unformat_classify_mask,
10582 &mask, &skip, &match))
10584 else if (unformat (i, "next-table %d", &next_table_index))
10586 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10589 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10592 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10595 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10597 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10603 if (is_add && mask == 0)
10605 errmsg ("Mask required");
10609 if (is_add && skip == ~0)
10611 errmsg ("skip count required");
10615 if (is_add && match == ~0)
10617 errmsg ("match count required");
10621 if (!is_add && table_index == ~0)
10623 errmsg ("table index required for delete");
10627 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10629 mp->is_add = is_add;
10630 mp->del_chain = del_chain;
10631 mp->table_index = ntohl (table_index);
10632 mp->nbuckets = ntohl (nbuckets);
10633 mp->memory_size = ntohl (memory_size);
10634 mp->skip_n_vectors = ntohl (skip);
10635 mp->match_n_vectors = ntohl (match);
10636 mp->next_table_index = ntohl (next_table_index);
10637 mp->miss_next_index = ntohl (miss_next_index);
10638 mp->current_data_flag = ntohl (current_data_flag);
10639 mp->current_data_offset = ntohl (current_data_offset);
10640 clib_memcpy (mp->mask, mask, vec_len (mask));
10649 #if VPP_API_TEST_BUILTIN == 0
10651 unformat_l4_match (unformat_input_t * input, va_list * args)
10653 u8 **matchp = va_arg (*args, u8 **);
10655 u8 *proto_header = 0;
10661 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10663 if (unformat (input, "src_port %d", &src_port))
10665 else if (unformat (input, "dst_port %d", &dst_port))
10671 h.src_port = clib_host_to_net_u16 (src_port);
10672 h.dst_port = clib_host_to_net_u16 (dst_port);
10673 vec_validate (proto_header, sizeof (h) - 1);
10674 memcpy (proto_header, &h, sizeof (h));
10676 *matchp = proto_header;
10682 unformat_ip4_match (unformat_input_t * input, va_list * args)
10684 u8 **matchp = va_arg (*args, u8 **);
10689 int hdr_length = 0;
10690 u32 hdr_length_val;
10691 int src = 0, dst = 0;
10692 ip4_address_t src_val, dst_val;
10699 int fragment_id = 0;
10700 u32 fragment_id_val;
10706 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10708 if (unformat (input, "version %d", &version_val))
10710 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10712 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10714 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10716 else if (unformat (input, "proto %d", &proto_val))
10718 else if (unformat (input, "tos %d", &tos_val))
10720 else if (unformat (input, "length %d", &length_val))
10722 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10724 else if (unformat (input, "ttl %d", &ttl_val))
10726 else if (unformat (input, "checksum %d", &checksum_val))
10732 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10733 + ttl + checksum == 0)
10737 * Aligned because we use the real comparison functions
10739 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10741 ip = (ip4_header_t *) match;
10743 /* These are realistically matched in practice */
10745 ip->src_address.as_u32 = src_val.as_u32;
10748 ip->dst_address.as_u32 = dst_val.as_u32;
10751 ip->protocol = proto_val;
10754 /* These are not, but they're included for completeness */
10756 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10759 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10765 ip->length = clib_host_to_net_u16 (length_val);
10771 ip->checksum = clib_host_to_net_u16 (checksum_val);
10778 unformat_ip6_match (unformat_input_t * input, va_list * args)
10780 u8 **matchp = va_arg (*args, u8 **);
10785 u8 traffic_class = 0;
10786 u32 traffic_class_val = 0;
10789 int src = 0, dst = 0;
10790 ip6_address_t src_val, dst_val;
10793 int payload_length = 0;
10794 u32 payload_length_val;
10797 u32 ip_version_traffic_class_and_flow_label;
10799 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10801 if (unformat (input, "version %d", &version_val))
10803 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10805 else if (unformat (input, "flow_label %d", &flow_label_val))
10807 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10809 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10811 else if (unformat (input, "proto %d", &proto_val))
10813 else if (unformat (input, "payload_length %d", &payload_length_val))
10814 payload_length = 1;
10815 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10821 if (version + traffic_class + flow_label + src + dst + proto +
10822 payload_length + hop_limit == 0)
10826 * Aligned because we use the real comparison functions
10828 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10830 ip = (ip6_header_t *) match;
10833 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10836 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10839 ip->protocol = proto_val;
10841 ip_version_traffic_class_and_flow_label = 0;
10844 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10847 ip_version_traffic_class_and_flow_label |=
10848 (traffic_class_val & 0xFF) << 20;
10851 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10853 ip->ip_version_traffic_class_and_flow_label =
10854 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10856 if (payload_length)
10857 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10860 ip->hop_limit = hop_limit_val;
10867 unformat_l3_match (unformat_input_t * input, va_list * args)
10869 u8 **matchp = va_arg (*args, u8 **);
10871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10873 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10875 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10884 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10886 u8 *tagp = va_arg (*args, u8 *);
10889 if (unformat (input, "%d", &tag))
10891 tagp[0] = (tag >> 8) & 0x0F;
10892 tagp[1] = tag & 0xFF;
10900 unformat_l2_match (unformat_input_t * input, va_list * args)
10902 u8 **matchp = va_arg (*args, u8 **);
10915 u8 ignore_tag1 = 0;
10916 u8 ignore_tag2 = 0;
10922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10924 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10927 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10929 else if (unformat (input, "proto %U",
10930 unformat_ethernet_type_host_byte_order, &proto_val))
10932 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10934 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10936 else if (unformat (input, "ignore-tag1"))
10938 else if (unformat (input, "ignore-tag2"))
10940 else if (unformat (input, "cos1 %d", &cos1_val))
10942 else if (unformat (input, "cos2 %d", &cos2_val))
10947 if ((src + dst + proto + tag1 + tag2 +
10948 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10951 if (tag1 || ignore_tag1 || cos1)
10953 if (tag2 || ignore_tag2 || cos2)
10956 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10959 clib_memcpy (match, dst_val, 6);
10962 clib_memcpy (match + 6, src_val, 6);
10966 /* inner vlan tag */
10967 match[19] = tag2_val[1];
10968 match[18] = tag2_val[0];
10970 match[18] |= (cos2_val & 0x7) << 5;
10973 match[21] = proto_val & 0xff;
10974 match[20] = proto_val >> 8;
10978 match[15] = tag1_val[1];
10979 match[14] = tag1_val[0];
10982 match[14] |= (cos1_val & 0x7) << 5;
10988 match[15] = tag1_val[1];
10989 match[14] = tag1_val[0];
10992 match[17] = proto_val & 0xff;
10993 match[16] = proto_val >> 8;
10996 match[14] |= (cos1_val & 0x7) << 5;
11002 match[18] |= (cos2_val & 0x7) << 5;
11004 match[14] |= (cos1_val & 0x7) << 5;
11007 match[13] = proto_val & 0xff;
11008 match[12] = proto_val >> 8;
11017 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11019 u8 **matchp = va_arg (*args, u8 **);
11020 u32 skip_n_vectors = va_arg (*args, u32);
11021 u32 match_n_vectors = va_arg (*args, u32);
11028 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11030 if (unformat (input, "hex %U", unformat_hex_string, &match))
11032 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11034 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11036 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11050 if (match || l2 || l3 || l4)
11052 if (l2 || l3 || l4)
11054 /* "Win a free Ethernet header in every packet" */
11056 vec_validate_aligned (l2, 13, sizeof (u32x4));
11060 vec_append_aligned (match, l3, sizeof (u32x4));
11065 vec_append_aligned (match, l4, sizeof (u32x4));
11070 /* Make sure the vector is big enough even if key is all 0's */
11071 vec_validate_aligned
11072 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11075 /* Set size, include skipped vectors */
11076 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11087 api_classify_add_del_session (vat_main_t * vam)
11089 unformat_input_t *i = vam->input;
11090 vl_api_classify_add_del_session_t *mp;
11092 u32 table_index = ~0;
11093 u32 hit_next_index = ~0;
11094 u32 opaque_index = ~0;
11097 u32 skip_n_vectors = 0;
11098 u32 match_n_vectors = 0;
11104 * Warning: you have to supply skip_n and match_n
11105 * because the API client cant simply look at the classify
11109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11111 if (unformat (i, "del"))
11113 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11116 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11119 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11122 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11124 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11126 else if (unformat (i, "opaque-index %d", &opaque_index))
11128 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11130 else if (unformat (i, "match_n %d", &match_n_vectors))
11132 else if (unformat (i, "match %U", api_unformat_classify_match,
11133 &match, skip_n_vectors, match_n_vectors))
11135 else if (unformat (i, "advance %d", &advance))
11137 else if (unformat (i, "table-index %d", &table_index))
11139 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11141 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11143 else if (unformat (i, "action %d", &action))
11145 else if (unformat (i, "metadata %d", &metadata))
11151 if (table_index == ~0)
11153 errmsg ("Table index required");
11157 if (is_add && match == 0)
11159 errmsg ("Match value required");
11163 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11165 mp->is_add = is_add;
11166 mp->table_index = ntohl (table_index);
11167 mp->hit_next_index = ntohl (hit_next_index);
11168 mp->opaque_index = ntohl (opaque_index);
11169 mp->advance = ntohl (advance);
11170 mp->action = action;
11171 mp->metadata = ntohl (metadata);
11172 clib_memcpy (mp->match, match, vec_len (match));
11181 api_classify_set_interface_ip_table (vat_main_t * vam)
11183 unformat_input_t *i = vam->input;
11184 vl_api_classify_set_interface_ip_table_t *mp;
11186 int sw_if_index_set;
11187 u32 table_index = ~0;
11191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11193 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11194 sw_if_index_set = 1;
11195 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11196 sw_if_index_set = 1;
11197 else if (unformat (i, "table %d", &table_index))
11201 clib_warning ("parse error '%U'", format_unformat_error, i);
11206 if (sw_if_index_set == 0)
11208 errmsg ("missing interface name or sw_if_index");
11213 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11215 mp->sw_if_index = ntohl (sw_if_index);
11216 mp->table_index = ntohl (table_index);
11217 mp->is_ipv6 = is_ipv6;
11225 api_classify_set_interface_l2_tables (vat_main_t * vam)
11227 unformat_input_t *i = vam->input;
11228 vl_api_classify_set_interface_l2_tables_t *mp;
11230 int sw_if_index_set;
11231 u32 ip4_table_index = ~0;
11232 u32 ip6_table_index = ~0;
11233 u32 other_table_index = ~0;
11237 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11239 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11240 sw_if_index_set = 1;
11241 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11242 sw_if_index_set = 1;
11243 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11245 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11247 else if (unformat (i, "other-table %d", &other_table_index))
11249 else if (unformat (i, "is-input %d", &is_input))
11253 clib_warning ("parse error '%U'", format_unformat_error, i);
11258 if (sw_if_index_set == 0)
11260 errmsg ("missing interface name or sw_if_index");
11265 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11267 mp->sw_if_index = ntohl (sw_if_index);
11268 mp->ip4_table_index = ntohl (ip4_table_index);
11269 mp->ip6_table_index = ntohl (ip6_table_index);
11270 mp->other_table_index = ntohl (other_table_index);
11271 mp->is_input = (u8) is_input;
11279 api_set_ipfix_exporter (vat_main_t * vam)
11281 unformat_input_t *i = vam->input;
11282 vl_api_set_ipfix_exporter_t *mp;
11283 ip4_address_t collector_address;
11284 u8 collector_address_set = 0;
11285 u32 collector_port = ~0;
11286 ip4_address_t src_address;
11287 u8 src_address_set = 0;
11290 u32 template_interval = ~0;
11291 u8 udp_checksum = 0;
11294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11296 if (unformat (i, "collector_address %U", unformat_ip4_address,
11297 &collector_address))
11298 collector_address_set = 1;
11299 else if (unformat (i, "collector_port %d", &collector_port))
11301 else if (unformat (i, "src_address %U", unformat_ip4_address,
11303 src_address_set = 1;
11304 else if (unformat (i, "vrf_id %d", &vrf_id))
11306 else if (unformat (i, "path_mtu %d", &path_mtu))
11308 else if (unformat (i, "template_interval %d", &template_interval))
11310 else if (unformat (i, "udp_checksum"))
11316 if (collector_address_set == 0)
11318 errmsg ("collector_address required");
11322 if (src_address_set == 0)
11324 errmsg ("src_address required");
11328 M (SET_IPFIX_EXPORTER, mp);
11330 memcpy (mp->collector_address, collector_address.data,
11331 sizeof (collector_address.data));
11332 mp->collector_port = htons ((u16) collector_port);
11333 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11334 mp->vrf_id = htonl (vrf_id);
11335 mp->path_mtu = htonl (path_mtu);
11336 mp->template_interval = htonl (template_interval);
11337 mp->udp_checksum = udp_checksum;
11345 api_set_ipfix_classify_stream (vat_main_t * vam)
11347 unformat_input_t *i = vam->input;
11348 vl_api_set_ipfix_classify_stream_t *mp;
11350 u32 src_port = UDP_DST_PORT_ipfix;
11353 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11355 if (unformat (i, "domain %d", &domain_id))
11357 else if (unformat (i, "src_port %d", &src_port))
11361 errmsg ("unknown input `%U'", format_unformat_error, i);
11366 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11368 mp->domain_id = htonl (domain_id);
11369 mp->src_port = htons ((u16) src_port);
11377 api_ipfix_classify_table_add_del (vat_main_t * vam)
11379 unformat_input_t *i = vam->input;
11380 vl_api_ipfix_classify_table_add_del_t *mp;
11382 u32 classify_table_index = ~0;
11384 u8 transport_protocol = 255;
11387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11389 if (unformat (i, "add"))
11391 else if (unformat (i, "del"))
11393 else if (unformat (i, "table %d", &classify_table_index))
11395 else if (unformat (i, "ip4"))
11397 else if (unformat (i, "ip6"))
11399 else if (unformat (i, "tcp"))
11400 transport_protocol = 6;
11401 else if (unformat (i, "udp"))
11402 transport_protocol = 17;
11405 errmsg ("unknown input `%U'", format_unformat_error, i);
11412 errmsg ("expecting: add|del");
11415 if (classify_table_index == ~0)
11417 errmsg ("classifier table not specified");
11420 if (ip_version == 0)
11422 errmsg ("IP version not specified");
11426 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11428 mp->is_add = is_add;
11429 mp->table_id = htonl (classify_table_index);
11430 mp->ip_version = ip_version;
11431 mp->transport_protocol = transport_protocol;
11439 api_get_node_index (vat_main_t * vam)
11441 unformat_input_t *i = vam->input;
11442 vl_api_get_node_index_t *mp;
11446 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11448 if (unformat (i, "node %s", &name))
11455 errmsg ("node name required");
11458 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11460 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11464 M (GET_NODE_INDEX, mp);
11465 clib_memcpy (mp->node_name, name, vec_len (name));
11474 api_get_next_index (vat_main_t * vam)
11476 unformat_input_t *i = vam->input;
11477 vl_api_get_next_index_t *mp;
11478 u8 *node_name = 0, *next_node_name = 0;
11481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11483 if (unformat (i, "node-name %s", &node_name))
11485 else if (unformat (i, "next-node-name %s", &next_node_name))
11489 if (node_name == 0)
11491 errmsg ("node name required");
11494 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11496 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11500 if (next_node_name == 0)
11502 errmsg ("next node name required");
11505 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11507 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11511 M (GET_NEXT_INDEX, mp);
11512 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11513 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11514 vec_free (node_name);
11515 vec_free (next_node_name);
11523 api_add_node_next (vat_main_t * vam)
11525 unformat_input_t *i = vam->input;
11526 vl_api_add_node_next_t *mp;
11531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11533 if (unformat (i, "node %s", &name))
11535 else if (unformat (i, "next %s", &next))
11542 errmsg ("node name required");
11545 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11547 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11552 errmsg ("next node required");
11555 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11557 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11561 M (ADD_NODE_NEXT, mp);
11562 clib_memcpy (mp->node_name, name, vec_len (name));
11563 clib_memcpy (mp->next_name, next, vec_len (next));
11573 api_l2tpv3_create_tunnel (vat_main_t * vam)
11575 unformat_input_t *i = vam->input;
11576 ip6_address_t client_address, our_address;
11577 int client_address_set = 0;
11578 int our_address_set = 0;
11579 u32 local_session_id = 0;
11580 u32 remote_session_id = 0;
11581 u64 local_cookie = 0;
11582 u64 remote_cookie = 0;
11583 u8 l2_sublayer_present = 0;
11584 vl_api_l2tpv3_create_tunnel_t *mp;
11587 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11589 if (unformat (i, "client_address %U", unformat_ip6_address,
11591 client_address_set = 1;
11592 else if (unformat (i, "our_address %U", unformat_ip6_address,
11594 our_address_set = 1;
11595 else if (unformat (i, "local_session_id %d", &local_session_id))
11597 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11599 else if (unformat (i, "local_cookie %lld", &local_cookie))
11601 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11603 else if (unformat (i, "l2-sublayer-present"))
11604 l2_sublayer_present = 1;
11609 if (client_address_set == 0)
11611 errmsg ("client_address required");
11615 if (our_address_set == 0)
11617 errmsg ("our_address required");
11621 M (L2TPV3_CREATE_TUNNEL, mp);
11623 clib_memcpy (mp->client_address, client_address.as_u8,
11624 sizeof (mp->client_address));
11626 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11628 mp->local_session_id = ntohl (local_session_id);
11629 mp->remote_session_id = ntohl (remote_session_id);
11630 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11631 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11632 mp->l2_sublayer_present = l2_sublayer_present;
11641 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11643 unformat_input_t *i = vam->input;
11645 u8 sw_if_index_set = 0;
11646 u64 new_local_cookie = 0;
11647 u64 new_remote_cookie = 0;
11648 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11653 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11654 sw_if_index_set = 1;
11655 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11656 sw_if_index_set = 1;
11657 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11659 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11665 if (sw_if_index_set == 0)
11667 errmsg ("missing interface name or sw_if_index");
11671 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11673 mp->sw_if_index = ntohl (sw_if_index);
11674 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11675 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11683 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11685 unformat_input_t *i = vam->input;
11686 vl_api_l2tpv3_interface_enable_disable_t *mp;
11688 u8 sw_if_index_set = 0;
11689 u8 enable_disable = 1;
11692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11694 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11695 sw_if_index_set = 1;
11696 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11697 sw_if_index_set = 1;
11698 else if (unformat (i, "enable"))
11699 enable_disable = 1;
11700 else if (unformat (i, "disable"))
11701 enable_disable = 0;
11706 if (sw_if_index_set == 0)
11708 errmsg ("missing interface name or sw_if_index");
11712 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11714 mp->sw_if_index = ntohl (sw_if_index);
11715 mp->enable_disable = enable_disable;
11723 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11725 unformat_input_t *i = vam->input;
11726 vl_api_l2tpv3_set_lookup_key_t *mp;
11730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11732 if (unformat (i, "lookup_v6_src"))
11733 key = L2T_LOOKUP_SRC_ADDRESS;
11734 else if (unformat (i, "lookup_v6_dst"))
11735 key = L2T_LOOKUP_DST_ADDRESS;
11736 else if (unformat (i, "lookup_session_id"))
11737 key = L2T_LOOKUP_SESSION_ID;
11742 if (key == (u8) ~ 0)
11744 errmsg ("l2tp session lookup key unset");
11748 M (L2TPV3_SET_LOOKUP_KEY, mp);
11757 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11758 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11760 vat_main_t *vam = &vat_main;
11762 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11763 format_ip6_address, mp->our_address,
11764 format_ip6_address, mp->client_address,
11765 clib_net_to_host_u32 (mp->sw_if_index));
11768 " local cookies %016llx %016llx remote cookie %016llx",
11769 clib_net_to_host_u64 (mp->local_cookie[0]),
11770 clib_net_to_host_u64 (mp->local_cookie[1]),
11771 clib_net_to_host_u64 (mp->remote_cookie));
11773 print (vam->ofp, " local session-id %d remote session-id %d",
11774 clib_net_to_host_u32 (mp->local_session_id),
11775 clib_net_to_host_u32 (mp->remote_session_id));
11777 print (vam->ofp, " l2 specific sublayer %s\n",
11778 mp->l2_sublayer_present ? "preset" : "absent");
11782 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11783 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11785 vat_main_t *vam = &vat_main;
11786 vat_json_node_t *node = NULL;
11787 struct in6_addr addr;
11789 if (VAT_JSON_ARRAY != vam->json_tree.type)
11791 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11792 vat_json_init_array (&vam->json_tree);
11794 node = vat_json_array_add (&vam->json_tree);
11796 vat_json_init_object (node);
11798 clib_memcpy (&addr, mp->our_address, sizeof (addr));
11799 vat_json_object_add_ip6 (node, "our_address", addr);
11800 clib_memcpy (&addr, mp->client_address, sizeof (addr));
11801 vat_json_object_add_ip6 (node, "client_address", addr);
11803 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11804 vat_json_init_array (lc);
11805 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11806 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11807 vat_json_object_add_uint (node, "remote_cookie",
11808 clib_net_to_host_u64 (mp->remote_cookie));
11810 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11811 vat_json_object_add_uint (node, "local_session_id",
11812 clib_net_to_host_u32 (mp->local_session_id));
11813 vat_json_object_add_uint (node, "remote_session_id",
11814 clib_net_to_host_u32 (mp->remote_session_id));
11815 vat_json_object_add_string_copy (node, "l2_sublayer",
11816 mp->l2_sublayer_present ? (u8 *) "present"
11817 : (u8 *) "absent");
11821 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11823 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11824 vl_api_control_ping_t *mp_ping;
11827 /* Get list of l2tpv3-tunnel interfaces */
11828 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11831 /* Use a control ping for synchronization */
11832 MPING (CONTROL_PING, mp_ping);
11840 static void vl_api_sw_interface_tap_details_t_handler
11841 (vl_api_sw_interface_tap_details_t * mp)
11843 vat_main_t *vam = &vat_main;
11845 print (vam->ofp, "%-16s %d",
11846 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
11849 static void vl_api_sw_interface_tap_details_t_handler_json
11850 (vl_api_sw_interface_tap_details_t * mp)
11852 vat_main_t *vam = &vat_main;
11853 vat_json_node_t *node = NULL;
11855 if (VAT_JSON_ARRAY != vam->json_tree.type)
11857 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11858 vat_json_init_array (&vam->json_tree);
11860 node = vat_json_array_add (&vam->json_tree);
11862 vat_json_init_object (node);
11863 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11864 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11868 api_sw_interface_tap_dump (vat_main_t * vam)
11870 vl_api_sw_interface_tap_dump_t *mp;
11871 vl_api_control_ping_t *mp_ping;
11874 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
11875 /* Get list of tap interfaces */
11876 M (SW_INTERFACE_TAP_DUMP, mp);
11879 /* Use a control ping for synchronization */
11880 MPING (CONTROL_PING, mp_ping);
11887 static uword unformat_vxlan_decap_next
11888 (unformat_input_t * input, va_list * args)
11890 u32 *result = va_arg (*args, u32 *);
11893 if (unformat (input, "l2"))
11894 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11895 else if (unformat (input, "%d", &tmp))
11903 api_vxlan_add_del_tunnel (vat_main_t * vam)
11905 unformat_input_t *line_input = vam->input;
11906 vl_api_vxlan_add_del_tunnel_t *mp;
11907 ip46_address_t src, dst;
11909 u8 ipv4_set = 0, ipv6_set = 0;
11913 u32 mcast_sw_if_index = ~0;
11914 u32 encap_vrf_id = 0;
11915 u32 decap_next_index = ~0;
11919 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11920 memset (&src, 0, sizeof src);
11921 memset (&dst, 0, sizeof dst);
11923 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11925 if (unformat (line_input, "del"))
11928 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11934 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11940 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11946 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11951 else if (unformat (line_input, "group %U %U",
11952 unformat_ip4_address, &dst.ip4,
11953 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11955 grp_set = dst_set = 1;
11958 else if (unformat (line_input, "group %U",
11959 unformat_ip4_address, &dst.ip4))
11961 grp_set = dst_set = 1;
11964 else if (unformat (line_input, "group %U %U",
11965 unformat_ip6_address, &dst.ip6,
11966 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11968 grp_set = dst_set = 1;
11971 else if (unformat (line_input, "group %U",
11972 unformat_ip6_address, &dst.ip6))
11974 grp_set = dst_set = 1;
11978 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11980 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11982 else if (unformat (line_input, "decap-next %U",
11983 unformat_vxlan_decap_next, &decap_next_index))
11985 else if (unformat (line_input, "vni %d", &vni))
11989 errmsg ("parse error '%U'", format_unformat_error, line_input);
11996 errmsg ("tunnel src address not specified");
12001 errmsg ("tunnel dst address not specified");
12005 if (grp_set && !ip46_address_is_multicast (&dst))
12007 errmsg ("tunnel group address not multicast");
12010 if (grp_set && mcast_sw_if_index == ~0)
12012 errmsg ("tunnel nonexistent multicast device");
12015 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12017 errmsg ("tunnel dst address must be unicast");
12022 if (ipv4_set && ipv6_set)
12024 errmsg ("both IPv4 and IPv6 addresses specified");
12028 if ((vni == 0) || (vni >> 24))
12030 errmsg ("vni not specified or out of range");
12034 M (VXLAN_ADD_DEL_TUNNEL, mp);
12038 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12039 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12043 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12044 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12046 mp->encap_vrf_id = ntohl (encap_vrf_id);
12047 mp->decap_next_index = ntohl (decap_next_index);
12048 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12049 mp->vni = ntohl (vni);
12050 mp->is_add = is_add;
12051 mp->is_ipv6 = ipv6_set;
12058 static void vl_api_vxlan_tunnel_details_t_handler
12059 (vl_api_vxlan_tunnel_details_t * mp)
12061 vat_main_t *vam = &vat_main;
12062 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12063 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12065 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12066 ntohl (mp->sw_if_index),
12067 format_ip46_address, &src, IP46_TYPE_ANY,
12068 format_ip46_address, &dst, IP46_TYPE_ANY,
12069 ntohl (mp->encap_vrf_id),
12070 ntohl (mp->decap_next_index), ntohl (mp->vni),
12071 ntohl (mp->mcast_sw_if_index));
12074 static void vl_api_vxlan_tunnel_details_t_handler_json
12075 (vl_api_vxlan_tunnel_details_t * mp)
12077 vat_main_t *vam = &vat_main;
12078 vat_json_node_t *node = NULL;
12080 if (VAT_JSON_ARRAY != vam->json_tree.type)
12082 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12083 vat_json_init_array (&vam->json_tree);
12085 node = vat_json_array_add (&vam->json_tree);
12087 vat_json_init_object (node);
12088 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12091 struct in6_addr ip6;
12093 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12094 vat_json_object_add_ip6 (node, "src_address", ip6);
12095 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12096 vat_json_object_add_ip6 (node, "dst_address", ip6);
12100 struct in_addr ip4;
12102 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12103 vat_json_object_add_ip4 (node, "src_address", ip4);
12104 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12105 vat_json_object_add_ip4 (node, "dst_address", ip4);
12107 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12108 vat_json_object_add_uint (node, "decap_next_index",
12109 ntohl (mp->decap_next_index));
12110 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12111 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12112 vat_json_object_add_uint (node, "mcast_sw_if_index",
12113 ntohl (mp->mcast_sw_if_index));
12117 api_vxlan_tunnel_dump (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_vxlan_tunnel_dump_t *mp;
12121 vl_api_control_ping_t *mp_ping;
12123 u8 sw_if_index_set = 0;
12126 /* Parse args required to build the message */
12127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12129 if (unformat (i, "sw_if_index %d", &sw_if_index))
12130 sw_if_index_set = 1;
12135 if (sw_if_index_set == 0)
12140 if (!vam->json_output)
12142 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12143 "sw_if_index", "src_address", "dst_address",
12144 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12147 /* Get list of vxlan-tunnel interfaces */
12148 M (VXLAN_TUNNEL_DUMP, mp);
12150 mp->sw_if_index = htonl (sw_if_index);
12154 /* Use a control ping for synchronization */
12155 MPING (CONTROL_PING, mp_ping);
12162 static uword unformat_geneve_decap_next
12163 (unformat_input_t * input, va_list * args)
12165 u32 *result = va_arg (*args, u32 *);
12168 if (unformat (input, "l2"))
12169 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12170 else if (unformat (input, "%d", &tmp))
12178 api_geneve_add_del_tunnel (vat_main_t * vam)
12180 unformat_input_t *line_input = vam->input;
12181 vl_api_geneve_add_del_tunnel_t *mp;
12182 ip46_address_t src, dst;
12184 u8 ipv4_set = 0, ipv6_set = 0;
12188 u32 mcast_sw_if_index = ~0;
12189 u32 encap_vrf_id = 0;
12190 u32 decap_next_index = ~0;
12194 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12195 memset (&src, 0, sizeof src);
12196 memset (&dst, 0, sizeof dst);
12198 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12200 if (unformat (line_input, "del"))
12203 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12209 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12215 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12221 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12226 else if (unformat (line_input, "group %U %U",
12227 unformat_ip4_address, &dst.ip4,
12228 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12230 grp_set = dst_set = 1;
12233 else if (unformat (line_input, "group %U",
12234 unformat_ip4_address, &dst.ip4))
12236 grp_set = dst_set = 1;
12239 else if (unformat (line_input, "group %U %U",
12240 unformat_ip6_address, &dst.ip6,
12241 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12243 grp_set = dst_set = 1;
12246 else if (unformat (line_input, "group %U",
12247 unformat_ip6_address, &dst.ip6))
12249 grp_set = dst_set = 1;
12253 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12255 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12257 else if (unformat (line_input, "decap-next %U",
12258 unformat_geneve_decap_next, &decap_next_index))
12260 else if (unformat (line_input, "vni %d", &vni))
12264 errmsg ("parse error '%U'", format_unformat_error, line_input);
12271 errmsg ("tunnel src address not specified");
12276 errmsg ("tunnel dst address not specified");
12280 if (grp_set && !ip46_address_is_multicast (&dst))
12282 errmsg ("tunnel group address not multicast");
12285 if (grp_set && mcast_sw_if_index == ~0)
12287 errmsg ("tunnel nonexistent multicast device");
12290 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12292 errmsg ("tunnel dst address must be unicast");
12297 if (ipv4_set && ipv6_set)
12299 errmsg ("both IPv4 and IPv6 addresses specified");
12303 if ((vni == 0) || (vni >> 24))
12305 errmsg ("vni not specified or out of range");
12309 M (GENEVE_ADD_DEL_TUNNEL, mp);
12313 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12314 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12318 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12319 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12321 mp->encap_vrf_id = ntohl (encap_vrf_id);
12322 mp->decap_next_index = ntohl (decap_next_index);
12323 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12324 mp->vni = ntohl (vni);
12325 mp->is_add = is_add;
12326 mp->is_ipv6 = ipv6_set;
12333 static void vl_api_geneve_tunnel_details_t_handler
12334 (vl_api_geneve_tunnel_details_t * mp)
12336 vat_main_t *vam = &vat_main;
12337 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12338 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12340 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12341 ntohl (mp->sw_if_index),
12342 format_ip46_address, &src, IP46_TYPE_ANY,
12343 format_ip46_address, &dst, IP46_TYPE_ANY,
12344 ntohl (mp->encap_vrf_id),
12345 ntohl (mp->decap_next_index), ntohl (mp->vni),
12346 ntohl (mp->mcast_sw_if_index));
12349 static void vl_api_geneve_tunnel_details_t_handler_json
12350 (vl_api_geneve_tunnel_details_t * mp)
12352 vat_main_t *vam = &vat_main;
12353 vat_json_node_t *node = NULL;
12355 if (VAT_JSON_ARRAY != vam->json_tree.type)
12357 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12358 vat_json_init_array (&vam->json_tree);
12360 node = vat_json_array_add (&vam->json_tree);
12362 vat_json_init_object (node);
12363 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12366 struct in6_addr ip6;
12368 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12369 vat_json_object_add_ip6 (node, "src_address", ip6);
12370 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12371 vat_json_object_add_ip6 (node, "dst_address", ip6);
12375 struct in_addr ip4;
12377 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12378 vat_json_object_add_ip4 (node, "src_address", ip4);
12379 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12380 vat_json_object_add_ip4 (node, "dst_address", ip4);
12382 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12383 vat_json_object_add_uint (node, "decap_next_index",
12384 ntohl (mp->decap_next_index));
12385 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12386 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12387 vat_json_object_add_uint (node, "mcast_sw_if_index",
12388 ntohl (mp->mcast_sw_if_index));
12392 api_geneve_tunnel_dump (vat_main_t * vam)
12394 unformat_input_t *i = vam->input;
12395 vl_api_geneve_tunnel_dump_t *mp;
12396 vl_api_control_ping_t *mp_ping;
12398 u8 sw_if_index_set = 0;
12401 /* Parse args required to build the message */
12402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12404 if (unformat (i, "sw_if_index %d", &sw_if_index))
12405 sw_if_index_set = 1;
12410 if (sw_if_index_set == 0)
12415 if (!vam->json_output)
12417 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12418 "sw_if_index", "local_address", "remote_address",
12419 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12422 /* Get list of geneve-tunnel interfaces */
12423 M (GENEVE_TUNNEL_DUMP, mp);
12425 mp->sw_if_index = htonl (sw_if_index);
12429 /* Use a control ping for synchronization */
12430 M (CONTROL_PING, mp_ping);
12438 api_gre_add_del_tunnel (vat_main_t * vam)
12440 unformat_input_t *line_input = vam->input;
12441 vl_api_gre_add_del_tunnel_t *mp;
12442 ip4_address_t src4, dst4;
12443 ip6_address_t src6, dst6;
12450 u32 outer_fib_id = 0;
12453 memset (&src4, 0, sizeof src4);
12454 memset (&dst4, 0, sizeof dst4);
12455 memset (&src6, 0, sizeof src6);
12456 memset (&dst6, 0, sizeof dst6);
12458 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12460 if (unformat (line_input, "del"))
12462 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
12467 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
12472 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
12477 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
12482 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
12484 else if (unformat (line_input, "teb"))
12488 errmsg ("parse error '%U'", format_unformat_error, line_input);
12495 errmsg ("tunnel src address not specified");
12500 errmsg ("tunnel dst address not specified");
12503 if (ipv4_set && ipv6_set)
12505 errmsg ("both IPv4 and IPv6 addresses specified");
12510 M (GRE_ADD_DEL_TUNNEL, mp);
12514 clib_memcpy (&mp->src_address, &src4, 4);
12515 clib_memcpy (&mp->dst_address, &dst4, 4);
12519 clib_memcpy (&mp->src_address, &src6, 16);
12520 clib_memcpy (&mp->dst_address, &dst6, 16);
12522 mp->outer_fib_id = ntohl (outer_fib_id);
12523 mp->is_add = is_add;
12525 mp->is_ipv6 = ipv6_set;
12532 static void vl_api_gre_tunnel_details_t_handler
12533 (vl_api_gre_tunnel_details_t * mp)
12535 vat_main_t *vam = &vat_main;
12536 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
12537 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
12539 print (vam->ofp, "%11d%24U%24U%6d%14d",
12540 ntohl (mp->sw_if_index),
12541 format_ip46_address, &src, IP46_TYPE_ANY,
12542 format_ip46_address, &dst, IP46_TYPE_ANY,
12543 mp->teb, ntohl (mp->outer_fib_id));
12546 static void vl_api_gre_tunnel_details_t_handler_json
12547 (vl_api_gre_tunnel_details_t * mp)
12549 vat_main_t *vam = &vat_main;
12550 vat_json_node_t *node = NULL;
12551 struct in_addr ip4;
12552 struct in6_addr ip6;
12554 if (VAT_JSON_ARRAY != vam->json_tree.type)
12556 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12557 vat_json_init_array (&vam->json_tree);
12559 node = vat_json_array_add (&vam->json_tree);
12561 vat_json_init_object (node);
12562 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12565 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
12566 vat_json_object_add_ip4 (node, "src_address", ip4);
12567 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
12568 vat_json_object_add_ip4 (node, "dst_address", ip4);
12572 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
12573 vat_json_object_add_ip6 (node, "src_address", ip6);
12574 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
12575 vat_json_object_add_ip6 (node, "dst_address", ip6);
12577 vat_json_object_add_uint (node, "teb", mp->teb);
12578 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
12579 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
12583 api_gre_tunnel_dump (vat_main_t * vam)
12585 unformat_input_t *i = vam->input;
12586 vl_api_gre_tunnel_dump_t *mp;
12587 vl_api_control_ping_t *mp_ping;
12589 u8 sw_if_index_set = 0;
12592 /* Parse args required to build the message */
12593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12595 if (unformat (i, "sw_if_index %d", &sw_if_index))
12596 sw_if_index_set = 1;
12601 if (sw_if_index_set == 0)
12606 if (!vam->json_output)
12608 print (vam->ofp, "%11s%24s%24s%6s%14s",
12609 "sw_if_index", "src_address", "dst_address", "teb",
12613 /* Get list of gre-tunnel interfaces */
12614 M (GRE_TUNNEL_DUMP, mp);
12616 mp->sw_if_index = htonl (sw_if_index);
12620 /* Use a control ping for synchronization */
12621 MPING (CONTROL_PING, mp_ping);
12629 api_l2_fib_clear_table (vat_main_t * vam)
12631 // unformat_input_t * i = vam->input;
12632 vl_api_l2_fib_clear_table_t *mp;
12635 M (L2_FIB_CLEAR_TABLE, mp);
12643 api_l2_interface_efp_filter (vat_main_t * vam)
12645 unformat_input_t *i = vam->input;
12646 vl_api_l2_interface_efp_filter_t *mp;
12649 u8 sw_if_index_set = 0;
12652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12654 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12655 sw_if_index_set = 1;
12656 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12657 sw_if_index_set = 1;
12658 else if (unformat (i, "enable"))
12660 else if (unformat (i, "disable"))
12664 clib_warning ("parse error '%U'", format_unformat_error, i);
12669 if (sw_if_index_set == 0)
12671 errmsg ("missing sw_if_index");
12675 M (L2_INTERFACE_EFP_FILTER, mp);
12677 mp->sw_if_index = ntohl (sw_if_index);
12678 mp->enable_disable = enable;
12685 #define foreach_vtr_op \
12686 _("disable", L2_VTR_DISABLED) \
12687 _("push-1", L2_VTR_PUSH_1) \
12688 _("push-2", L2_VTR_PUSH_2) \
12689 _("pop-1", L2_VTR_POP_1) \
12690 _("pop-2", L2_VTR_POP_2) \
12691 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12692 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12693 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12694 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12697 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12699 unformat_input_t *i = vam->input;
12700 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12702 u8 sw_if_index_set = 0;
12705 u32 push_dot1q = 1;
12710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12712 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12713 sw_if_index_set = 1;
12714 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12715 sw_if_index_set = 1;
12716 else if (unformat (i, "vtr_op %d", &vtr_op))
12718 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12721 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12723 else if (unformat (i, "tag1 %d", &tag1))
12725 else if (unformat (i, "tag2 %d", &tag2))
12729 clib_warning ("parse error '%U'", format_unformat_error, i);
12734 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12736 errmsg ("missing vtr operation or sw_if_index");
12740 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12741 mp->sw_if_index = ntohl (sw_if_index);
12742 mp->vtr_op = ntohl (vtr_op);
12743 mp->push_dot1q = ntohl (push_dot1q);
12744 mp->tag1 = ntohl (tag1);
12745 mp->tag2 = ntohl (tag2);
12753 api_create_vhost_user_if (vat_main_t * vam)
12755 unformat_input_t *i = vam->input;
12756 vl_api_create_vhost_user_if_t *mp;
12759 u8 file_name_set = 0;
12760 u32 custom_dev_instance = ~0;
12762 u8 use_custom_mac = 0;
12766 /* Shut up coverity */
12767 memset (hwaddr, 0, sizeof (hwaddr));
12769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12771 if (unformat (i, "socket %s", &file_name))
12775 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12777 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12778 use_custom_mac = 1;
12779 else if (unformat (i, "server"))
12781 else if (unformat (i, "tag %s", &tag))
12787 if (file_name_set == 0)
12789 errmsg ("missing socket file name");
12793 if (vec_len (file_name) > 255)
12795 errmsg ("socket file name too long");
12798 vec_add1 (file_name, 0);
12800 M (CREATE_VHOST_USER_IF, mp);
12802 mp->is_server = is_server;
12803 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12804 vec_free (file_name);
12805 if (custom_dev_instance != ~0)
12808 mp->custom_dev_instance = ntohl (custom_dev_instance);
12810 mp->use_custom_mac = use_custom_mac;
12811 clib_memcpy (mp->mac_address, hwaddr, 6);
12813 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12822 api_modify_vhost_user_if (vat_main_t * vam)
12824 unformat_input_t *i = vam->input;
12825 vl_api_modify_vhost_user_if_t *mp;
12828 u8 file_name_set = 0;
12829 u32 custom_dev_instance = ~0;
12830 u8 sw_if_index_set = 0;
12831 u32 sw_if_index = (u32) ~ 0;
12834 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12836 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12837 sw_if_index_set = 1;
12838 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12839 sw_if_index_set = 1;
12840 else if (unformat (i, "socket %s", &file_name))
12844 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12846 else if (unformat (i, "server"))
12852 if (sw_if_index_set == 0)
12854 errmsg ("missing sw_if_index or interface name");
12858 if (file_name_set == 0)
12860 errmsg ("missing socket file name");
12864 if (vec_len (file_name) > 255)
12866 errmsg ("socket file name too long");
12869 vec_add1 (file_name, 0);
12871 M (MODIFY_VHOST_USER_IF, mp);
12873 mp->sw_if_index = ntohl (sw_if_index);
12874 mp->is_server = is_server;
12875 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12876 vec_free (file_name);
12877 if (custom_dev_instance != ~0)
12880 mp->custom_dev_instance = ntohl (custom_dev_instance);
12889 api_delete_vhost_user_if (vat_main_t * vam)
12891 unformat_input_t *i = vam->input;
12892 vl_api_delete_vhost_user_if_t *mp;
12893 u32 sw_if_index = ~0;
12894 u8 sw_if_index_set = 0;
12897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12899 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12900 sw_if_index_set = 1;
12901 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12902 sw_if_index_set = 1;
12907 if (sw_if_index_set == 0)
12909 errmsg ("missing sw_if_index or interface name");
12914 M (DELETE_VHOST_USER_IF, mp);
12916 mp->sw_if_index = ntohl (sw_if_index);
12923 static void vl_api_sw_interface_vhost_user_details_t_handler
12924 (vl_api_sw_interface_vhost_user_details_t * mp)
12926 vat_main_t *vam = &vat_main;
12928 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12929 (char *) mp->interface_name,
12930 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12931 clib_net_to_host_u64 (mp->features), mp->is_server,
12932 ntohl (mp->num_regions), (char *) mp->sock_filename);
12933 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12936 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12937 (vl_api_sw_interface_vhost_user_details_t * mp)
12939 vat_main_t *vam = &vat_main;
12940 vat_json_node_t *node = NULL;
12942 if (VAT_JSON_ARRAY != vam->json_tree.type)
12944 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12945 vat_json_init_array (&vam->json_tree);
12947 node = vat_json_array_add (&vam->json_tree);
12949 vat_json_init_object (node);
12950 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12951 vat_json_object_add_string_copy (node, "interface_name",
12952 mp->interface_name);
12953 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12954 ntohl (mp->virtio_net_hdr_sz));
12955 vat_json_object_add_uint (node, "features",
12956 clib_net_to_host_u64 (mp->features));
12957 vat_json_object_add_uint (node, "is_server", mp->is_server);
12958 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12959 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12960 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12964 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12966 vl_api_sw_interface_vhost_user_dump_t *mp;
12967 vl_api_control_ping_t *mp_ping;
12970 "Interface name idx hdr_sz features server regions filename");
12972 /* Get list of vhost-user interfaces */
12973 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12976 /* Use a control ping for synchronization */
12977 MPING (CONTROL_PING, mp_ping);
12985 api_show_version (vat_main_t * vam)
12987 vl_api_show_version_t *mp;
12990 M (SHOW_VERSION, mp);
12999 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13001 unformat_input_t *line_input = vam->input;
13002 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13003 ip4_address_t local4, remote4;
13004 ip6_address_t local6, remote6;
13006 u8 ipv4_set = 0, ipv6_set = 0;
13010 u32 mcast_sw_if_index = ~0;
13011 u32 encap_vrf_id = 0;
13012 u32 decap_vrf_id = 0;
13018 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13019 memset (&local4, 0, sizeof local4);
13020 memset (&remote4, 0, sizeof remote4);
13021 memset (&local6, 0, sizeof local6);
13022 memset (&remote6, 0, sizeof remote6);
13024 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13026 if (unformat (line_input, "del"))
13028 else if (unformat (line_input, "local %U",
13029 unformat_ip4_address, &local4))
13034 else if (unformat (line_input, "remote %U",
13035 unformat_ip4_address, &remote4))
13040 else if (unformat (line_input, "local %U",
13041 unformat_ip6_address, &local6))
13046 else if (unformat (line_input, "remote %U",
13047 unformat_ip6_address, &remote6))
13052 else if (unformat (line_input, "group %U %U",
13053 unformat_ip4_address, &remote4,
13054 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13056 grp_set = remote_set = 1;
13059 else if (unformat (line_input, "group %U",
13060 unformat_ip4_address, &remote4))
13062 grp_set = remote_set = 1;
13065 else if (unformat (line_input, "group %U %U",
13066 unformat_ip6_address, &remote6,
13067 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13069 grp_set = remote_set = 1;
13072 else if (unformat (line_input, "group %U",
13073 unformat_ip6_address, &remote6))
13075 grp_set = remote_set = 1;
13079 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13081 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13083 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13085 else if (unformat (line_input, "vni %d", &vni))
13087 else if (unformat (line_input, "next-ip4"))
13089 else if (unformat (line_input, "next-ip6"))
13091 else if (unformat (line_input, "next-ethernet"))
13093 else if (unformat (line_input, "next-nsh"))
13097 errmsg ("parse error '%U'", format_unformat_error, line_input);
13102 if (local_set == 0)
13104 errmsg ("tunnel local address not specified");
13107 if (remote_set == 0)
13109 errmsg ("tunnel remote address not specified");
13112 if (grp_set && mcast_sw_if_index == ~0)
13114 errmsg ("tunnel nonexistent multicast device");
13117 if (ipv4_set && ipv6_set)
13119 errmsg ("both IPv4 and IPv6 addresses specified");
13125 errmsg ("vni not specified");
13129 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13134 clib_memcpy (&mp->local, &local6, sizeof (local6));
13135 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13139 clib_memcpy (&mp->local, &local4, sizeof (local4));
13140 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13143 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13144 mp->encap_vrf_id = ntohl (encap_vrf_id);
13145 mp->decap_vrf_id = ntohl (decap_vrf_id);
13146 mp->protocol = protocol;
13147 mp->vni = ntohl (vni);
13148 mp->is_add = is_add;
13149 mp->is_ipv6 = ipv6_set;
13156 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13157 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13159 vat_main_t *vam = &vat_main;
13160 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13161 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13163 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13164 ntohl (mp->sw_if_index),
13165 format_ip46_address, &local, IP46_TYPE_ANY,
13166 format_ip46_address, &remote, IP46_TYPE_ANY,
13167 ntohl (mp->vni), mp->protocol,
13168 ntohl (mp->mcast_sw_if_index),
13169 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13173 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13174 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13176 vat_main_t *vam = &vat_main;
13177 vat_json_node_t *node = NULL;
13178 struct in_addr ip4;
13179 struct in6_addr ip6;
13181 if (VAT_JSON_ARRAY != vam->json_tree.type)
13183 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13184 vat_json_init_array (&vam->json_tree);
13186 node = vat_json_array_add (&vam->json_tree);
13188 vat_json_init_object (node);
13189 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13192 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13193 vat_json_object_add_ip6 (node, "local", ip6);
13194 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13195 vat_json_object_add_ip6 (node, "remote", ip6);
13199 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13200 vat_json_object_add_ip4 (node, "local", ip4);
13201 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13202 vat_json_object_add_ip4 (node, "remote", ip4);
13204 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13205 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13206 vat_json_object_add_uint (node, "mcast_sw_if_index",
13207 ntohl (mp->mcast_sw_if_index));
13208 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13209 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13210 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13214 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13216 unformat_input_t *i = vam->input;
13217 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13218 vl_api_control_ping_t *mp_ping;
13220 u8 sw_if_index_set = 0;
13223 /* Parse args required to build the message */
13224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13226 if (unformat (i, "sw_if_index %d", &sw_if_index))
13227 sw_if_index_set = 1;
13232 if (sw_if_index_set == 0)
13237 if (!vam->json_output)
13239 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13240 "sw_if_index", "local", "remote", "vni",
13241 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13244 /* Get list of vxlan-tunnel interfaces */
13245 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13247 mp->sw_if_index = htonl (sw_if_index);
13251 /* Use a control ping for synchronization */
13252 MPING (CONTROL_PING, mp_ping);
13261 format_l2_fib_mac_address (u8 * s, va_list * args)
13263 u8 *a = va_arg (*args, u8 *);
13265 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
13266 a[2], a[3], a[4], a[5], a[6], a[7]);
13269 static void vl_api_l2_fib_table_details_t_handler
13270 (vl_api_l2_fib_table_details_t * mp)
13272 vat_main_t *vam = &vat_main;
13274 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13276 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
13277 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13281 static void vl_api_l2_fib_table_details_t_handler_json
13282 (vl_api_l2_fib_table_details_t * mp)
13284 vat_main_t *vam = &vat_main;
13285 vat_json_node_t *node = NULL;
13287 if (VAT_JSON_ARRAY != vam->json_tree.type)
13289 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13290 vat_json_init_array (&vam->json_tree);
13292 node = vat_json_array_add (&vam->json_tree);
13294 vat_json_init_object (node);
13295 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13296 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
13297 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13298 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13299 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13300 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13304 api_l2_fib_table_dump (vat_main_t * vam)
13306 unformat_input_t *i = vam->input;
13307 vl_api_l2_fib_table_dump_t *mp;
13308 vl_api_control_ping_t *mp_ping;
13313 /* Parse args required to build the message */
13314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13316 if (unformat (i, "bd_id %d", &bd_id))
13322 if (bd_id_set == 0)
13324 errmsg ("missing bridge domain");
13328 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13330 /* Get list of l2 fib entries */
13331 M (L2_FIB_TABLE_DUMP, mp);
13333 mp->bd_id = ntohl (bd_id);
13336 /* Use a control ping for synchronization */
13337 MPING (CONTROL_PING, mp_ping);
13346 api_interface_name_renumber (vat_main_t * vam)
13348 unformat_input_t *line_input = vam->input;
13349 vl_api_interface_name_renumber_t *mp;
13350 u32 sw_if_index = ~0;
13351 u32 new_show_dev_instance = ~0;
13354 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13356 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13359 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13361 else if (unformat (line_input, "new_show_dev_instance %d",
13362 &new_show_dev_instance))
13368 if (sw_if_index == ~0)
13370 errmsg ("missing interface name or sw_if_index");
13374 if (new_show_dev_instance == ~0)
13376 errmsg ("missing new_show_dev_instance");
13380 M (INTERFACE_NAME_RENUMBER, mp);
13382 mp->sw_if_index = ntohl (sw_if_index);
13383 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13391 api_want_ip4_arp_events (vat_main_t * vam)
13393 unformat_input_t *line_input = vam->input;
13394 vl_api_want_ip4_arp_events_t *mp;
13395 ip4_address_t address;
13396 int address_set = 0;
13397 u32 enable_disable = 1;
13400 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13402 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13404 else if (unformat (line_input, "del"))
13405 enable_disable = 0;
13410 if (address_set == 0)
13412 errmsg ("missing addresses");
13416 M (WANT_IP4_ARP_EVENTS, mp);
13417 mp->enable_disable = enable_disable;
13418 mp->pid = htonl (getpid ());
13419 mp->address = address.as_u32;
13427 api_want_ip6_nd_events (vat_main_t * vam)
13429 unformat_input_t *line_input = vam->input;
13430 vl_api_want_ip6_nd_events_t *mp;
13431 ip6_address_t address;
13432 int address_set = 0;
13433 u32 enable_disable = 1;
13436 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13438 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
13440 else if (unformat (line_input, "del"))
13441 enable_disable = 0;
13446 if (address_set == 0)
13448 errmsg ("missing addresses");
13452 M (WANT_IP6_ND_EVENTS, mp);
13453 mp->enable_disable = enable_disable;
13454 mp->pid = htonl (getpid ());
13455 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
13463 api_want_l2_macs_events (vat_main_t * vam)
13465 unformat_input_t *line_input = vam->input;
13466 vl_api_want_l2_macs_events_t *mp;
13467 u8 enable_disable = 1;
13468 u32 scan_delay = 0;
13469 u32 max_macs_in_event = 0;
13470 u32 learn_limit = 0;
13473 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13475 if (unformat (line_input, "learn-limit %d", &learn_limit))
13477 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13479 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13481 else if (unformat (line_input, "disable"))
13482 enable_disable = 0;
13487 M (WANT_L2_MACS_EVENTS, mp);
13488 mp->enable_disable = enable_disable;
13489 mp->pid = htonl (getpid ());
13490 mp->learn_limit = htonl (learn_limit);
13491 mp->scan_delay = (u8) scan_delay;
13492 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13499 api_input_acl_set_interface (vat_main_t * vam)
13501 unformat_input_t *i = vam->input;
13502 vl_api_input_acl_set_interface_t *mp;
13504 int sw_if_index_set;
13505 u32 ip4_table_index = ~0;
13506 u32 ip6_table_index = ~0;
13507 u32 l2_table_index = ~0;
13511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13514 sw_if_index_set = 1;
13515 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13516 sw_if_index_set = 1;
13517 else if (unformat (i, "del"))
13519 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13521 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13523 else if (unformat (i, "l2-table %d", &l2_table_index))
13527 clib_warning ("parse error '%U'", format_unformat_error, i);
13532 if (sw_if_index_set == 0)
13534 errmsg ("missing interface name or sw_if_index");
13538 M (INPUT_ACL_SET_INTERFACE, mp);
13540 mp->sw_if_index = ntohl (sw_if_index);
13541 mp->ip4_table_index = ntohl (ip4_table_index);
13542 mp->ip6_table_index = ntohl (ip6_table_index);
13543 mp->l2_table_index = ntohl (l2_table_index);
13544 mp->is_add = is_add;
13552 api_ip_address_dump (vat_main_t * vam)
13554 unformat_input_t *i = vam->input;
13555 vl_api_ip_address_dump_t *mp;
13556 vl_api_control_ping_t *mp_ping;
13557 u32 sw_if_index = ~0;
13558 u8 sw_if_index_set = 0;
13563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13565 if (unformat (i, "sw_if_index %d", &sw_if_index))
13566 sw_if_index_set = 1;
13568 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13569 sw_if_index_set = 1;
13570 else if (unformat (i, "ipv4"))
13572 else if (unformat (i, "ipv6"))
13578 if (ipv4_set && ipv6_set)
13580 errmsg ("ipv4 and ipv6 flags cannot be both set");
13584 if ((!ipv4_set) && (!ipv6_set))
13586 errmsg ("no ipv4 nor ipv6 flag set");
13590 if (sw_if_index_set == 0)
13592 errmsg ("missing interface name or sw_if_index");
13596 vam->current_sw_if_index = sw_if_index;
13597 vam->is_ipv6 = ipv6_set;
13599 M (IP_ADDRESS_DUMP, mp);
13600 mp->sw_if_index = ntohl (sw_if_index);
13601 mp->is_ipv6 = ipv6_set;
13604 /* Use a control ping for synchronization */
13605 MPING (CONTROL_PING, mp_ping);
13613 api_ip_dump (vat_main_t * vam)
13615 vl_api_ip_dump_t *mp;
13616 vl_api_control_ping_t *mp_ping;
13617 unformat_input_t *in = vam->input;
13624 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13626 if (unformat (in, "ipv4"))
13628 else if (unformat (in, "ipv6"))
13634 if (ipv4_set && ipv6_set)
13636 errmsg ("ipv4 and ipv6 flags cannot be both set");
13640 if ((!ipv4_set) && (!ipv6_set))
13642 errmsg ("no ipv4 nor ipv6 flag set");
13646 is_ipv6 = ipv6_set;
13647 vam->is_ipv6 = is_ipv6;
13649 /* free old data */
13650 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13652 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13654 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13657 mp->is_ipv6 = ipv6_set;
13660 /* Use a control ping for synchronization */
13661 MPING (CONTROL_PING, mp_ping);
13669 api_ipsec_spd_add_del (vat_main_t * vam)
13671 unformat_input_t *i = vam->input;
13672 vl_api_ipsec_spd_add_del_t *mp;
13677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13679 if (unformat (i, "spd_id %d", &spd_id))
13681 else if (unformat (i, "del"))
13685 clib_warning ("parse error '%U'", format_unformat_error, i);
13691 errmsg ("spd_id must be set");
13695 M (IPSEC_SPD_ADD_DEL, mp);
13697 mp->spd_id = ntohl (spd_id);
13698 mp->is_add = is_add;
13706 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13708 unformat_input_t *i = vam->input;
13709 vl_api_ipsec_interface_add_del_spd_t *mp;
13711 u8 sw_if_index_set = 0;
13712 u32 spd_id = (u32) ~ 0;
13716 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13718 if (unformat (i, "del"))
13720 else if (unformat (i, "spd_id %d", &spd_id))
13723 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13724 sw_if_index_set = 1;
13725 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13726 sw_if_index_set = 1;
13729 clib_warning ("parse error '%U'", format_unformat_error, i);
13735 if (spd_id == (u32) ~ 0)
13737 errmsg ("spd_id must be set");
13741 if (sw_if_index_set == 0)
13743 errmsg ("missing interface name or sw_if_index");
13747 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13749 mp->spd_id = ntohl (spd_id);
13750 mp->sw_if_index = ntohl (sw_if_index);
13751 mp->is_add = is_add;
13759 api_ipsec_spd_add_del_entry (vat_main_t * vam)
13761 unformat_input_t *i = vam->input;
13762 vl_api_ipsec_spd_add_del_entry_t *mp;
13763 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
13764 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13766 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13767 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13768 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
13769 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
13772 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
13773 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
13774 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
13775 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
13776 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
13777 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
13779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13781 if (unformat (i, "del"))
13783 if (unformat (i, "outbound"))
13785 if (unformat (i, "inbound"))
13787 else if (unformat (i, "spd_id %d", &spd_id))
13789 else if (unformat (i, "sa_id %d", &sa_id))
13791 else if (unformat (i, "priority %d", &priority))
13793 else if (unformat (i, "protocol %d", &protocol))
13795 else if (unformat (i, "lport_start %d", &lport_start))
13797 else if (unformat (i, "lport_stop %d", &lport_stop))
13799 else if (unformat (i, "rport_start %d", &rport_start))
13801 else if (unformat (i, "rport_stop %d", &rport_stop))
13805 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
13811 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
13818 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
13824 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
13831 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
13837 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
13844 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
13850 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
13856 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13858 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13860 clib_warning ("unsupported action: 'resolve'");
13866 clib_warning ("parse error '%U'", format_unformat_error, i);
13872 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
13874 mp->spd_id = ntohl (spd_id);
13875 mp->priority = ntohl (priority);
13876 mp->is_outbound = is_outbound;
13878 mp->is_ipv6 = is_ipv6;
13879 if (is_ipv6 || is_ip_any)
13881 clib_memcpy (mp->remote_address_start, &raddr6_start,
13882 sizeof (ip6_address_t));
13883 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
13884 sizeof (ip6_address_t));
13885 clib_memcpy (mp->local_address_start, &laddr6_start,
13886 sizeof (ip6_address_t));
13887 clib_memcpy (mp->local_address_stop, &laddr6_stop,
13888 sizeof (ip6_address_t));
13892 clib_memcpy (mp->remote_address_start, &raddr4_start,
13893 sizeof (ip4_address_t));
13894 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
13895 sizeof (ip4_address_t));
13896 clib_memcpy (mp->local_address_start, &laddr4_start,
13897 sizeof (ip4_address_t));
13898 clib_memcpy (mp->local_address_stop, &laddr4_stop,
13899 sizeof (ip4_address_t));
13901 mp->protocol = (u8) protocol;
13902 mp->local_port_start = ntohs ((u16) lport_start);
13903 mp->local_port_stop = ntohs ((u16) lport_stop);
13904 mp->remote_port_start = ntohs ((u16) rport_start);
13905 mp->remote_port_stop = ntohs ((u16) rport_stop);
13906 mp->policy = (u8) policy;
13907 mp->sa_id = ntohl (sa_id);
13908 mp->is_add = is_add;
13909 mp->is_ip_any = is_ip_any;
13916 api_ipsec_sad_add_del_entry (vat_main_t * vam)
13918 unformat_input_t *i = vam->input;
13919 vl_api_ipsec_sad_add_del_entry_t *mp;
13920 u32 sad_id = 0, spi = 0;
13921 u8 *ck = 0, *ik = 0;
13924 u8 protocol = IPSEC_PROTOCOL_AH;
13925 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
13926 u32 crypto_alg = 0, integ_alg = 0;
13927 ip4_address_t tun_src4;
13928 ip4_address_t tun_dst4;
13929 ip6_address_t tun_src6;
13930 ip6_address_t tun_dst6;
13933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13935 if (unformat (i, "del"))
13937 else if (unformat (i, "sad_id %d", &sad_id))
13939 else if (unformat (i, "spi %d", &spi))
13941 else if (unformat (i, "esp"))
13942 protocol = IPSEC_PROTOCOL_ESP;
13943 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
13946 is_tunnel_ipv6 = 0;
13948 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
13951 is_tunnel_ipv6 = 0;
13953 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
13956 is_tunnel_ipv6 = 1;
13958 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
13961 is_tunnel_ipv6 = 1;
13965 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
13967 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
13968 crypto_alg >= IPSEC_CRYPTO_N_ALG)
13970 clib_warning ("unsupported crypto-alg: '%U'",
13971 format_ipsec_crypto_alg, crypto_alg);
13975 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13979 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
13981 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
13982 integ_alg >= IPSEC_INTEG_N_ALG)
13984 clib_warning ("unsupported integ-alg: '%U'",
13985 format_ipsec_integ_alg, integ_alg);
13989 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13993 clib_warning ("parse error '%U'", format_unformat_error, i);
13999 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14001 mp->sad_id = ntohl (sad_id);
14002 mp->is_add = is_add;
14003 mp->protocol = protocol;
14004 mp->spi = ntohl (spi);
14005 mp->is_tunnel = is_tunnel;
14006 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14007 mp->crypto_algorithm = crypto_alg;
14008 mp->integrity_algorithm = integ_alg;
14009 mp->crypto_key_length = vec_len (ck);
14010 mp->integrity_key_length = vec_len (ik);
14012 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14013 mp->crypto_key_length = sizeof (mp->crypto_key);
14015 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14016 mp->integrity_key_length = sizeof (mp->integrity_key);
14019 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14021 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14025 if (is_tunnel_ipv6)
14027 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14028 sizeof (ip6_address_t));
14029 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14030 sizeof (ip6_address_t));
14034 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14035 sizeof (ip4_address_t));
14036 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14037 sizeof (ip4_address_t));
14047 api_ipsec_sa_set_key (vat_main_t * vam)
14049 unformat_input_t *i = vam->input;
14050 vl_api_ipsec_sa_set_key_t *mp;
14052 u8 *ck = 0, *ik = 0;
14055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14057 if (unformat (i, "sa_id %d", &sa_id))
14059 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14061 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14065 clib_warning ("parse error '%U'", format_unformat_error, i);
14070 M (IPSEC_SA_SET_KEY, mp);
14072 mp->sa_id = ntohl (sa_id);
14073 mp->crypto_key_length = vec_len (ck);
14074 mp->integrity_key_length = vec_len (ik);
14076 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14077 mp->crypto_key_length = sizeof (mp->crypto_key);
14079 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14080 mp->integrity_key_length = sizeof (mp->integrity_key);
14083 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14085 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14093 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14095 unformat_input_t *i = vam->input;
14096 vl_api_ipsec_tunnel_if_add_del_t *mp;
14097 u32 local_spi = 0, remote_spi = 0;
14098 u32 crypto_alg = 0, integ_alg = 0;
14099 u8 *lck = NULL, *rck = NULL;
14100 u8 *lik = NULL, *rik = NULL;
14101 ip4_address_t local_ip = { {0} };
14102 ip4_address_t remote_ip = { {0} };
14105 u8 anti_replay = 0;
14108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14110 if (unformat (i, "del"))
14112 else if (unformat (i, "esn"))
14114 else if (unformat (i, "anti_replay"))
14116 else if (unformat (i, "local_spi %d", &local_spi))
14118 else if (unformat (i, "remote_spi %d", &remote_spi))
14120 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14122 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14124 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14127 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14129 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14131 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14135 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14137 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14138 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14140 errmsg ("unsupported crypto-alg: '%U'\n",
14141 format_ipsec_crypto_alg, crypto_alg);
14147 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14149 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14150 integ_alg >= IPSEC_INTEG_N_ALG)
14152 errmsg ("unsupported integ-alg: '%U'\n",
14153 format_ipsec_integ_alg, integ_alg);
14159 errmsg ("parse error '%U'\n", format_unformat_error, i);
14164 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14166 mp->is_add = is_add;
14168 mp->anti_replay = anti_replay;
14170 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14171 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14173 mp->local_spi = htonl (local_spi);
14174 mp->remote_spi = htonl (remote_spi);
14175 mp->crypto_alg = (u8) crypto_alg;
14177 mp->local_crypto_key_len = 0;
14180 mp->local_crypto_key_len = vec_len (lck);
14181 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14182 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14183 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14186 mp->remote_crypto_key_len = 0;
14189 mp->remote_crypto_key_len = vec_len (rck);
14190 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14191 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14192 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14195 mp->integ_alg = (u8) integ_alg;
14197 mp->local_integ_key_len = 0;
14200 mp->local_integ_key_len = vec_len (lik);
14201 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14202 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14203 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14206 mp->remote_integ_key_len = 0;
14209 mp->remote_integ_key_len = vec_len (rik);
14210 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14211 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14212 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14221 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14223 vat_main_t *vam = &vat_main;
14225 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14226 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14227 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14228 "tunnel_src_addr %U tunnel_dst_addr %U "
14229 "salt %u seq_outbound %lu last_seq_inbound %lu "
14230 "replay_window %lu total_data_size %lu\n",
14231 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14233 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14234 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14235 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14236 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14237 mp->tunnel_src_addr,
14238 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14239 mp->tunnel_dst_addr,
14241 clib_net_to_host_u64 (mp->seq_outbound),
14242 clib_net_to_host_u64 (mp->last_seq_inbound),
14243 clib_net_to_host_u64 (mp->replay_window),
14244 clib_net_to_host_u64 (mp->total_data_size));
14247 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14248 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14250 static void vl_api_ipsec_sa_details_t_handler_json
14251 (vl_api_ipsec_sa_details_t * mp)
14253 vat_main_t *vam = &vat_main;
14254 vat_json_node_t *node = NULL;
14255 struct in_addr src_ip4, dst_ip4;
14256 struct in6_addr src_ip6, dst_ip6;
14258 if (VAT_JSON_ARRAY != vam->json_tree.type)
14260 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14261 vat_json_init_array (&vam->json_tree);
14263 node = vat_json_array_add (&vam->json_tree);
14265 vat_json_init_object (node);
14266 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14267 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14268 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14269 vat_json_object_add_uint (node, "proto", mp->protocol);
14270 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14271 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14272 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14273 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14274 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14275 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14276 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14277 mp->crypto_key_len);
14278 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14279 mp->integ_key_len);
14280 if (mp->is_tunnel_ip6)
14282 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14283 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14284 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14285 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14289 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14290 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14291 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14292 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14294 vat_json_object_add_uint (node, "replay_window",
14295 clib_net_to_host_u64 (mp->replay_window));
14296 vat_json_object_add_uint (node, "total_data_size",
14297 clib_net_to_host_u64 (mp->total_data_size));
14302 api_ipsec_sa_dump (vat_main_t * vam)
14304 unformat_input_t *i = vam->input;
14305 vl_api_ipsec_sa_dump_t *mp;
14306 vl_api_control_ping_t *mp_ping;
14310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14312 if (unformat (i, "sa_id %d", &sa_id))
14316 clib_warning ("parse error '%U'", format_unformat_error, i);
14321 M (IPSEC_SA_DUMP, mp);
14323 mp->sa_id = ntohl (sa_id);
14327 /* Use a control ping for synchronization */
14328 M (CONTROL_PING, mp_ping);
14336 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14338 unformat_input_t *i = vam->input;
14339 vl_api_ipsec_tunnel_if_set_key_t *mp;
14340 u32 sw_if_index = ~0;
14341 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14348 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14351 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14352 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14354 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14355 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14356 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14357 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14359 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14360 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14361 else if (unformat (i, "%U", unformat_hex_string, &key))
14365 clib_warning ("parse error '%U'", format_unformat_error, i);
14370 if (sw_if_index == ~0)
14372 errmsg ("interface must be specified");
14376 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14378 errmsg ("key type must be specified");
14384 errmsg ("algorithm must be specified");
14388 if (vec_len (key) == 0)
14390 errmsg ("key must be specified");
14394 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14396 mp->sw_if_index = htonl (sw_if_index);
14398 mp->key_type = key_type;
14399 mp->key_len = vec_len (key);
14400 clib_memcpy (mp->key, key, vec_len (key));
14409 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14411 unformat_input_t *i = vam->input;
14412 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14413 u32 sw_if_index = ~0;
14415 u8 is_outbound = (u8) ~ 0;
14418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14420 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14422 else if (unformat (i, "sa_id %d", &sa_id))
14424 else if (unformat (i, "outbound"))
14426 else if (unformat (i, "inbound"))
14430 clib_warning ("parse error '%U'", format_unformat_error, i);
14435 if (sw_if_index == ~0)
14437 errmsg ("interface must be specified");
14443 errmsg ("SA ID must be specified");
14447 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14449 mp->sw_if_index = htonl (sw_if_index);
14450 mp->sa_id = htonl (sa_id);
14451 mp->is_outbound = is_outbound;
14460 api_ikev2_profile_add_del (vat_main_t * vam)
14462 unformat_input_t *i = vam->input;
14463 vl_api_ikev2_profile_add_del_t *mp;
14468 const char *valid_chars = "a-zA-Z0-9_";
14470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14472 if (unformat (i, "del"))
14474 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14475 vec_add1 (name, 0);
14478 errmsg ("parse error '%U'", format_unformat_error, i);
14483 if (!vec_len (name))
14485 errmsg ("profile name must be specified");
14489 if (vec_len (name) > 64)
14491 errmsg ("profile name too long");
14495 M (IKEV2_PROFILE_ADD_DEL, mp);
14497 clib_memcpy (mp->name, name, vec_len (name));
14498 mp->is_add = is_add;
14507 api_ikev2_profile_set_auth (vat_main_t * vam)
14509 unformat_input_t *i = vam->input;
14510 vl_api_ikev2_profile_set_auth_t *mp;
14513 u32 auth_method = 0;
14517 const char *valid_chars = "a-zA-Z0-9_";
14519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14521 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14522 vec_add1 (name, 0);
14523 else if (unformat (i, "auth_method %U",
14524 unformat_ikev2_auth_method, &auth_method))
14526 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
14528 else if (unformat (i, "auth_data %v", &data))
14532 errmsg ("parse error '%U'", format_unformat_error, i);
14537 if (!vec_len (name))
14539 errmsg ("profile name must be specified");
14543 if (vec_len (name) > 64)
14545 errmsg ("profile name too long");
14549 if (!vec_len (data))
14551 errmsg ("auth_data must be specified");
14557 errmsg ("auth_method must be specified");
14561 M (IKEV2_PROFILE_SET_AUTH, mp);
14563 mp->is_hex = is_hex;
14564 mp->auth_method = (u8) auth_method;
14565 mp->data_len = vec_len (data);
14566 clib_memcpy (mp->name, name, vec_len (name));
14567 clib_memcpy (mp->data, data, vec_len (data));
14577 api_ikev2_profile_set_id (vat_main_t * vam)
14579 unformat_input_t *i = vam->input;
14580 vl_api_ikev2_profile_set_id_t *mp;
14588 const char *valid_chars = "a-zA-Z0-9_";
14590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14592 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14593 vec_add1 (name, 0);
14594 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
14596 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
14598 data = vec_new (u8, 4);
14599 clib_memcpy (data, ip4.as_u8, 4);
14601 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
14603 else if (unformat (i, "id_data %v", &data))
14605 else if (unformat (i, "local"))
14607 else if (unformat (i, "remote"))
14611 errmsg ("parse error '%U'", format_unformat_error, i);
14616 if (!vec_len (name))
14618 errmsg ("profile name must be specified");
14622 if (vec_len (name) > 64)
14624 errmsg ("profile name too long");
14628 if (!vec_len (data))
14630 errmsg ("id_data must be specified");
14636 errmsg ("id_type must be specified");
14640 M (IKEV2_PROFILE_SET_ID, mp);
14642 mp->is_local = is_local;
14643 mp->id_type = (u8) id_type;
14644 mp->data_len = vec_len (data);
14645 clib_memcpy (mp->name, name, vec_len (name));
14646 clib_memcpy (mp->data, data, vec_len (data));
14656 api_ikev2_profile_set_ts (vat_main_t * vam)
14658 unformat_input_t *i = vam->input;
14659 vl_api_ikev2_profile_set_ts_t *mp;
14662 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
14663 ip4_address_t start_addr, end_addr;
14665 const char *valid_chars = "a-zA-Z0-9_";
14668 start_addr.as_u32 = 0;
14669 end_addr.as_u32 = (u32) ~ 0;
14671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14673 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
14674 vec_add1 (name, 0);
14675 else if (unformat (i, "protocol %d", &proto))
14677 else if (unformat (i, "start_port %d", &start_port))
14679 else if (unformat (i, "end_port %d", &end_port))
14682 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
14684 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
14686 else if (unformat (i, "local"))
14688 else if (unformat (i, "remote"))
14692 errmsg ("parse error '%U'", format_unformat_error, i);
14697 if (!vec_len (name))
14699 errmsg ("profile name must be specified");
14703 if (vec_len (name) > 64)
14705 errmsg ("profile name too long");
14709 M (IKEV2_PROFILE_SET_TS, mp);
14711 mp->is_local = is_local;
14712 mp->proto = (u8) proto;
14713 mp->start_port = (u16) start_port;
14714 mp->end_port = (u16) end_port;
14715 mp->start_addr = start_addr.as_u32;
14716 mp->end_addr = end_addr.as_u32;
14717 clib_memcpy (mp->name, name, vec_len (name));
14726 api_ikev2_set_local_key (vat_main_t * vam)
14728 unformat_input_t *i = vam->input;
14729 vl_api_ikev2_set_local_key_t *mp;
14733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14735 if (unformat (i, "file %v", &file))
14736 vec_add1 (file, 0);
14739 errmsg ("parse error '%U'", format_unformat_error, i);
14744 if (!vec_len (file))
14746 errmsg ("RSA key file must be specified");
14750 if (vec_len (file) > 256)
14752 errmsg ("file name too long");
14756 M (IKEV2_SET_LOCAL_KEY, mp);
14758 clib_memcpy (mp->key_file, file, vec_len (file));
14767 api_ikev2_set_responder (vat_main_t * vam)
14769 unformat_input_t *i = vam->input;
14770 vl_api_ikev2_set_responder_t *mp;
14773 u32 sw_if_index = ~0;
14774 ip4_address_t address;
14776 const char *valid_chars = "a-zA-Z0-9_";
14778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14781 (i, "%U interface %d address %U", unformat_token, valid_chars,
14782 &name, &sw_if_index, unformat_ip4_address, &address))
14783 vec_add1 (name, 0);
14786 errmsg ("parse error '%U'", format_unformat_error, i);
14791 if (!vec_len (name))
14793 errmsg ("profile name must be specified");
14797 if (vec_len (name) > 64)
14799 errmsg ("profile name too long");
14803 M (IKEV2_SET_RESPONDER, mp);
14805 clib_memcpy (mp->name, name, vec_len (name));
14808 mp->sw_if_index = sw_if_index;
14809 clib_memcpy (mp->address, &address, sizeof (address));
14817 api_ikev2_set_ike_transforms (vat_main_t * vam)
14819 unformat_input_t *i = vam->input;
14820 vl_api_ikev2_set_ike_transforms_t *mp;
14823 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
14825 const char *valid_chars = "a-zA-Z0-9_";
14827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14829 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
14830 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
14831 vec_add1 (name, 0);
14834 errmsg ("parse error '%U'", format_unformat_error, i);
14839 if (!vec_len (name))
14841 errmsg ("profile name must be specified");
14845 if (vec_len (name) > 64)
14847 errmsg ("profile name too long");
14851 M (IKEV2_SET_IKE_TRANSFORMS, mp);
14853 clib_memcpy (mp->name, name, vec_len (name));
14855 mp->crypto_alg = crypto_alg;
14856 mp->crypto_key_size = crypto_key_size;
14857 mp->integ_alg = integ_alg;
14858 mp->dh_group = dh_group;
14867 api_ikev2_set_esp_transforms (vat_main_t * vam)
14869 unformat_input_t *i = vam->input;
14870 vl_api_ikev2_set_esp_transforms_t *mp;
14873 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
14875 const char *valid_chars = "a-zA-Z0-9_";
14877 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14879 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
14880 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
14881 vec_add1 (name, 0);
14884 errmsg ("parse error '%U'", format_unformat_error, i);
14889 if (!vec_len (name))
14891 errmsg ("profile name must be specified");
14895 if (vec_len (name) > 64)
14897 errmsg ("profile name too long");
14901 M (IKEV2_SET_ESP_TRANSFORMS, mp);
14903 clib_memcpy (mp->name, name, vec_len (name));
14905 mp->crypto_alg = crypto_alg;
14906 mp->crypto_key_size = crypto_key_size;
14907 mp->integ_alg = integ_alg;
14908 mp->dh_group = dh_group;
14916 api_ikev2_set_sa_lifetime (vat_main_t * vam)
14918 unformat_input_t *i = vam->input;
14919 vl_api_ikev2_set_sa_lifetime_t *mp;
14922 u64 lifetime, lifetime_maxdata;
14923 u32 lifetime_jitter, handover;
14925 const char *valid_chars = "a-zA-Z0-9_";
14927 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14929 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
14930 &lifetime, &lifetime_jitter, &handover,
14931 &lifetime_maxdata))
14932 vec_add1 (name, 0);
14935 errmsg ("parse error '%U'", format_unformat_error, i);
14940 if (!vec_len (name))
14942 errmsg ("profile name must be specified");
14946 if (vec_len (name) > 64)
14948 errmsg ("profile name too long");
14952 M (IKEV2_SET_SA_LIFETIME, mp);
14954 clib_memcpy (mp->name, name, vec_len (name));
14956 mp->lifetime = lifetime;
14957 mp->lifetime_jitter = lifetime_jitter;
14958 mp->handover = handover;
14959 mp->lifetime_maxdata = lifetime_maxdata;
14967 api_ikev2_initiate_sa_init (vat_main_t * vam)
14969 unformat_input_t *i = vam->input;
14970 vl_api_ikev2_initiate_sa_init_t *mp;
14974 const char *valid_chars = "a-zA-Z0-9_";
14976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14978 if (unformat (i, "%U", unformat_token, valid_chars, &name))
14979 vec_add1 (name, 0);
14982 errmsg ("parse error '%U'", format_unformat_error, i);
14987 if (!vec_len (name))
14989 errmsg ("profile name must be specified");
14993 if (vec_len (name) > 64)
14995 errmsg ("profile name too long");
14999 M (IKEV2_INITIATE_SA_INIT, mp);
15001 clib_memcpy (mp->name, name, vec_len (name));
15010 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15012 unformat_input_t *i = vam->input;
15013 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15020 if (unformat (i, "%lx", &ispi))
15024 errmsg ("parse error '%U'", format_unformat_error, i);
15029 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15039 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15041 unformat_input_t *i = vam->input;
15042 vl_api_ikev2_initiate_del_child_sa_t *mp;
15047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15049 if (unformat (i, "%x", &ispi))
15053 errmsg ("parse error '%U'", format_unformat_error, i);
15058 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15068 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15070 unformat_input_t *i = vam->input;
15071 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15078 if (unformat (i, "%x", &ispi))
15082 errmsg ("parse error '%U'", format_unformat_error, i);
15087 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15100 api_map_add_domain (vat_main_t * vam)
15102 unformat_input_t *i = vam->input;
15103 vl_api_map_add_domain_t *mp;
15105 ip4_address_t ip4_prefix;
15106 ip6_address_t ip6_prefix;
15107 ip6_address_t ip6_src;
15108 u32 num_m_args = 0;
15109 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15110 0, psid_length = 0;
15111 u8 is_translation = 0;
15113 u32 ip6_src_len = 128;
15116 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15118 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15119 &ip4_prefix, &ip4_prefix_len))
15121 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15122 &ip6_prefix, &ip6_prefix_len))
15126 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15129 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15131 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15133 else if (unformat (i, "psid-offset %d", &psid_offset))
15135 else if (unformat (i, "psid-len %d", &psid_length))
15137 else if (unformat (i, "mtu %d", &mtu))
15139 else if (unformat (i, "map-t"))
15140 is_translation = 1;
15143 clib_warning ("parse error '%U'", format_unformat_error, i);
15148 if (num_m_args < 3)
15150 errmsg ("mandatory argument(s) missing");
15154 /* Construct the API message */
15155 M (MAP_ADD_DOMAIN, mp);
15157 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15158 mp->ip4_prefix_len = ip4_prefix_len;
15160 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15161 mp->ip6_prefix_len = ip6_prefix_len;
15163 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15164 mp->ip6_src_prefix_len = ip6_src_len;
15166 mp->ea_bits_len = ea_bits_len;
15167 mp->psid_offset = psid_offset;
15168 mp->psid_length = psid_length;
15169 mp->is_translation = is_translation;
15170 mp->mtu = htons (mtu);
15175 /* Wait for a reply, return good/bad news */
15181 api_map_del_domain (vat_main_t * vam)
15183 unformat_input_t *i = vam->input;
15184 vl_api_map_del_domain_t *mp;
15186 u32 num_m_args = 0;
15190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15192 if (unformat (i, "index %d", &index))
15196 clib_warning ("parse error '%U'", format_unformat_error, i);
15201 if (num_m_args != 1)
15203 errmsg ("mandatory argument(s) missing");
15207 /* Construct the API message */
15208 M (MAP_DEL_DOMAIN, mp);
15210 mp->index = ntohl (index);
15215 /* Wait for a reply, return good/bad news */
15221 api_map_add_del_rule (vat_main_t * vam)
15223 unformat_input_t *i = vam->input;
15224 vl_api_map_add_del_rule_t *mp;
15226 ip6_address_t ip6_dst;
15227 u32 num_m_args = 0, index, psid = 0;
15230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15232 if (unformat (i, "index %d", &index))
15234 else if (unformat (i, "psid %d", &psid))
15236 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15238 else if (unformat (i, "del"))
15244 clib_warning ("parse error '%U'", format_unformat_error, i);
15249 /* Construct the API message */
15250 M (MAP_ADD_DEL_RULE, mp);
15252 mp->index = ntohl (index);
15253 mp->is_add = is_add;
15254 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15255 mp->psid = ntohs (psid);
15260 /* Wait for a reply, return good/bad news */
15266 api_map_domain_dump (vat_main_t * vam)
15268 vl_api_map_domain_dump_t *mp;
15269 vl_api_control_ping_t *mp_ping;
15272 /* Construct the API message */
15273 M (MAP_DOMAIN_DUMP, mp);
15278 /* Use a control ping for synchronization */
15279 MPING (CONTROL_PING, mp_ping);
15287 api_map_rule_dump (vat_main_t * vam)
15289 unformat_input_t *i = vam->input;
15290 vl_api_map_rule_dump_t *mp;
15291 vl_api_control_ping_t *mp_ping;
15292 u32 domain_index = ~0;
15295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15297 if (unformat (i, "index %u", &domain_index))
15303 if (domain_index == ~0)
15305 clib_warning ("parse error: domain index expected");
15309 /* Construct the API message */
15310 M (MAP_RULE_DUMP, mp);
15312 mp->domain_index = htonl (domain_index);
15317 /* Use a control ping for synchronization */
15318 MPING (CONTROL_PING, mp_ping);
15325 static void vl_api_map_add_domain_reply_t_handler
15326 (vl_api_map_add_domain_reply_t * mp)
15328 vat_main_t *vam = &vat_main;
15329 i32 retval = ntohl (mp->retval);
15331 if (vam->async_mode)
15333 vam->async_errors += (retval < 0);
15337 vam->retval = retval;
15338 vam->result_ready = 1;
15342 static void vl_api_map_add_domain_reply_t_handler_json
15343 (vl_api_map_add_domain_reply_t * mp)
15345 vat_main_t *vam = &vat_main;
15346 vat_json_node_t node;
15348 vat_json_init_object (&node);
15349 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15350 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15352 vat_json_print (vam->ofp, &node);
15353 vat_json_free (&node);
15355 vam->retval = ntohl (mp->retval);
15356 vam->result_ready = 1;
15360 api_get_first_msg_id (vat_main_t * vam)
15362 vl_api_get_first_msg_id_t *mp;
15363 unformat_input_t *i = vam->input;
15368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15370 if (unformat (i, "client %s", &name))
15378 errmsg ("missing client name");
15381 vec_add1 (name, 0);
15383 if (vec_len (name) > 63)
15385 errmsg ("client name too long");
15389 M (GET_FIRST_MSG_ID, mp);
15390 clib_memcpy (mp->name, name, vec_len (name));
15397 api_cop_interface_enable_disable (vat_main_t * vam)
15399 unformat_input_t *line_input = vam->input;
15400 vl_api_cop_interface_enable_disable_t *mp;
15401 u32 sw_if_index = ~0;
15402 u8 enable_disable = 1;
15405 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15407 if (unformat (line_input, "disable"))
15408 enable_disable = 0;
15409 if (unformat (line_input, "enable"))
15410 enable_disable = 1;
15411 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15412 vam, &sw_if_index))
15414 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15420 if (sw_if_index == ~0)
15422 errmsg ("missing interface name or sw_if_index");
15426 /* Construct the API message */
15427 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15428 mp->sw_if_index = ntohl (sw_if_index);
15429 mp->enable_disable = enable_disable;
15433 /* Wait for the reply */
15439 api_cop_whitelist_enable_disable (vat_main_t * vam)
15441 unformat_input_t *line_input = vam->input;
15442 vl_api_cop_whitelist_enable_disable_t *mp;
15443 u32 sw_if_index = ~0;
15444 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15448 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15450 if (unformat (line_input, "ip4"))
15452 else if (unformat (line_input, "ip6"))
15454 else if (unformat (line_input, "default"))
15456 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15457 vam, &sw_if_index))
15459 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15461 else if (unformat (line_input, "fib-id %d", &fib_id))
15467 if (sw_if_index == ~0)
15469 errmsg ("missing interface name or sw_if_index");
15473 /* Construct the API message */
15474 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15475 mp->sw_if_index = ntohl (sw_if_index);
15476 mp->fib_id = ntohl (fib_id);
15479 mp->default_cop = default_cop;
15483 /* Wait for the reply */
15489 api_get_node_graph (vat_main_t * vam)
15491 vl_api_get_node_graph_t *mp;
15494 M (GET_NODE_GRAPH, mp);
15498 /* Wait for the reply */
15504 /** Used for parsing LISP eids */
15505 typedef CLIB_PACKED(struct{
15506 u8 addr[16]; /**< eid address */
15507 u32 len; /**< prefix length if IP */
15508 u8 type; /**< type of eid */
15513 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15515 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15517 memset (a, 0, sizeof (a[0]));
15519 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15521 a->type = 0; /* ipv4 type */
15523 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15525 a->type = 1; /* ipv6 type */
15527 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15529 a->type = 2; /* mac type */
15531 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15533 a->type = 3; /* NSH type */
15534 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15535 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15542 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15551 lisp_eid_size_vat (u8 type)
15568 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15570 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15574 api_one_add_del_locator_set (vat_main_t * vam)
15576 unformat_input_t *input = vam->input;
15577 vl_api_one_add_del_locator_set_t *mp;
15579 u8 *locator_set_name = NULL;
15580 u8 locator_set_name_set = 0;
15581 vl_api_local_locator_t locator, *locators = 0;
15582 u32 sw_if_index, priority, weight;
15586 /* Parse args required to build the message */
15587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15589 if (unformat (input, "del"))
15593 else if (unformat (input, "locator-set %s", &locator_set_name))
15595 locator_set_name_set = 1;
15597 else if (unformat (input, "sw_if_index %u p %u w %u",
15598 &sw_if_index, &priority, &weight))
15600 locator.sw_if_index = htonl (sw_if_index);
15601 locator.priority = priority;
15602 locator.weight = weight;
15603 vec_add1 (locators, locator);
15607 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15608 &sw_if_index, &priority, &weight))
15610 locator.sw_if_index = htonl (sw_if_index);
15611 locator.priority = priority;
15612 locator.weight = weight;
15613 vec_add1 (locators, locator);
15619 if (locator_set_name_set == 0)
15621 errmsg ("missing locator-set name");
15622 vec_free (locators);
15626 if (vec_len (locator_set_name) > 64)
15628 errmsg ("locator-set name too long");
15629 vec_free (locator_set_name);
15630 vec_free (locators);
15633 vec_add1 (locator_set_name, 0);
15635 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15637 /* Construct the API message */
15638 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15640 mp->is_add = is_add;
15641 clib_memcpy (mp->locator_set_name, locator_set_name,
15642 vec_len (locator_set_name));
15643 vec_free (locator_set_name);
15645 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15647 clib_memcpy (mp->locators, locators, data_len);
15648 vec_free (locators);
15653 /* Wait for a reply... */
15658 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15661 api_one_add_del_locator (vat_main_t * vam)
15663 unformat_input_t *input = vam->input;
15664 vl_api_one_add_del_locator_t *mp;
15665 u32 tmp_if_index = ~0;
15666 u32 sw_if_index = ~0;
15667 u8 sw_if_index_set = 0;
15668 u8 sw_if_index_if_name_set = 0;
15670 u8 priority_set = 0;
15674 u8 *locator_set_name = NULL;
15675 u8 locator_set_name_set = 0;
15678 /* Parse args required to build the message */
15679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15681 if (unformat (input, "del"))
15685 else if (unformat (input, "locator-set %s", &locator_set_name))
15687 locator_set_name_set = 1;
15689 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15692 sw_if_index_if_name_set = 1;
15693 sw_if_index = tmp_if_index;
15695 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15697 sw_if_index_set = 1;
15698 sw_if_index = tmp_if_index;
15700 else if (unformat (input, "p %d", &priority))
15704 else if (unformat (input, "w %d", &weight))
15712 if (locator_set_name_set == 0)
15714 errmsg ("missing locator-set name");
15718 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15720 errmsg ("missing sw_if_index");
15721 vec_free (locator_set_name);
15725 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15727 errmsg ("cannot use both params interface name and sw_if_index");
15728 vec_free (locator_set_name);
15732 if (priority_set == 0)
15734 errmsg ("missing locator-set priority");
15735 vec_free (locator_set_name);
15739 if (weight_set == 0)
15741 errmsg ("missing locator-set weight");
15742 vec_free (locator_set_name);
15746 if (vec_len (locator_set_name) > 64)
15748 errmsg ("locator-set name too long");
15749 vec_free (locator_set_name);
15752 vec_add1 (locator_set_name, 0);
15754 /* Construct the API message */
15755 M (ONE_ADD_DEL_LOCATOR, mp);
15757 mp->is_add = is_add;
15758 mp->sw_if_index = ntohl (sw_if_index);
15759 mp->priority = priority;
15760 mp->weight = weight;
15761 clib_memcpy (mp->locator_set_name, locator_set_name,
15762 vec_len (locator_set_name));
15763 vec_free (locator_set_name);
15768 /* Wait for a reply... */
15773 #define api_lisp_add_del_locator api_one_add_del_locator
15776 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15778 u32 *key_id = va_arg (*args, u32 *);
15781 if (unformat (input, "%s", &s))
15783 if (!strcmp ((char *) s, "sha1"))
15784 key_id[0] = HMAC_SHA_1_96;
15785 else if (!strcmp ((char *) s, "sha256"))
15786 key_id[0] = HMAC_SHA_256_128;
15789 clib_warning ("invalid key_id: '%s'", s);
15790 key_id[0] = HMAC_NO_KEY;
15801 api_one_add_del_local_eid (vat_main_t * vam)
15803 unformat_input_t *input = vam->input;
15804 vl_api_one_add_del_local_eid_t *mp;
15807 lisp_eid_vat_t _eid, *eid = &_eid;
15808 u8 *locator_set_name = 0;
15809 u8 locator_set_name_set = 0;
15815 /* Parse args required to build the message */
15816 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15818 if (unformat (input, "del"))
15822 else if (unformat (input, "vni %d", &vni))
15826 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15830 else if (unformat (input, "locator-set %s", &locator_set_name))
15832 locator_set_name_set = 1;
15834 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15836 else if (unformat (input, "secret-key %_%v%_", &key))
15842 if (locator_set_name_set == 0)
15844 errmsg ("missing locator-set name");
15850 errmsg ("EID address not set!");
15851 vec_free (locator_set_name);
15855 if (key && (0 == key_id))
15857 errmsg ("invalid key_id!");
15861 if (vec_len (key) > 64)
15863 errmsg ("key too long");
15868 if (vec_len (locator_set_name) > 64)
15870 errmsg ("locator-set name too long");
15871 vec_free (locator_set_name);
15874 vec_add1 (locator_set_name, 0);
15876 /* Construct the API message */
15877 M (ONE_ADD_DEL_LOCAL_EID, mp);
15879 mp->is_add = is_add;
15880 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15881 mp->eid_type = eid->type;
15882 mp->prefix_len = eid->len;
15883 mp->vni = clib_host_to_net_u32 (vni);
15884 mp->key_id = clib_host_to_net_u16 (key_id);
15885 clib_memcpy (mp->locator_set_name, locator_set_name,
15886 vec_len (locator_set_name));
15887 clib_memcpy (mp->key, key, vec_len (key));
15889 vec_free (locator_set_name);
15895 /* Wait for a reply... */
15900 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15903 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15905 u32 dp_table = 0, vni = 0;;
15906 unformat_input_t *input = vam->input;
15907 vl_api_gpe_add_del_fwd_entry_t *mp;
15909 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15910 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15911 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15912 u32 action = ~0, w;
15913 ip4_address_t rmt_rloc4, lcl_rloc4;
15914 ip6_address_t rmt_rloc6, lcl_rloc6;
15915 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15918 memset (&rloc, 0, sizeof (rloc));
15920 /* Parse args required to build the message */
15921 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15923 if (unformat (input, "del"))
15925 else if (unformat (input, "add"))
15927 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15931 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15935 else if (unformat (input, "vrf %d", &dp_table))
15937 else if (unformat (input, "bd %d", &dp_table))
15939 else if (unformat (input, "vni %d", &vni))
15941 else if (unformat (input, "w %d", &w))
15945 errmsg ("No RLOC configured for setting priority/weight!");
15948 curr_rloc->weight = w;
15950 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15951 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15955 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15957 vec_add1 (lcl_locs, rloc);
15959 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15960 vec_add1 (rmt_locs, rloc);
15961 /* weight saved in rmt loc */
15962 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15964 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15965 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15968 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15970 vec_add1 (lcl_locs, rloc);
15972 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15973 vec_add1 (rmt_locs, rloc);
15974 /* weight saved in rmt loc */
15975 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15977 else if (unformat (input, "action %d", &action))
15983 clib_warning ("parse error '%U'", format_unformat_error, input);
15990 errmsg ("remote eid addresses not set");
15994 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15996 errmsg ("eid types don't match");
16000 if (0 == rmt_locs && (u32) ~ 0 == action)
16002 errmsg ("action not set for negative mapping");
16006 /* Construct the API message */
16007 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16008 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16010 mp->is_add = is_add;
16011 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16012 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16013 mp->eid_type = rmt_eid->type;
16014 mp->dp_table = clib_host_to_net_u32 (dp_table);
16015 mp->vni = clib_host_to_net_u32 (vni);
16016 mp->rmt_len = rmt_eid->len;
16017 mp->lcl_len = lcl_eid->len;
16018 mp->action = action;
16020 if (0 != rmt_locs && 0 != lcl_locs)
16022 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16023 clib_memcpy (mp->locs, lcl_locs,
16024 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16026 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16027 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16028 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16030 vec_free (lcl_locs);
16031 vec_free (rmt_locs);
16036 /* Wait for a reply... */
16042 api_one_add_del_map_server (vat_main_t * vam)
16044 unformat_input_t *input = vam->input;
16045 vl_api_one_add_del_map_server_t *mp;
16049 ip4_address_t ipv4;
16050 ip6_address_t ipv6;
16053 /* Parse args required to build the message */
16054 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16056 if (unformat (input, "del"))
16060 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16064 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16072 if (ipv4_set && ipv6_set)
16074 errmsg ("both eid v4 and v6 addresses set");
16078 if (!ipv4_set && !ipv6_set)
16080 errmsg ("eid addresses not set");
16084 /* Construct the API message */
16085 M (ONE_ADD_DEL_MAP_SERVER, mp);
16087 mp->is_add = is_add;
16091 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16096 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16102 /* Wait for a reply... */
16107 #define api_lisp_add_del_map_server api_one_add_del_map_server
16110 api_one_add_del_map_resolver (vat_main_t * vam)
16112 unformat_input_t *input = vam->input;
16113 vl_api_one_add_del_map_resolver_t *mp;
16117 ip4_address_t ipv4;
16118 ip6_address_t ipv6;
16121 /* Parse args required to build the message */
16122 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16124 if (unformat (input, "del"))
16128 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16132 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16140 if (ipv4_set && ipv6_set)
16142 errmsg ("both eid v4 and v6 addresses set");
16146 if (!ipv4_set && !ipv6_set)
16148 errmsg ("eid addresses not set");
16152 /* Construct the API message */
16153 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16155 mp->is_add = is_add;
16159 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16164 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16170 /* Wait for a reply... */
16175 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16178 api_lisp_gpe_enable_disable (vat_main_t * vam)
16180 unformat_input_t *input = vam->input;
16181 vl_api_gpe_enable_disable_t *mp;
16186 /* Parse args required to build the message */
16187 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16189 if (unformat (input, "enable"))
16194 else if (unformat (input, "disable"))
16205 errmsg ("Value not set");
16209 /* Construct the API message */
16210 M (GPE_ENABLE_DISABLE, mp);
16217 /* Wait for a reply... */
16223 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16225 unformat_input_t *input = vam->input;
16226 vl_api_one_rloc_probe_enable_disable_t *mp;
16231 /* Parse args required to build the message */
16232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16234 if (unformat (input, "enable"))
16239 else if (unformat (input, "disable"))
16247 errmsg ("Value not set");
16251 /* Construct the API message */
16252 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16254 mp->is_enabled = is_en;
16259 /* Wait for a reply... */
16264 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16267 api_one_map_register_enable_disable (vat_main_t * vam)
16269 unformat_input_t *input = vam->input;
16270 vl_api_one_map_register_enable_disable_t *mp;
16275 /* Parse args required to build the message */
16276 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16278 if (unformat (input, "enable"))
16283 else if (unformat (input, "disable"))
16291 errmsg ("Value not set");
16295 /* Construct the API message */
16296 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16298 mp->is_enabled = is_en;
16303 /* Wait for a reply... */
16308 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16311 api_one_enable_disable (vat_main_t * vam)
16313 unformat_input_t *input = vam->input;
16314 vl_api_one_enable_disable_t *mp;
16319 /* Parse args required to build the message */
16320 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16322 if (unformat (input, "enable"))
16327 else if (unformat (input, "disable"))
16337 errmsg ("Value not set");
16341 /* Construct the API message */
16342 M (ONE_ENABLE_DISABLE, mp);
16349 /* Wait for a reply... */
16354 #define api_lisp_enable_disable api_one_enable_disable
16357 api_show_one_map_register_state (vat_main_t * vam)
16359 vl_api_show_one_map_register_state_t *mp;
16362 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16367 /* wait for reply */
16372 #define api_show_lisp_map_register_state api_show_one_map_register_state
16375 api_show_one_rloc_probe_state (vat_main_t * vam)
16377 vl_api_show_one_rloc_probe_state_t *mp;
16380 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16385 /* wait for reply */
16390 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16393 api_one_add_del_ndp_entry (vat_main_t * vam)
16395 vl_api_one_add_del_ndp_entry_t *mp;
16396 unformat_input_t *input = vam->input;
16401 u8 mac[6] = { 0, };
16402 u8 ip6[16] = { 0, };
16406 /* Parse args required to build the message */
16407 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16409 if (unformat (input, "del"))
16411 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16413 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16415 else if (unformat (input, "bd %d", &bd))
16419 errmsg ("parse error '%U'", format_unformat_error, input);
16424 if (!bd_set || !ip_set || (!mac_set && is_add))
16426 errmsg ("Missing BD, IP or MAC!");
16430 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16431 mp->is_add = is_add;
16432 clib_memcpy (mp->mac, mac, 6);
16433 mp->bd = clib_host_to_net_u32 (bd);
16434 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16439 /* wait for reply */
16445 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16447 vl_api_one_add_del_l2_arp_entry_t *mp;
16448 unformat_input_t *input = vam->input;
16453 u8 mac[6] = { 0, };
16454 u32 ip4 = 0, bd = ~0;
16457 /* Parse args required to build the message */
16458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16460 if (unformat (input, "del"))
16462 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16464 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16466 else if (unformat (input, "bd %d", &bd))
16470 errmsg ("parse error '%U'", format_unformat_error, input);
16475 if (!bd_set || !ip_set || (!mac_set && is_add))
16477 errmsg ("Missing BD, IP or MAC!");
16481 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16482 mp->is_add = is_add;
16483 clib_memcpy (mp->mac, mac, 6);
16484 mp->bd = clib_host_to_net_u32 (bd);
16490 /* wait for reply */
16496 api_one_ndp_bd_get (vat_main_t * vam)
16498 vl_api_one_ndp_bd_get_t *mp;
16501 M (ONE_NDP_BD_GET, mp);
16506 /* wait for reply */
16512 api_one_ndp_entries_get (vat_main_t * vam)
16514 vl_api_one_ndp_entries_get_t *mp;
16515 unformat_input_t *input = vam->input;
16520 /* Parse args required to build the message */
16521 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16523 if (unformat (input, "bd %d", &bd))
16527 errmsg ("parse error '%U'", format_unformat_error, input);
16534 errmsg ("Expected bridge domain!");
16538 M (ONE_NDP_ENTRIES_GET, mp);
16539 mp->bd = clib_host_to_net_u32 (bd);
16544 /* wait for reply */
16550 api_one_l2_arp_bd_get (vat_main_t * vam)
16552 vl_api_one_l2_arp_bd_get_t *mp;
16555 M (ONE_L2_ARP_BD_GET, mp);
16560 /* wait for reply */
16566 api_one_l2_arp_entries_get (vat_main_t * vam)
16568 vl_api_one_l2_arp_entries_get_t *mp;
16569 unformat_input_t *input = vam->input;
16574 /* Parse args required to build the message */
16575 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16577 if (unformat (input, "bd %d", &bd))
16581 errmsg ("parse error '%U'", format_unformat_error, input);
16588 errmsg ("Expected bridge domain!");
16592 M (ONE_L2_ARP_ENTRIES_GET, mp);
16593 mp->bd = clib_host_to_net_u32 (bd);
16598 /* wait for reply */
16604 api_one_stats_enable_disable (vat_main_t * vam)
16606 vl_api_one_stats_enable_disable_t *mp;
16607 unformat_input_t *input = vam->input;
16612 /* Parse args required to build the message */
16613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16615 if (unformat (input, "enable"))
16620 else if (unformat (input, "disable"))
16630 errmsg ("Value not set");
16634 M (ONE_STATS_ENABLE_DISABLE, mp);
16640 /* wait for reply */
16646 api_show_one_stats_enable_disable (vat_main_t * vam)
16648 vl_api_show_one_stats_enable_disable_t *mp;
16651 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16656 /* wait for reply */
16662 api_show_one_map_request_mode (vat_main_t * vam)
16664 vl_api_show_one_map_request_mode_t *mp;
16667 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16672 /* wait for reply */
16677 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16680 api_one_map_request_mode (vat_main_t * vam)
16682 unformat_input_t *input = vam->input;
16683 vl_api_one_map_request_mode_t *mp;
16687 /* Parse args required to build the message */
16688 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16690 if (unformat (input, "dst-only"))
16692 else if (unformat (input, "src-dst"))
16696 errmsg ("parse error '%U'", format_unformat_error, input);
16701 M (ONE_MAP_REQUEST_MODE, mp);
16708 /* wait for reply */
16713 #define api_lisp_map_request_mode api_one_map_request_mode
16716 * Enable/disable ONE proxy ITR.
16718 * @param vam vpp API test context
16719 * @return return code
16722 api_one_pitr_set_locator_set (vat_main_t * vam)
16724 u8 ls_name_set = 0;
16725 unformat_input_t *input = vam->input;
16726 vl_api_one_pitr_set_locator_set_t *mp;
16731 /* Parse args required to build the message */
16732 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16734 if (unformat (input, "del"))
16736 else if (unformat (input, "locator-set %s", &ls_name))
16740 errmsg ("parse error '%U'", format_unformat_error, input);
16747 errmsg ("locator-set name not set!");
16751 M (ONE_PITR_SET_LOCATOR_SET, mp);
16753 mp->is_add = is_add;
16754 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16755 vec_free (ls_name);
16760 /* wait for reply */
16765 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16768 api_one_nsh_set_locator_set (vat_main_t * vam)
16770 u8 ls_name_set = 0;
16771 unformat_input_t *input = vam->input;
16772 vl_api_one_nsh_set_locator_set_t *mp;
16777 /* Parse args required to build the message */
16778 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16780 if (unformat (input, "del"))
16782 else if (unformat (input, "ls %s", &ls_name))
16786 errmsg ("parse error '%U'", format_unformat_error, input);
16791 if (!ls_name_set && is_add)
16793 errmsg ("locator-set name not set!");
16797 M (ONE_NSH_SET_LOCATOR_SET, mp);
16799 mp->is_add = is_add;
16800 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16801 vec_free (ls_name);
16806 /* wait for reply */
16812 api_show_one_pitr (vat_main_t * vam)
16814 vl_api_show_one_pitr_t *mp;
16817 if (!vam->json_output)
16819 print (vam->ofp, "%=20s", "lisp status:");
16822 M (SHOW_ONE_PITR, mp);
16826 /* Wait for a reply... */
16831 #define api_show_lisp_pitr api_show_one_pitr
16834 api_one_use_petr (vat_main_t * vam)
16836 unformat_input_t *input = vam->input;
16837 vl_api_one_use_petr_t *mp;
16842 memset (&ip, 0, sizeof (ip));
16844 /* Parse args required to build the message */
16845 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16847 if (unformat (input, "disable"))
16850 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16853 ip_addr_version (&ip) = IP4;
16856 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16859 ip_addr_version (&ip) = IP6;
16863 errmsg ("parse error '%U'", format_unformat_error, input);
16868 M (ONE_USE_PETR, mp);
16870 mp->is_add = is_add;
16873 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
16875 clib_memcpy (mp->address, &ip, 4);
16877 clib_memcpy (mp->address, &ip, 16);
16883 /* wait for reply */
16888 #define api_lisp_use_petr api_one_use_petr
16891 api_show_one_nsh_mapping (vat_main_t * vam)
16893 vl_api_show_one_use_petr_t *mp;
16896 if (!vam->json_output)
16898 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16901 M (SHOW_ONE_NSH_MAPPING, mp);
16905 /* Wait for a reply... */
16911 api_show_one_use_petr (vat_main_t * vam)
16913 vl_api_show_one_use_petr_t *mp;
16916 if (!vam->json_output)
16918 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16921 M (SHOW_ONE_USE_PETR, mp);
16925 /* Wait for a reply... */
16930 #define api_show_lisp_use_petr api_show_one_use_petr
16933 * Add/delete mapping between vni and vrf
16936 api_one_eid_table_add_del_map (vat_main_t * vam)
16938 unformat_input_t *input = vam->input;
16939 vl_api_one_eid_table_add_del_map_t *mp;
16940 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16941 u32 vni, vrf, bd_index;
16944 /* Parse args required to build the message */
16945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16947 if (unformat (input, "del"))
16949 else if (unformat (input, "vrf %d", &vrf))
16951 else if (unformat (input, "bd_index %d", &bd_index))
16953 else if (unformat (input, "vni %d", &vni))
16959 if (!vni_set || (!vrf_set && !bd_index_set))
16961 errmsg ("missing arguments!");
16965 if (vrf_set && bd_index_set)
16967 errmsg ("error: both vrf and bd entered!");
16971 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16973 mp->is_add = is_add;
16974 mp->vni = htonl (vni);
16975 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16976 mp->is_l2 = bd_index_set;
16981 /* wait for reply */
16986 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16989 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16991 u32 *action = va_arg (*args, u32 *);
16994 if (unformat (input, "%s", &s))
16996 if (!strcmp ((char *) s, "no-action"))
16998 else if (!strcmp ((char *) s, "natively-forward"))
17000 else if (!strcmp ((char *) s, "send-map-request"))
17002 else if (!strcmp ((char *) s, "drop"))
17006 clib_warning ("invalid action: '%s'", s);
17018 * Add/del remote mapping to/from ONE control plane
17020 * @param vam vpp API test context
17021 * @return return code
17024 api_one_add_del_remote_mapping (vat_main_t * vam)
17026 unformat_input_t *input = vam->input;
17027 vl_api_one_add_del_remote_mapping_t *mp;
17029 lisp_eid_vat_t _eid, *eid = &_eid;
17030 lisp_eid_vat_t _seid, *seid = &_seid;
17031 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17032 u32 action = ~0, p, w, data_len;
17033 ip4_address_t rloc4;
17034 ip6_address_t rloc6;
17035 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17038 memset (&rloc, 0, sizeof (rloc));
17040 /* Parse args required to build the message */
17041 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17043 if (unformat (input, "del-all"))
17047 else if (unformat (input, "del"))
17051 else if (unformat (input, "add"))
17055 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17059 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17063 else if (unformat (input, "vni %d", &vni))
17067 else if (unformat (input, "p %d w %d", &p, &w))
17071 errmsg ("No RLOC configured for setting priority/weight!");
17074 curr_rloc->priority = p;
17075 curr_rloc->weight = w;
17077 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17080 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17081 vec_add1 (rlocs, rloc);
17082 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17084 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17087 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17088 vec_add1 (rlocs, rloc);
17089 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17091 else if (unformat (input, "action %U",
17092 unformat_negative_mapping_action, &action))
17098 clib_warning ("parse error '%U'", format_unformat_error, input);
17105 errmsg ("missing params!");
17109 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17111 errmsg ("no action set for negative map-reply!");
17115 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17117 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17118 mp->is_add = is_add;
17119 mp->vni = htonl (vni);
17120 mp->action = (u8) action;
17121 mp->is_src_dst = seid_set;
17122 mp->eid_len = eid->len;
17123 mp->seid_len = seid->len;
17124 mp->del_all = del_all;
17125 mp->eid_type = eid->type;
17126 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17127 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17129 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17130 clib_memcpy (mp->rlocs, rlocs, data_len);
17136 /* Wait for a reply... */
17141 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17144 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17145 * forwarding entries in data-plane accordingly.
17147 * @param vam vpp API test context
17148 * @return return code
17151 api_one_add_del_adjacency (vat_main_t * vam)
17153 unformat_input_t *input = vam->input;
17154 vl_api_one_add_del_adjacency_t *mp;
17156 ip4_address_t leid4, reid4;
17157 ip6_address_t leid6, reid6;
17158 u8 reid_mac[6] = { 0 };
17159 u8 leid_mac[6] = { 0 };
17160 u8 reid_type, leid_type;
17161 u32 leid_len = 0, reid_len = 0, len;
17165 leid_type = reid_type = (u8) ~ 0;
17167 /* Parse args required to build the message */
17168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17170 if (unformat (input, "del"))
17174 else if (unformat (input, "add"))
17178 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17181 reid_type = 0; /* ipv4 */
17184 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17187 reid_type = 1; /* ipv6 */
17190 else if (unformat (input, "reid %U", unformat_ethernet_address,
17193 reid_type = 2; /* mac */
17195 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17198 leid_type = 0; /* ipv4 */
17201 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17204 leid_type = 1; /* ipv6 */
17207 else if (unformat (input, "leid %U", unformat_ethernet_address,
17210 leid_type = 2; /* mac */
17212 else if (unformat (input, "vni %d", &vni))
17218 errmsg ("parse error '%U'", format_unformat_error, input);
17223 if ((u8) ~ 0 == reid_type)
17225 errmsg ("missing params!");
17229 if (leid_type != reid_type)
17231 errmsg ("remote and local EIDs are of different types!");
17235 M (ONE_ADD_DEL_ADJACENCY, mp);
17236 mp->is_add = is_add;
17237 mp->vni = htonl (vni);
17238 mp->leid_len = leid_len;
17239 mp->reid_len = reid_len;
17240 mp->eid_type = reid_type;
17242 switch (mp->eid_type)
17245 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17246 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17249 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17250 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17253 clib_memcpy (mp->leid, leid_mac, 6);
17254 clib_memcpy (mp->reid, reid_mac, 6);
17257 errmsg ("unknown EID type %d!", mp->eid_type);
17264 /* Wait for a reply... */
17269 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17272 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17274 u32 *mode = va_arg (*args, u32 *);
17276 if (unformat (input, "lisp"))
17278 else if (unformat (input, "vxlan"))
17287 api_gpe_get_encap_mode (vat_main_t * vam)
17289 vl_api_gpe_get_encap_mode_t *mp;
17292 /* Construct the API message */
17293 M (GPE_GET_ENCAP_MODE, mp);
17298 /* Wait for a reply... */
17304 api_gpe_set_encap_mode (vat_main_t * vam)
17306 unformat_input_t *input = vam->input;
17307 vl_api_gpe_set_encap_mode_t *mp;
17311 /* Parse args required to build the message */
17312 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17314 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17320 /* Construct the API message */
17321 M (GPE_SET_ENCAP_MODE, mp);
17328 /* Wait for a reply... */
17334 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17336 unformat_input_t *input = vam->input;
17337 vl_api_gpe_add_del_iface_t *mp;
17338 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17339 u32 dp_table = 0, vni = 0;
17342 /* Parse args required to build the message */
17343 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17345 if (unformat (input, "up"))
17350 else if (unformat (input, "down"))
17355 else if (unformat (input, "table_id %d", &dp_table))
17359 else if (unformat (input, "bd_id %d", &dp_table))
17364 else if (unformat (input, "vni %d", &vni))
17372 if (action_set == 0)
17374 errmsg ("Action not set");
17377 if (dp_table_set == 0 || vni_set == 0)
17379 errmsg ("vni and dp_table must be set");
17383 /* Construct the API message */
17384 M (GPE_ADD_DEL_IFACE, mp);
17386 mp->is_add = is_add;
17387 mp->dp_table = clib_host_to_net_u32 (dp_table);
17389 mp->vni = clib_host_to_net_u32 (vni);
17394 /* Wait for a reply... */
17400 api_one_map_register_fallback_threshold (vat_main_t * vam)
17402 unformat_input_t *input = vam->input;
17403 vl_api_one_map_register_fallback_threshold_t *mp;
17408 /* Parse args required to build the message */
17409 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17411 if (unformat (input, "%u", &value))
17415 clib_warning ("parse error '%U'", format_unformat_error, input);
17422 errmsg ("fallback threshold value is missing!");
17426 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17427 mp->value = clib_host_to_net_u32 (value);
17432 /* Wait for a reply... */
17438 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17440 vl_api_show_one_map_register_fallback_threshold_t *mp;
17443 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17448 /* Wait for a reply... */
17454 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17456 u32 *proto = va_arg (*args, u32 *);
17458 if (unformat (input, "udp"))
17460 else if (unformat (input, "api"))
17469 api_one_set_transport_protocol (vat_main_t * vam)
17471 unformat_input_t *input = vam->input;
17472 vl_api_one_set_transport_protocol_t *mp;
17477 /* Parse args required to build the message */
17478 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17480 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17484 clib_warning ("parse error '%U'", format_unformat_error, input);
17491 errmsg ("Transport protocol missing!");
17495 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17496 mp->protocol = (u8) protocol;
17501 /* Wait for a reply... */
17507 api_one_get_transport_protocol (vat_main_t * vam)
17509 vl_api_one_get_transport_protocol_t *mp;
17512 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17517 /* Wait for a reply... */
17523 api_one_map_register_set_ttl (vat_main_t * vam)
17525 unformat_input_t *input = vam->input;
17526 vl_api_one_map_register_set_ttl_t *mp;
17531 /* Parse args required to build the message */
17532 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17534 if (unformat (input, "%u", &ttl))
17538 clib_warning ("parse error '%U'", format_unformat_error, input);
17545 errmsg ("TTL value missing!");
17549 M (ONE_MAP_REGISTER_SET_TTL, mp);
17550 mp->ttl = clib_host_to_net_u32 (ttl);
17555 /* Wait for a reply... */
17561 api_show_one_map_register_ttl (vat_main_t * vam)
17563 vl_api_show_one_map_register_ttl_t *mp;
17566 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17571 /* Wait for a reply... */
17577 * Add/del map request itr rlocs from ONE control plane and updates
17579 * @param vam vpp API test context
17580 * @return return code
17583 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17585 unformat_input_t *input = vam->input;
17586 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17587 u8 *locator_set_name = 0;
17588 u8 locator_set_name_set = 0;
17592 /* Parse args required to build the message */
17593 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17595 if (unformat (input, "del"))
17599 else if (unformat (input, "%_%v%_", &locator_set_name))
17601 locator_set_name_set = 1;
17605 clib_warning ("parse error '%U'", format_unformat_error, input);
17610 if (is_add && !locator_set_name_set)
17612 errmsg ("itr-rloc is not set!");
17616 if (is_add && vec_len (locator_set_name) > 64)
17618 errmsg ("itr-rloc locator-set name too long");
17619 vec_free (locator_set_name);
17623 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17624 mp->is_add = is_add;
17627 clib_memcpy (mp->locator_set_name, locator_set_name,
17628 vec_len (locator_set_name));
17632 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17634 vec_free (locator_set_name);
17639 /* Wait for a reply... */
17644 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17647 api_one_locator_dump (vat_main_t * vam)
17649 unformat_input_t *input = vam->input;
17650 vl_api_one_locator_dump_t *mp;
17651 vl_api_control_ping_t *mp_ping;
17652 u8 is_index_set = 0, is_name_set = 0;
17657 /* Parse args required to build the message */
17658 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17660 if (unformat (input, "ls_name %_%v%_", &ls_name))
17664 else if (unformat (input, "ls_index %d", &ls_index))
17670 errmsg ("parse error '%U'", format_unformat_error, input);
17675 if (!is_index_set && !is_name_set)
17677 errmsg ("error: expected one of index or name!");
17681 if (is_index_set && is_name_set)
17683 errmsg ("error: only one param expected!");
17687 if (vec_len (ls_name) > 62)
17689 errmsg ("error: locator set name too long!");
17693 if (!vam->json_output)
17695 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17698 M (ONE_LOCATOR_DUMP, mp);
17699 mp->is_index_set = is_index_set;
17702 mp->ls_index = clib_host_to_net_u32 (ls_index);
17705 vec_add1 (ls_name, 0);
17706 strncpy ((char *) mp->ls_name, (char *) ls_name,
17707 sizeof (mp->ls_name) - 1);
17713 /* Use a control ping for synchronization */
17714 MPING (CONTROL_PING, mp_ping);
17717 /* Wait for a reply... */
17722 #define api_lisp_locator_dump api_one_locator_dump
17725 api_one_locator_set_dump (vat_main_t * vam)
17727 vl_api_one_locator_set_dump_t *mp;
17728 vl_api_control_ping_t *mp_ping;
17729 unformat_input_t *input = vam->input;
17733 /* Parse args required to build the message */
17734 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17736 if (unformat (input, "local"))
17740 else if (unformat (input, "remote"))
17746 errmsg ("parse error '%U'", format_unformat_error, input);
17751 if (!vam->json_output)
17753 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17756 M (ONE_LOCATOR_SET_DUMP, mp);
17758 mp->filter = filter;
17763 /* Use a control ping for synchronization */
17764 MPING (CONTROL_PING, mp_ping);
17767 /* Wait for a reply... */
17772 #define api_lisp_locator_set_dump api_one_locator_set_dump
17775 api_one_eid_table_map_dump (vat_main_t * vam)
17779 unformat_input_t *input = vam->input;
17780 vl_api_one_eid_table_map_dump_t *mp;
17781 vl_api_control_ping_t *mp_ping;
17784 /* Parse args required to build the message */
17785 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17787 if (unformat (input, "l2"))
17792 else if (unformat (input, "l3"))
17799 errmsg ("parse error '%U'", format_unformat_error, input);
17806 errmsg ("expected one of 'l2' or 'l3' parameter!");
17810 if (!vam->json_output)
17812 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17815 M (ONE_EID_TABLE_MAP_DUMP, mp);
17821 /* Use a control ping for synchronization */
17822 MPING (CONTROL_PING, mp_ping);
17825 /* Wait for a reply... */
17830 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17833 api_one_eid_table_vni_dump (vat_main_t * vam)
17835 vl_api_one_eid_table_vni_dump_t *mp;
17836 vl_api_control_ping_t *mp_ping;
17839 if (!vam->json_output)
17841 print (vam->ofp, "VNI");
17844 M (ONE_EID_TABLE_VNI_DUMP, mp);
17849 /* Use a control ping for synchronization */
17850 MPING (CONTROL_PING, mp_ping);
17853 /* Wait for a reply... */
17858 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17861 api_one_eid_table_dump (vat_main_t * vam)
17863 unformat_input_t *i = vam->input;
17864 vl_api_one_eid_table_dump_t *mp;
17865 vl_api_control_ping_t *mp_ping;
17866 struct in_addr ip4;
17867 struct in6_addr ip6;
17869 u8 eid_type = ~0, eid_set = 0;
17870 u32 prefix_length = ~0, t, vni = 0;
17873 lisp_nsh_api_t nsh;
17875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17877 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17883 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17889 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17894 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17899 else if (unformat (i, "vni %d", &t))
17903 else if (unformat (i, "local"))
17907 else if (unformat (i, "remote"))
17913 errmsg ("parse error '%U'", format_unformat_error, i);
17918 if (!vam->json_output)
17920 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17921 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17924 M (ONE_EID_TABLE_DUMP, mp);
17926 mp->filter = filter;
17930 mp->vni = htonl (vni);
17931 mp->eid_type = eid_type;
17935 mp->prefix_length = prefix_length;
17936 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17939 mp->prefix_length = prefix_length;
17940 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17943 clib_memcpy (mp->eid, mac, sizeof (mac));
17946 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17949 errmsg ("unknown EID type %d!", eid_type);
17957 /* Use a control ping for synchronization */
17958 MPING (CONTROL_PING, mp_ping);
17961 /* Wait for a reply... */
17966 #define api_lisp_eid_table_dump api_one_eid_table_dump
17969 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17971 unformat_input_t *i = vam->input;
17972 vl_api_gpe_fwd_entries_get_t *mp;
17977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17979 if (unformat (i, "vni %d", &vni))
17985 errmsg ("parse error '%U'", format_unformat_error, i);
17992 errmsg ("vni not set!");
17996 if (!vam->json_output)
17998 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18002 M (GPE_FWD_ENTRIES_GET, mp);
18003 mp->vni = clib_host_to_net_u32 (vni);
18008 /* Wait for a reply... */
18013 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18014 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18015 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18016 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18017 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18018 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18019 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18020 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18023 api_one_adjacencies_get (vat_main_t * vam)
18025 unformat_input_t *i = vam->input;
18026 vl_api_one_adjacencies_get_t *mp;
18031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18033 if (unformat (i, "vni %d", &vni))
18039 errmsg ("parse error '%U'", format_unformat_error, i);
18046 errmsg ("vni not set!");
18050 if (!vam->json_output)
18052 print (vam->ofp, "%s %40s", "leid", "reid");
18055 M (ONE_ADJACENCIES_GET, mp);
18056 mp->vni = clib_host_to_net_u32 (vni);
18061 /* Wait for a reply... */
18066 #define api_lisp_adjacencies_get api_one_adjacencies_get
18069 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18071 unformat_input_t *i = vam->input;
18072 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18074 u8 ip_family_set = 0, is_ip4 = 1;
18076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18078 if (unformat (i, "ip4"))
18083 else if (unformat (i, "ip6"))
18090 errmsg ("parse error '%U'", format_unformat_error, i);
18095 if (!ip_family_set)
18097 errmsg ("ip family not set!");
18101 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18102 mp->is_ip4 = is_ip4;
18107 /* Wait for a reply... */
18113 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18115 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18118 if (!vam->json_output)
18120 print (vam->ofp, "VNIs");
18123 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18128 /* Wait for a reply... */
18134 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18136 unformat_input_t *i = vam->input;
18137 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18139 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18140 struct in_addr ip4;
18141 struct in6_addr ip6;
18142 u32 table_id = 0, nh_sw_if_index = ~0;
18144 memset (&ip4, 0, sizeof (ip4));
18145 memset (&ip6, 0, sizeof (ip6));
18147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18149 if (unformat (i, "del"))
18151 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18152 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18157 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18158 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18163 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18167 nh_sw_if_index = ~0;
18169 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18173 nh_sw_if_index = ~0;
18175 else if (unformat (i, "table %d", &table_id))
18179 errmsg ("parse error '%U'", format_unformat_error, i);
18186 errmsg ("nh addr not set!");
18190 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18191 mp->is_add = is_add;
18192 mp->table_id = clib_host_to_net_u32 (table_id);
18193 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18194 mp->is_ip4 = is_ip4;
18196 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18198 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18203 /* Wait for a reply... */
18209 api_one_map_server_dump (vat_main_t * vam)
18211 vl_api_one_map_server_dump_t *mp;
18212 vl_api_control_ping_t *mp_ping;
18215 if (!vam->json_output)
18217 print (vam->ofp, "%=20s", "Map server");
18220 M (ONE_MAP_SERVER_DUMP, mp);
18224 /* Use a control ping for synchronization */
18225 MPING (CONTROL_PING, mp_ping);
18228 /* Wait for a reply... */
18233 #define api_lisp_map_server_dump api_one_map_server_dump
18236 api_one_map_resolver_dump (vat_main_t * vam)
18238 vl_api_one_map_resolver_dump_t *mp;
18239 vl_api_control_ping_t *mp_ping;
18242 if (!vam->json_output)
18244 print (vam->ofp, "%=20s", "Map resolver");
18247 M (ONE_MAP_RESOLVER_DUMP, mp);
18251 /* Use a control ping for synchronization */
18252 MPING (CONTROL_PING, mp_ping);
18255 /* Wait for a reply... */
18260 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18263 api_one_stats_flush (vat_main_t * vam)
18265 vl_api_one_stats_flush_t *mp;
18268 M (ONE_STATS_FLUSH, mp);
18275 api_one_stats_dump (vat_main_t * vam)
18277 vl_api_one_stats_dump_t *mp;
18278 vl_api_control_ping_t *mp_ping;
18281 M (ONE_STATS_DUMP, mp);
18285 /* Use a control ping for synchronization */
18286 MPING (CONTROL_PING, mp_ping);
18289 /* Wait for a reply... */
18295 api_show_one_status (vat_main_t * vam)
18297 vl_api_show_one_status_t *mp;
18300 if (!vam->json_output)
18302 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18305 M (SHOW_ONE_STATUS, mp);
18308 /* Wait for a reply... */
18313 #define api_show_lisp_status api_show_one_status
18316 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18318 vl_api_gpe_fwd_entry_path_dump_t *mp;
18319 vl_api_control_ping_t *mp_ping;
18320 unformat_input_t *i = vam->input;
18321 u32 fwd_entry_index = ~0;
18324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18326 if (unformat (i, "index %d", &fwd_entry_index))
18332 if (~0 == fwd_entry_index)
18334 errmsg ("no index specified!");
18338 if (!vam->json_output)
18340 print (vam->ofp, "first line");
18343 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18347 /* Use a control ping for synchronization */
18348 MPING (CONTROL_PING, mp_ping);
18351 /* Wait for a reply... */
18357 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18359 vl_api_one_get_map_request_itr_rlocs_t *mp;
18362 if (!vam->json_output)
18364 print (vam->ofp, "%=20s", "itr-rlocs:");
18367 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18370 /* Wait for a reply... */
18375 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18378 api_af_packet_create (vat_main_t * vam)
18380 unformat_input_t *i = vam->input;
18381 vl_api_af_packet_create_t *mp;
18382 u8 *host_if_name = 0;
18384 u8 random_hw_addr = 1;
18387 memset (hw_addr, 0, sizeof (hw_addr));
18389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18391 if (unformat (i, "name %s", &host_if_name))
18392 vec_add1 (host_if_name, 0);
18393 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18394 random_hw_addr = 0;
18399 if (!vec_len (host_if_name))
18401 errmsg ("host-interface name must be specified");
18405 if (vec_len (host_if_name) > 64)
18407 errmsg ("host-interface name too long");
18411 M (AF_PACKET_CREATE, mp);
18413 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18414 clib_memcpy (mp->hw_addr, hw_addr, 6);
18415 mp->use_random_hw_addr = random_hw_addr;
18416 vec_free (host_if_name);
18424 fprintf (vam->ofp ? vam->ofp : stderr,
18425 " new sw_if_index = %d\n", vam->sw_if_index);
18432 api_af_packet_delete (vat_main_t * vam)
18434 unformat_input_t *i = vam->input;
18435 vl_api_af_packet_delete_t *mp;
18436 u8 *host_if_name = 0;
18439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18441 if (unformat (i, "name %s", &host_if_name))
18442 vec_add1 (host_if_name, 0);
18447 if (!vec_len (host_if_name))
18449 errmsg ("host-interface name must be specified");
18453 if (vec_len (host_if_name) > 64)
18455 errmsg ("host-interface name too long");
18459 M (AF_PACKET_DELETE, mp);
18461 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18462 vec_free (host_if_name);
18470 api_policer_add_del (vat_main_t * vam)
18472 unformat_input_t *i = vam->input;
18473 vl_api_policer_add_del_t *mp;
18483 u8 color_aware = 0;
18484 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18487 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18488 conform_action.dscp = 0;
18489 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18490 exceed_action.dscp = 0;
18491 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18492 violate_action.dscp = 0;
18494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18496 if (unformat (i, "del"))
18498 else if (unformat (i, "name %s", &name))
18499 vec_add1 (name, 0);
18500 else if (unformat (i, "cir %u", &cir))
18502 else if (unformat (i, "eir %u", &eir))
18504 else if (unformat (i, "cb %u", &cb))
18506 else if (unformat (i, "eb %u", &eb))
18508 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18511 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18514 else if (unformat (i, "type %U", unformat_policer_type, &type))
18516 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18519 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18522 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18525 else if (unformat (i, "color-aware"))
18531 if (!vec_len (name))
18533 errmsg ("policer name must be specified");
18537 if (vec_len (name) > 64)
18539 errmsg ("policer name too long");
18543 M (POLICER_ADD_DEL, mp);
18545 clib_memcpy (mp->name, name, vec_len (name));
18547 mp->is_add = is_add;
18548 mp->cir = ntohl (cir);
18549 mp->eir = ntohl (eir);
18550 mp->cb = clib_net_to_host_u64 (cb);
18551 mp->eb = clib_net_to_host_u64 (eb);
18552 mp->rate_type = rate_type;
18553 mp->round_type = round_type;
18555 mp->conform_action_type = conform_action.action_type;
18556 mp->conform_dscp = conform_action.dscp;
18557 mp->exceed_action_type = exceed_action.action_type;
18558 mp->exceed_dscp = exceed_action.dscp;
18559 mp->violate_action_type = violate_action.action_type;
18560 mp->violate_dscp = violate_action.dscp;
18561 mp->color_aware = color_aware;
18569 api_policer_dump (vat_main_t * vam)
18571 unformat_input_t *i = vam->input;
18572 vl_api_policer_dump_t *mp;
18573 vl_api_control_ping_t *mp_ping;
18574 u8 *match_name = 0;
18575 u8 match_name_valid = 0;
18578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18580 if (unformat (i, "name %s", &match_name))
18582 vec_add1 (match_name, 0);
18583 match_name_valid = 1;
18589 M (POLICER_DUMP, mp);
18590 mp->match_name_valid = match_name_valid;
18591 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18592 vec_free (match_name);
18596 /* Use a control ping for synchronization */
18597 MPING (CONTROL_PING, mp_ping);
18600 /* Wait for a reply... */
18606 api_policer_classify_set_interface (vat_main_t * vam)
18608 unformat_input_t *i = vam->input;
18609 vl_api_policer_classify_set_interface_t *mp;
18611 int sw_if_index_set;
18612 u32 ip4_table_index = ~0;
18613 u32 ip6_table_index = ~0;
18614 u32 l2_table_index = ~0;
18618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18620 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18621 sw_if_index_set = 1;
18622 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18623 sw_if_index_set = 1;
18624 else if (unformat (i, "del"))
18626 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18628 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18630 else if (unformat (i, "l2-table %d", &l2_table_index))
18634 clib_warning ("parse error '%U'", format_unformat_error, i);
18639 if (sw_if_index_set == 0)
18641 errmsg ("missing interface name or sw_if_index");
18645 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18647 mp->sw_if_index = ntohl (sw_if_index);
18648 mp->ip4_table_index = ntohl (ip4_table_index);
18649 mp->ip6_table_index = ntohl (ip6_table_index);
18650 mp->l2_table_index = ntohl (l2_table_index);
18651 mp->is_add = is_add;
18659 api_policer_classify_dump (vat_main_t * vam)
18661 unformat_input_t *i = vam->input;
18662 vl_api_policer_classify_dump_t *mp;
18663 vl_api_control_ping_t *mp_ping;
18664 u8 type = POLICER_CLASSIFY_N_TABLES;
18667 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18671 errmsg ("classify table type must be specified");
18675 if (!vam->json_output)
18677 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18680 M (POLICER_CLASSIFY_DUMP, mp);
18685 /* Use a control ping for synchronization */
18686 MPING (CONTROL_PING, mp_ping);
18689 /* Wait for a reply... */
18695 api_netmap_create (vat_main_t * vam)
18697 unformat_input_t *i = vam->input;
18698 vl_api_netmap_create_t *mp;
18701 u8 random_hw_addr = 1;
18706 memset (hw_addr, 0, sizeof (hw_addr));
18708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18710 if (unformat (i, "name %s", &if_name))
18711 vec_add1 (if_name, 0);
18712 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18713 random_hw_addr = 0;
18714 else if (unformat (i, "pipe"))
18716 else if (unformat (i, "master"))
18718 else if (unformat (i, "slave"))
18724 if (!vec_len (if_name))
18726 errmsg ("interface name must be specified");
18730 if (vec_len (if_name) > 64)
18732 errmsg ("interface name too long");
18736 M (NETMAP_CREATE, mp);
18738 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18739 clib_memcpy (mp->hw_addr, hw_addr, 6);
18740 mp->use_random_hw_addr = random_hw_addr;
18741 mp->is_pipe = is_pipe;
18742 mp->is_master = is_master;
18743 vec_free (if_name);
18751 api_netmap_delete (vat_main_t * vam)
18753 unformat_input_t *i = vam->input;
18754 vl_api_netmap_delete_t *mp;
18758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18760 if (unformat (i, "name %s", &if_name))
18761 vec_add1 (if_name, 0);
18766 if (!vec_len (if_name))
18768 errmsg ("interface name must be specified");
18772 if (vec_len (if_name) > 64)
18774 errmsg ("interface name too long");
18778 M (NETMAP_DELETE, mp);
18780 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18781 vec_free (if_name);
18789 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
18791 if (fp->afi == IP46_TYPE_IP6)
18793 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
18794 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
18795 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
18796 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
18797 format_ip6_address, fp->next_hop);
18798 else if (fp->afi == IP46_TYPE_IP4)
18800 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
18801 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
18802 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
18803 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
18804 format_ip4_address, fp->next_hop);
18808 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18809 vl_api_fib_path2_t * fp)
18811 struct in_addr ip4;
18812 struct in6_addr ip6;
18814 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18815 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18816 vat_json_object_add_uint (node, "is_local", fp->is_local);
18817 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
18818 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
18819 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
18820 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
18821 if (fp->afi == IP46_TYPE_IP4)
18823 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
18824 vat_json_object_add_ip4 (node, "next_hop", ip4);
18826 else if (fp->afi == IP46_TYPE_IP6)
18828 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
18829 vat_json_object_add_ip6 (node, "next_hop", ip6);
18834 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18836 vat_main_t *vam = &vat_main;
18837 int count = ntohl (mp->mt_count);
18838 vl_api_fib_path2_t *fp;
18841 print (vam->ofp, "[%d]: sw_if_index %d via:",
18842 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
18844 for (i = 0; i < count; i++)
18846 vl_api_mpls_fib_path_print (vam, fp);
18850 print (vam->ofp, "");
18853 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18854 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18857 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18859 vat_main_t *vam = &vat_main;
18860 vat_json_node_t *node = NULL;
18861 int count = ntohl (mp->mt_count);
18862 vl_api_fib_path2_t *fp;
18865 if (VAT_JSON_ARRAY != vam->json_tree.type)
18867 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18868 vat_json_init_array (&vam->json_tree);
18870 node = vat_json_array_add (&vam->json_tree);
18872 vat_json_init_object (node);
18873 vat_json_object_add_uint (node, "tunnel_index",
18874 ntohl (mp->mt_tunnel_index));
18875 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
18877 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
18880 for (i = 0; i < count; i++)
18882 vl_api_mpls_fib_path_json_print (node, fp);
18888 api_mpls_tunnel_dump (vat_main_t * vam)
18890 vl_api_mpls_tunnel_dump_t *mp;
18891 vl_api_control_ping_t *mp_ping;
18895 /* Parse args required to build the message */
18896 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
18898 if (!unformat (vam->input, "tunnel_index %d", &index))
18905 print (vam->ofp, " tunnel_index %d", index);
18907 M (MPLS_TUNNEL_DUMP, mp);
18908 mp->tunnel_index = htonl (index);
18911 /* Use a control ping for synchronization */
18912 MPING (CONTROL_PING, mp_ping);
18919 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
18920 #define vl_api_mpls_fib_details_t_print vl_noop_handler
18924 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
18926 vat_main_t *vam = &vat_main;
18927 int count = ntohl (mp->count);
18928 vl_api_fib_path2_t *fp;
18932 "table-id %d, label %u, ess_bit %u",
18933 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
18935 for (i = 0; i < count; i++)
18937 vl_api_mpls_fib_path_print (vam, fp);
18942 static void vl_api_mpls_fib_details_t_handler_json
18943 (vl_api_mpls_fib_details_t * mp)
18945 vat_main_t *vam = &vat_main;
18946 int count = ntohl (mp->count);
18947 vat_json_node_t *node = NULL;
18948 vl_api_fib_path2_t *fp;
18951 if (VAT_JSON_ARRAY != vam->json_tree.type)
18953 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18954 vat_json_init_array (&vam->json_tree);
18956 node = vat_json_array_add (&vam->json_tree);
18958 vat_json_init_object (node);
18959 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
18960 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
18961 vat_json_object_add_uint (node, "label", ntohl (mp->label));
18962 vat_json_object_add_uint (node, "path_count", count);
18964 for (i = 0; i < count; i++)
18966 vl_api_mpls_fib_path_json_print (node, fp);
18972 api_mpls_fib_dump (vat_main_t * vam)
18974 vl_api_mpls_fib_dump_t *mp;
18975 vl_api_control_ping_t *mp_ping;
18978 M (MPLS_FIB_DUMP, mp);
18981 /* Use a control ping for synchronization */
18982 MPING (CONTROL_PING, mp_ping);
18989 #define vl_api_ip_fib_details_t_endian vl_noop_handler
18990 #define vl_api_ip_fib_details_t_print vl_noop_handler
18993 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
18995 vat_main_t *vam = &vat_main;
18996 int count = ntohl (mp->count);
18997 vl_api_fib_path_t *fp;
19001 "table-id %d, prefix %U/%d",
19002 ntohl (mp->table_id), format_ip4_address, mp->address,
19003 mp->address_length);
19005 for (i = 0; i < count; i++)
19007 if (fp->afi == IP46_TYPE_IP6)
19009 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19010 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19011 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19012 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19013 format_ip6_address, fp->next_hop);
19014 else if (fp->afi == IP46_TYPE_IP4)
19016 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19017 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19018 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19019 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19020 format_ip4_address, fp->next_hop);
19025 static void vl_api_ip_fib_details_t_handler_json
19026 (vl_api_ip_fib_details_t * mp)
19028 vat_main_t *vam = &vat_main;
19029 int count = ntohl (mp->count);
19030 vat_json_node_t *node = NULL;
19031 struct in_addr ip4;
19032 struct in6_addr ip6;
19033 vl_api_fib_path_t *fp;
19036 if (VAT_JSON_ARRAY != vam->json_tree.type)
19038 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19039 vat_json_init_array (&vam->json_tree);
19041 node = vat_json_array_add (&vam->json_tree);
19043 vat_json_init_object (node);
19044 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19045 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19046 vat_json_object_add_ip4 (node, "prefix", ip4);
19047 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19048 vat_json_object_add_uint (node, "path_count", count);
19050 for (i = 0; i < count; i++)
19052 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19053 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19054 vat_json_object_add_uint (node, "is_local", fp->is_local);
19055 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19056 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19057 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19058 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19059 if (fp->afi == IP46_TYPE_IP4)
19061 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19062 vat_json_object_add_ip4 (node, "next_hop", ip4);
19064 else if (fp->afi == IP46_TYPE_IP6)
19066 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19067 vat_json_object_add_ip6 (node, "next_hop", ip6);
19073 api_ip_fib_dump (vat_main_t * vam)
19075 vl_api_ip_fib_dump_t *mp;
19076 vl_api_control_ping_t *mp_ping;
19079 M (IP_FIB_DUMP, mp);
19082 /* Use a control ping for synchronization */
19083 MPING (CONTROL_PING, mp_ping);
19091 api_ip_mfib_dump (vat_main_t * vam)
19093 vl_api_ip_mfib_dump_t *mp;
19094 vl_api_control_ping_t *mp_ping;
19097 M (IP_MFIB_DUMP, mp);
19100 /* Use a control ping for synchronization */
19101 MPING (CONTROL_PING, mp_ping);
19108 static void vl_api_ip_neighbor_details_t_handler
19109 (vl_api_ip_neighbor_details_t * mp)
19111 vat_main_t *vam = &vat_main;
19113 print (vam->ofp, "%c %U %U",
19114 (mp->is_static) ? 'S' : 'D',
19115 format_ethernet_address, &mp->mac_address,
19116 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19120 static void vl_api_ip_neighbor_details_t_handler_json
19121 (vl_api_ip_neighbor_details_t * mp)
19124 vat_main_t *vam = &vat_main;
19125 vat_json_node_t *node;
19126 struct in_addr ip4;
19127 struct in6_addr ip6;
19129 if (VAT_JSON_ARRAY != vam->json_tree.type)
19131 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19132 vat_json_init_array (&vam->json_tree);
19134 node = vat_json_array_add (&vam->json_tree);
19136 vat_json_init_object (node);
19137 vat_json_object_add_string_copy (node, "flag",
19138 (mp->is_static) ? (u8 *) "static" : (u8 *)
19141 vat_json_object_add_string_copy (node, "link_layer",
19142 format (0, "%U", format_ethernet_address,
19143 &mp->mac_address));
19147 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19148 vat_json_object_add_ip6 (node, "ip_address", ip6);
19152 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19153 vat_json_object_add_ip4 (node, "ip_address", ip4);
19158 api_ip_neighbor_dump (vat_main_t * vam)
19160 unformat_input_t *i = vam->input;
19161 vl_api_ip_neighbor_dump_t *mp;
19162 vl_api_control_ping_t *mp_ping;
19164 u32 sw_if_index = ~0;
19167 /* Parse args required to build the message */
19168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19170 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19172 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19174 else if (unformat (i, "ip6"))
19180 if (sw_if_index == ~0)
19182 errmsg ("missing interface name or sw_if_index");
19186 M (IP_NEIGHBOR_DUMP, mp);
19187 mp->is_ipv6 = (u8) is_ipv6;
19188 mp->sw_if_index = ntohl (sw_if_index);
19191 /* Use a control ping for synchronization */
19192 MPING (CONTROL_PING, mp_ping);
19199 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19200 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19203 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19205 vat_main_t *vam = &vat_main;
19206 int count = ntohl (mp->count);
19207 vl_api_fib_path_t *fp;
19211 "table-id %d, prefix %U/%d",
19212 ntohl (mp->table_id), format_ip6_address, mp->address,
19213 mp->address_length);
19215 for (i = 0; i < count; i++)
19217 if (fp->afi == IP46_TYPE_IP6)
19219 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19220 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19221 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19222 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19223 format_ip6_address, fp->next_hop);
19224 else if (fp->afi == IP46_TYPE_IP4)
19226 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19227 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19228 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19229 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19230 format_ip4_address, fp->next_hop);
19235 static void vl_api_ip6_fib_details_t_handler_json
19236 (vl_api_ip6_fib_details_t * mp)
19238 vat_main_t *vam = &vat_main;
19239 int count = ntohl (mp->count);
19240 vat_json_node_t *node = NULL;
19241 struct in_addr ip4;
19242 struct in6_addr ip6;
19243 vl_api_fib_path_t *fp;
19246 if (VAT_JSON_ARRAY != vam->json_tree.type)
19248 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19249 vat_json_init_array (&vam->json_tree);
19251 node = vat_json_array_add (&vam->json_tree);
19253 vat_json_init_object (node);
19254 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19255 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19256 vat_json_object_add_ip6 (node, "prefix", ip6);
19257 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19258 vat_json_object_add_uint (node, "path_count", count);
19260 for (i = 0; i < count; i++)
19262 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19263 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19264 vat_json_object_add_uint (node, "is_local", fp->is_local);
19265 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19266 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19267 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19268 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19269 if (fp->afi == IP46_TYPE_IP4)
19271 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19272 vat_json_object_add_ip4 (node, "next_hop", ip4);
19274 else if (fp->afi == IP46_TYPE_IP6)
19276 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19277 vat_json_object_add_ip6 (node, "next_hop", ip6);
19283 api_ip6_fib_dump (vat_main_t * vam)
19285 vl_api_ip6_fib_dump_t *mp;
19286 vl_api_control_ping_t *mp_ping;
19289 M (IP6_FIB_DUMP, mp);
19292 /* Use a control ping for synchronization */
19293 MPING (CONTROL_PING, mp_ping);
19301 api_ip6_mfib_dump (vat_main_t * vam)
19303 vl_api_ip6_mfib_dump_t *mp;
19304 vl_api_control_ping_t *mp_ping;
19307 M (IP6_MFIB_DUMP, mp);
19310 /* Use a control ping for synchronization */
19311 MPING (CONTROL_PING, mp_ping);
19319 api_classify_table_ids (vat_main_t * vam)
19321 vl_api_classify_table_ids_t *mp;
19324 /* Construct the API message */
19325 M (CLASSIFY_TABLE_IDS, mp);
19334 api_classify_table_by_interface (vat_main_t * vam)
19336 unformat_input_t *input = vam->input;
19337 vl_api_classify_table_by_interface_t *mp;
19339 u32 sw_if_index = ~0;
19341 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19343 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19345 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19350 if (sw_if_index == ~0)
19352 errmsg ("missing interface name or sw_if_index");
19356 /* Construct the API message */
19357 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19359 mp->sw_if_index = ntohl (sw_if_index);
19367 api_classify_table_info (vat_main_t * vam)
19369 unformat_input_t *input = vam->input;
19370 vl_api_classify_table_info_t *mp;
19374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19376 if (unformat (input, "table_id %d", &table_id))
19381 if (table_id == ~0)
19383 errmsg ("missing table id");
19387 /* Construct the API message */
19388 M (CLASSIFY_TABLE_INFO, mp);
19390 mp->table_id = ntohl (table_id);
19398 api_classify_session_dump (vat_main_t * vam)
19400 unformat_input_t *input = vam->input;
19401 vl_api_classify_session_dump_t *mp;
19402 vl_api_control_ping_t *mp_ping;
19406 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19408 if (unformat (input, "table_id %d", &table_id))
19413 if (table_id == ~0)
19415 errmsg ("missing table id");
19419 /* Construct the API message */
19420 M (CLASSIFY_SESSION_DUMP, mp);
19422 mp->table_id = ntohl (table_id);
19425 /* Use a control ping for synchronization */
19426 MPING (CONTROL_PING, mp_ping);
19434 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19436 vat_main_t *vam = &vat_main;
19438 print (vam->ofp, "collector_address %U, collector_port %d, "
19439 "src_address %U, vrf_id %d, path_mtu %u, "
19440 "template_interval %u, udp_checksum %d",
19441 format_ip4_address, mp->collector_address,
19442 ntohs (mp->collector_port),
19443 format_ip4_address, mp->src_address,
19444 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19445 ntohl (mp->template_interval), mp->udp_checksum);
19448 vam->result_ready = 1;
19452 vl_api_ipfix_exporter_details_t_handler_json
19453 (vl_api_ipfix_exporter_details_t * mp)
19455 vat_main_t *vam = &vat_main;
19456 vat_json_node_t node;
19457 struct in_addr collector_address;
19458 struct in_addr src_address;
19460 vat_json_init_object (&node);
19461 clib_memcpy (&collector_address, &mp->collector_address,
19462 sizeof (collector_address));
19463 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19464 vat_json_object_add_uint (&node, "collector_port",
19465 ntohs (mp->collector_port));
19466 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19467 vat_json_object_add_ip4 (&node, "src_address", src_address);
19468 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19469 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19470 vat_json_object_add_uint (&node, "template_interval",
19471 ntohl (mp->template_interval));
19472 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19474 vat_json_print (vam->ofp, &node);
19475 vat_json_free (&node);
19477 vam->result_ready = 1;
19481 api_ipfix_exporter_dump (vat_main_t * vam)
19483 vl_api_ipfix_exporter_dump_t *mp;
19486 /* Construct the API message */
19487 M (IPFIX_EXPORTER_DUMP, mp);
19496 api_ipfix_classify_stream_dump (vat_main_t * vam)
19498 vl_api_ipfix_classify_stream_dump_t *mp;
19501 /* Construct the API message */
19502 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19513 vl_api_ipfix_classify_stream_details_t_handler
19514 (vl_api_ipfix_classify_stream_details_t * mp)
19516 vat_main_t *vam = &vat_main;
19517 print (vam->ofp, "domain_id %d, src_port %d",
19518 ntohl (mp->domain_id), ntohs (mp->src_port));
19520 vam->result_ready = 1;
19524 vl_api_ipfix_classify_stream_details_t_handler_json
19525 (vl_api_ipfix_classify_stream_details_t * mp)
19527 vat_main_t *vam = &vat_main;
19528 vat_json_node_t node;
19530 vat_json_init_object (&node);
19531 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19532 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19534 vat_json_print (vam->ofp, &node);
19535 vat_json_free (&node);
19537 vam->result_ready = 1;
19541 api_ipfix_classify_table_dump (vat_main_t * vam)
19543 vl_api_ipfix_classify_table_dump_t *mp;
19544 vl_api_control_ping_t *mp_ping;
19547 if (!vam->json_output)
19549 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19550 "transport_protocol");
19553 /* Construct the API message */
19554 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19559 /* Use a control ping for synchronization */
19560 MPING (CONTROL_PING, mp_ping);
19568 vl_api_ipfix_classify_table_details_t_handler
19569 (vl_api_ipfix_classify_table_details_t * mp)
19571 vat_main_t *vam = &vat_main;
19572 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19573 mp->transport_protocol);
19577 vl_api_ipfix_classify_table_details_t_handler_json
19578 (vl_api_ipfix_classify_table_details_t * mp)
19580 vat_json_node_t *node = NULL;
19581 vat_main_t *vam = &vat_main;
19583 if (VAT_JSON_ARRAY != vam->json_tree.type)
19585 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19586 vat_json_init_array (&vam->json_tree);
19589 node = vat_json_array_add (&vam->json_tree);
19590 vat_json_init_object (node);
19592 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19593 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19594 vat_json_object_add_uint (node, "transport_protocol",
19595 mp->transport_protocol);
19599 api_sw_interface_span_enable_disable (vat_main_t * vam)
19601 unformat_input_t *i = vam->input;
19602 vl_api_sw_interface_span_enable_disable_t *mp;
19603 u32 src_sw_if_index = ~0;
19604 u32 dst_sw_if_index = ~0;
19609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19612 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19614 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19618 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19620 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19622 else if (unformat (i, "disable"))
19624 else if (unformat (i, "rx"))
19626 else if (unformat (i, "tx"))
19628 else if (unformat (i, "both"))
19630 else if (unformat (i, "l2"))
19636 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19638 mp->sw_if_index_from = htonl (src_sw_if_index);
19639 mp->sw_if_index_to = htonl (dst_sw_if_index);
19649 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19652 vat_main_t *vam = &vat_main;
19653 u8 *sw_if_from_name = 0;
19654 u8 *sw_if_to_name = 0;
19655 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19656 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19657 char *states[] = { "none", "rx", "tx", "both" };
19661 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19663 if ((u32) p->value[0] == sw_if_index_from)
19665 sw_if_from_name = (u8 *)(p->key);
19669 if ((u32) p->value[0] == sw_if_index_to)
19671 sw_if_to_name = (u8 *)(p->key);
19672 if (sw_if_from_name)
19677 print (vam->ofp, "%20s => %20s (%s)",
19678 sw_if_from_name, sw_if_to_name, states[mp->state]);
19682 vl_api_sw_interface_span_details_t_handler_json
19683 (vl_api_sw_interface_span_details_t * mp)
19685 vat_main_t *vam = &vat_main;
19686 vat_json_node_t *node = NULL;
19687 u8 *sw_if_from_name = 0;
19688 u8 *sw_if_to_name = 0;
19689 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19690 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19694 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19696 if ((u32) p->value[0] == sw_if_index_from)
19698 sw_if_from_name = (u8 *)(p->key);
19702 if ((u32) p->value[0] == sw_if_index_to)
19704 sw_if_to_name = (u8 *)(p->key);
19705 if (sw_if_from_name)
19711 if (VAT_JSON_ARRAY != vam->json_tree.type)
19713 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19714 vat_json_init_array (&vam->json_tree);
19716 node = vat_json_array_add (&vam->json_tree);
19718 vat_json_init_object (node);
19719 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19720 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19721 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19722 if (0 != sw_if_to_name)
19724 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19726 vat_json_object_add_uint (node, "state", mp->state);
19730 api_sw_interface_span_dump (vat_main_t * vam)
19732 unformat_input_t *input = vam->input;
19733 vl_api_sw_interface_span_dump_t *mp;
19734 vl_api_control_ping_t *mp_ping;
19738 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19740 if (unformat (input, "l2"))
19746 M (SW_INTERFACE_SPAN_DUMP, mp);
19750 /* Use a control ping for synchronization */
19751 MPING (CONTROL_PING, mp_ping);
19759 api_pg_create_interface (vat_main_t * vam)
19761 unformat_input_t *input = vam->input;
19762 vl_api_pg_create_interface_t *mp;
19766 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19768 if (unformat (input, "if_id %d", &if_id))
19775 errmsg ("missing pg interface index");
19779 /* Construct the API message */
19780 M (PG_CREATE_INTERFACE, mp);
19782 mp->interface_id = ntohl (if_id);
19790 api_pg_capture (vat_main_t * vam)
19792 unformat_input_t *input = vam->input;
19793 vl_api_pg_capture_t *mp;
19798 u8 pcap_file_set = 0;
19801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19803 if (unformat (input, "if_id %d", &if_id))
19805 else if (unformat (input, "pcap %s", &pcap_file))
19807 else if (unformat (input, "count %d", &count))
19809 else if (unformat (input, "disable"))
19816 errmsg ("missing pg interface index");
19819 if (pcap_file_set > 0)
19821 if (vec_len (pcap_file) > 255)
19823 errmsg ("pcap file name is too long");
19828 u32 name_len = vec_len (pcap_file);
19829 /* Construct the API message */
19830 M (PG_CAPTURE, mp);
19832 mp->interface_id = ntohl (if_id);
19833 mp->is_enabled = enable;
19834 mp->count = ntohl (count);
19835 mp->pcap_name_length = ntohl (name_len);
19836 if (pcap_file_set != 0)
19838 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19840 vec_free (pcap_file);
19848 api_pg_enable_disable (vat_main_t * vam)
19850 unformat_input_t *input = vam->input;
19851 vl_api_pg_enable_disable_t *mp;
19854 u8 stream_name_set = 0;
19855 u8 *stream_name = 0;
19857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19859 if (unformat (input, "stream %s", &stream_name))
19860 stream_name_set = 1;
19861 else if (unformat (input, "disable"))
19867 if (stream_name_set > 0)
19869 if (vec_len (stream_name) > 255)
19871 errmsg ("stream name too long");
19876 u32 name_len = vec_len (stream_name);
19877 /* Construct the API message */
19878 M (PG_ENABLE_DISABLE, mp);
19880 mp->is_enabled = enable;
19881 if (stream_name_set != 0)
19883 mp->stream_name_length = ntohl (name_len);
19884 clib_memcpy (mp->stream_name, stream_name, name_len);
19886 vec_free (stream_name);
19894 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19896 unformat_input_t *input = vam->input;
19897 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19899 u16 *low_ports = 0;
19900 u16 *high_ports = 0;
19903 ip4_address_t ip4_addr;
19904 ip6_address_t ip6_addr;
19913 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19915 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
19921 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
19926 else if (unformat (input, "vrf %d", &vrf_id))
19928 else if (unformat (input, "del"))
19930 else if (unformat (input, "port %d", &tmp))
19932 if (tmp == 0 || tmp > 65535)
19934 errmsg ("port %d out of range", tmp);
19938 this_hi = this_low + 1;
19939 vec_add1 (low_ports, this_low);
19940 vec_add1 (high_ports, this_hi);
19942 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19944 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19946 errmsg ("incorrect range parameters");
19950 /* Note: in debug CLI +1 is added to high before
19951 passing to real fn that does "the work"
19952 (ip_source_and_port_range_check_add_del).
19953 This fn is a wrapper around the binary API fn a
19954 control plane will call, which expects this increment
19955 to have occurred. Hence letting the binary API control
19956 plane fn do the increment for consistency between VAT
19957 and other control planes.
19960 vec_add1 (low_ports, this_low);
19961 vec_add1 (high_ports, this_hi);
19967 if (prefix_set == 0)
19969 errmsg ("<address>/<mask> not specified");
19975 errmsg ("VRF ID required, not specified");
19982 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19986 if (vec_len (low_ports) == 0)
19988 errmsg ("At least one port or port range required");
19992 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
19994 mp->is_add = is_add;
19999 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20004 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20007 mp->mask_length = length;
20008 mp->number_of_ranges = vec_len (low_ports);
20010 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20011 vec_free (low_ports);
20013 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20014 vec_free (high_ports);
20016 mp->vrf_id = ntohl (vrf_id);
20024 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20026 unformat_input_t *input = vam->input;
20027 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20028 u32 sw_if_index = ~0;
20030 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20031 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20035 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20037 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20039 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20041 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20043 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20045 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20047 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20049 else if (unformat (input, "del"))
20055 if (sw_if_index == ~0)
20057 errmsg ("Interface required but not specified");
20063 errmsg ("VRF ID required but not specified");
20067 if (tcp_out_vrf_id == 0
20068 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20071 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20075 /* Construct the API message */
20076 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20078 mp->sw_if_index = ntohl (sw_if_index);
20079 mp->is_add = is_add;
20080 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20081 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20082 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20083 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20088 /* Wait for a reply... */
20094 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20096 unformat_input_t *i = vam->input;
20097 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20098 u32 local_sa_id = 0;
20099 u32 remote_sa_id = 0;
20100 ip4_address_t src_address;
20101 ip4_address_t dst_address;
20105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20107 if (unformat (i, "local_sa %d", &local_sa_id))
20109 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20111 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20113 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20115 else if (unformat (i, "del"))
20119 clib_warning ("parse error '%U'", format_unformat_error, i);
20124 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20126 mp->local_sa_id = ntohl (local_sa_id);
20127 mp->remote_sa_id = ntohl (remote_sa_id);
20128 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20129 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20130 mp->is_add = is_add;
20138 api_punt (vat_main_t * vam)
20140 unformat_input_t *i = vam->input;
20148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20150 if (unformat (i, "ip %d", &ipv))
20152 else if (unformat (i, "protocol %d", &protocol))
20154 else if (unformat (i, "port %d", &port))
20156 else if (unformat (i, "del"))
20160 clib_warning ("parse error '%U'", format_unformat_error, i);
20167 mp->is_add = (u8) is_add;
20168 mp->ipv = (u8) ipv;
20169 mp->l4_protocol = (u8) protocol;
20170 mp->l4_port = htons ((u16) port);
20177 static void vl_api_ipsec_gre_tunnel_details_t_handler
20178 (vl_api_ipsec_gre_tunnel_details_t * mp)
20180 vat_main_t *vam = &vat_main;
20182 print (vam->ofp, "%11d%15U%15U%14d%14d",
20183 ntohl (mp->sw_if_index),
20184 format_ip4_address, &mp->src_address,
20185 format_ip4_address, &mp->dst_address,
20186 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20189 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20190 (vl_api_ipsec_gre_tunnel_details_t * mp)
20192 vat_main_t *vam = &vat_main;
20193 vat_json_node_t *node = NULL;
20194 struct in_addr ip4;
20196 if (VAT_JSON_ARRAY != vam->json_tree.type)
20198 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20199 vat_json_init_array (&vam->json_tree);
20201 node = vat_json_array_add (&vam->json_tree);
20203 vat_json_init_object (node);
20204 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20205 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20206 vat_json_object_add_ip4 (node, "src_address", ip4);
20207 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20208 vat_json_object_add_ip4 (node, "dst_address", ip4);
20209 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20210 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20214 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20216 unformat_input_t *i = vam->input;
20217 vl_api_ipsec_gre_tunnel_dump_t *mp;
20218 vl_api_control_ping_t *mp_ping;
20220 u8 sw_if_index_set = 0;
20223 /* Parse args required to build the message */
20224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20226 if (unformat (i, "sw_if_index %d", &sw_if_index))
20227 sw_if_index_set = 1;
20232 if (sw_if_index_set == 0)
20237 if (!vam->json_output)
20239 print (vam->ofp, "%11s%15s%15s%14s%14s",
20240 "sw_if_index", "src_address", "dst_address",
20241 "local_sa_id", "remote_sa_id");
20244 /* Get list of gre-tunnel interfaces */
20245 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20247 mp->sw_if_index = htonl (sw_if_index);
20251 /* Use a control ping for synchronization */
20252 MPING (CONTROL_PING, mp_ping);
20260 api_delete_subif (vat_main_t * vam)
20262 unformat_input_t *i = vam->input;
20263 vl_api_delete_subif_t *mp;
20264 u32 sw_if_index = ~0;
20267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20269 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20271 if (unformat (i, "sw_if_index %d", &sw_if_index))
20277 if (sw_if_index == ~0)
20279 errmsg ("missing sw_if_index");
20283 /* Construct the API message */
20284 M (DELETE_SUBIF, mp);
20285 mp->sw_if_index = ntohl (sw_if_index);
20292 #define foreach_pbb_vtr_op \
20293 _("disable", L2_VTR_DISABLED) \
20294 _("pop", L2_VTR_POP_2) \
20295 _("push", L2_VTR_PUSH_2)
20298 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20300 unformat_input_t *i = vam->input;
20301 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20302 u32 sw_if_index = ~0, vtr_op = ~0;
20303 u16 outer_tag = ~0;
20304 u8 dmac[6], smac[6];
20305 u8 dmac_set = 0, smac_set = 0;
20311 /* Shut up coverity */
20312 memset (dmac, 0, sizeof (dmac));
20313 memset (smac, 0, sizeof (smac));
20315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20317 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20319 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20321 else if (unformat (i, "vtr_op %d", &vtr_op))
20323 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20326 else if (unformat (i, "translate_pbb_stag"))
20328 if (unformat (i, "%d", &tmp))
20330 vtr_op = L2_VTR_TRANSLATE_2_1;
20336 ("translate_pbb_stag operation requires outer tag definition");
20340 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20342 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20344 else if (unformat (i, "sid %d", &sid))
20346 else if (unformat (i, "vlanid %d", &tmp))
20350 clib_warning ("parse error '%U'", format_unformat_error, i);
20355 if ((sw_if_index == ~0) || (vtr_op == ~0))
20357 errmsg ("missing sw_if_index or vtr operation");
20360 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20361 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20364 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20368 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20369 mp->sw_if_index = ntohl (sw_if_index);
20370 mp->vtr_op = ntohl (vtr_op);
20371 mp->outer_tag = ntohs (outer_tag);
20372 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20373 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20374 mp->b_vlanid = ntohs (vlanid);
20375 mp->i_sid = ntohl (sid);
20383 api_flow_classify_set_interface (vat_main_t * vam)
20385 unformat_input_t *i = vam->input;
20386 vl_api_flow_classify_set_interface_t *mp;
20388 int sw_if_index_set;
20389 u32 ip4_table_index = ~0;
20390 u32 ip6_table_index = ~0;
20394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20396 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20397 sw_if_index_set = 1;
20398 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20399 sw_if_index_set = 1;
20400 else if (unformat (i, "del"))
20402 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20404 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20408 clib_warning ("parse error '%U'", format_unformat_error, i);
20413 if (sw_if_index_set == 0)
20415 errmsg ("missing interface name or sw_if_index");
20419 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20421 mp->sw_if_index = ntohl (sw_if_index);
20422 mp->ip4_table_index = ntohl (ip4_table_index);
20423 mp->ip6_table_index = ntohl (ip6_table_index);
20424 mp->is_add = is_add;
20432 api_flow_classify_dump (vat_main_t * vam)
20434 unformat_input_t *i = vam->input;
20435 vl_api_flow_classify_dump_t *mp;
20436 vl_api_control_ping_t *mp_ping;
20437 u8 type = FLOW_CLASSIFY_N_TABLES;
20440 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20444 errmsg ("classify table type must be specified");
20448 if (!vam->json_output)
20450 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20453 M (FLOW_CLASSIFY_DUMP, mp);
20458 /* Use a control ping for synchronization */
20459 MPING (CONTROL_PING, mp_ping);
20462 /* Wait for a reply... */
20468 api_feature_enable_disable (vat_main_t * vam)
20470 unformat_input_t *i = vam->input;
20471 vl_api_feature_enable_disable_t *mp;
20473 u8 *feature_name = 0;
20474 u32 sw_if_index = ~0;
20478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20480 if (unformat (i, "arc_name %s", &arc_name))
20482 else if (unformat (i, "feature_name %s", &feature_name))
20485 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20487 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20489 else if (unformat (i, "disable"))
20497 errmsg ("missing arc name");
20500 if (vec_len (arc_name) > 63)
20502 errmsg ("arc name too long");
20505 if (feature_name == 0)
20507 errmsg ("missing feature name");
20510 if (vec_len (feature_name) > 63)
20512 errmsg ("feature name too long");
20515 if (sw_if_index == ~0)
20517 errmsg ("missing interface name or sw_if_index");
20521 /* Construct the API message */
20522 M (FEATURE_ENABLE_DISABLE, mp);
20523 mp->sw_if_index = ntohl (sw_if_index);
20524 mp->enable = enable;
20525 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20526 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20527 vec_free (arc_name);
20528 vec_free (feature_name);
20536 api_sw_interface_tag_add_del (vat_main_t * vam)
20538 unformat_input_t *i = vam->input;
20539 vl_api_sw_interface_tag_add_del_t *mp;
20540 u32 sw_if_index = ~0;
20545 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20547 if (unformat (i, "tag %s", &tag))
20549 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20551 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20553 else if (unformat (i, "del"))
20559 if (sw_if_index == ~0)
20561 errmsg ("missing interface name or sw_if_index");
20565 if (enable && (tag == 0))
20567 errmsg ("no tag specified");
20571 /* Construct the API message */
20572 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20573 mp->sw_if_index = ntohl (sw_if_index);
20574 mp->is_add = enable;
20576 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20584 static void vl_api_l2_xconnect_details_t_handler
20585 (vl_api_l2_xconnect_details_t * mp)
20587 vat_main_t *vam = &vat_main;
20589 print (vam->ofp, "%15d%15d",
20590 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20593 static void vl_api_l2_xconnect_details_t_handler_json
20594 (vl_api_l2_xconnect_details_t * mp)
20596 vat_main_t *vam = &vat_main;
20597 vat_json_node_t *node = NULL;
20599 if (VAT_JSON_ARRAY != vam->json_tree.type)
20601 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20602 vat_json_init_array (&vam->json_tree);
20604 node = vat_json_array_add (&vam->json_tree);
20606 vat_json_init_object (node);
20607 vat_json_object_add_uint (node, "rx_sw_if_index",
20608 ntohl (mp->rx_sw_if_index));
20609 vat_json_object_add_uint (node, "tx_sw_if_index",
20610 ntohl (mp->tx_sw_if_index));
20614 api_l2_xconnect_dump (vat_main_t * vam)
20616 vl_api_l2_xconnect_dump_t *mp;
20617 vl_api_control_ping_t *mp_ping;
20620 if (!vam->json_output)
20622 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20625 M (L2_XCONNECT_DUMP, mp);
20629 /* Use a control ping for synchronization */
20630 MPING (CONTROL_PING, mp_ping);
20638 api_sw_interface_set_mtu (vat_main_t * vam)
20640 unformat_input_t *i = vam->input;
20641 vl_api_sw_interface_set_mtu_t *mp;
20642 u32 sw_if_index = ~0;
20646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20648 if (unformat (i, "mtu %d", &mtu))
20650 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20652 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20658 if (sw_if_index == ~0)
20660 errmsg ("missing interface name or sw_if_index");
20666 errmsg ("no mtu specified");
20670 /* Construct the API message */
20671 M (SW_INTERFACE_SET_MTU, mp);
20672 mp->sw_if_index = ntohl (sw_if_index);
20673 mp->mtu = ntohs ((u16) mtu);
20681 api_p2p_ethernet_add (vat_main_t * vam)
20683 unformat_input_t *i = vam->input;
20684 vl_api_p2p_ethernet_add_t *mp;
20685 u32 parent_if_index = ~0;
20691 memset (remote_mac, 0, sizeof (remote_mac));
20692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20694 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20696 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20700 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20702 else if (unformat (i, "sub_id %d", &sub_id))
20706 clib_warning ("parse error '%U'", format_unformat_error, i);
20711 if (parent_if_index == ~0)
20713 errmsg ("missing interface name or sw_if_index");
20718 errmsg ("missing remote mac address");
20723 errmsg ("missing sub-interface id");
20727 M (P2P_ETHERNET_ADD, mp);
20728 mp->parent_if_index = ntohl (parent_if_index);
20729 mp->subif_id = ntohl (sub_id);
20730 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20738 api_p2p_ethernet_del (vat_main_t * vam)
20740 unformat_input_t *i = vam->input;
20741 vl_api_p2p_ethernet_del_t *mp;
20742 u32 parent_if_index = ~0;
20747 memset (remote_mac, 0, sizeof (remote_mac));
20748 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20750 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20752 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20756 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20760 clib_warning ("parse error '%U'", format_unformat_error, i);
20765 if (parent_if_index == ~0)
20767 errmsg ("missing interface name or sw_if_index");
20772 errmsg ("missing remote mac address");
20776 M (P2P_ETHERNET_DEL, mp);
20777 mp->parent_if_index = ntohl (parent_if_index);
20778 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20786 api_lldp_config (vat_main_t * vam)
20788 unformat_input_t *i = vam->input;
20789 vl_api_lldp_config_t *mp;
20791 int tx_interval = 0;
20792 u8 *sys_name = NULL;
20795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20797 if (unformat (i, "system-name %s", &sys_name))
20799 else if (unformat (i, "tx-hold %d", &tx_hold))
20801 else if (unformat (i, "tx-interval %d", &tx_interval))
20805 clib_warning ("parse error '%U'", format_unformat_error, i);
20810 vec_add1 (sys_name, 0);
20812 M (LLDP_CONFIG, mp);
20813 mp->tx_hold = htonl (tx_hold);
20814 mp->tx_interval = htonl (tx_interval);
20815 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20816 vec_free (sys_name);
20824 api_sw_interface_set_lldp (vat_main_t * vam)
20826 unformat_input_t *i = vam->input;
20827 vl_api_sw_interface_set_lldp_t *mp;
20828 u32 sw_if_index = ~0;
20830 u8 *port_desc = NULL, *mgmt_oid = NULL;
20831 ip4_address_t ip4_addr;
20832 ip6_address_t ip6_addr;
20835 memset (&ip4_addr, 0, sizeof (ip4_addr));
20836 memset (&ip6_addr, 0, sizeof (ip6_addr));
20838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20840 if (unformat (i, "disable"))
20843 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20845 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20847 else if (unformat (i, "port-desc %s", &port_desc))
20849 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20851 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20853 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20859 if (sw_if_index == ~0)
20861 errmsg ("missing interface name or sw_if_index");
20865 /* Construct the API message */
20866 vec_add1 (port_desc, 0);
20867 vec_add1 (mgmt_oid, 0);
20868 M (SW_INTERFACE_SET_LLDP, mp);
20869 mp->sw_if_index = ntohl (sw_if_index);
20870 mp->enable = enable;
20871 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20872 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20873 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20874 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20875 vec_free (port_desc);
20876 vec_free (mgmt_oid);
20884 api_tcp_configure_src_addresses (vat_main_t * vam)
20886 vl_api_tcp_configure_src_addresses_t *mp;
20887 unformat_input_t *i = vam->input;
20888 ip4_address_t v4first, v4last;
20889 ip6_address_t v6first, v6last;
20894 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20896 if (unformat (i, "%U - %U",
20897 unformat_ip4_address, &v4first,
20898 unformat_ip4_address, &v4last))
20902 errmsg ("one range per message (range already set)");
20907 else if (unformat (i, "%U - %U",
20908 unformat_ip6_address, &v6first,
20909 unformat_ip6_address, &v6last))
20913 errmsg ("one range per message (range already set)");
20918 else if (unformat (i, "vrf %d", &vrf_id))
20924 if (range_set == 0)
20926 errmsg ("address range not set");
20930 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20931 mp->vrf_id = ntohl (vrf_id);
20933 if (range_set == 2)
20936 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20937 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20942 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20943 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20951 api_app_namespace_add_del (vat_main_t * vam)
20953 vl_api_app_namespace_add_del_t *mp;
20954 unformat_input_t *i = vam->input;
20955 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
20956 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
20960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20962 if (unformat (i, "id %_%v%_", &ns_id))
20964 else if (unformat (i, "secret %lu", &secret))
20966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20967 sw_if_index_set = 1;
20968 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
20970 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
20975 if (!ns_id || !secret_set || !sw_if_index_set)
20977 errmsg ("namespace id, secret and sw_if_index must be set");
20980 if (vec_len (ns_id) > 64)
20982 errmsg ("namespace id too long");
20985 M (APP_NAMESPACE_ADD_DEL, mp);
20987 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
20988 mp->namespace_id_len = vec_len (ns_id);
20989 mp->secret = clib_host_to_net_u64 (secret);
20990 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20991 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
20992 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21000 api_memfd_segment_create (vat_main_t * vam)
21002 #if VPP_API_TEST_BUILTIN == 0
21003 unformat_input_t *i = vam->input;
21004 vl_api_memfd_segment_create_t *mp;
21005 u64 size = 64 << 20;
21008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21010 if (unformat (i, "size %U", unformat_memory_size, &size))
21016 M (MEMFD_SEGMENT_CREATE, mp);
21017 mp->requested_size = size;
21023 errmsg ("memfd_segment_create (builtin) not supported");
21029 api_dns_enable_disable (vat_main_t * vam)
21031 unformat_input_t *line_input = vam->input;
21032 vl_api_dns_enable_disable_t *mp;
21033 u8 enable_disable = 1;
21036 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21038 if (unformat (line_input, "disable"))
21039 enable_disable = 0;
21040 if (unformat (line_input, "enable"))
21041 enable_disable = 1;
21046 /* Construct the API message */
21047 M (DNS_ENABLE_DISABLE, mp);
21048 mp->enable = enable_disable;
21052 /* Wait for the reply */
21058 api_dns_resolve_name (vat_main_t * vam)
21060 unformat_input_t *line_input = vam->input;
21061 vl_api_dns_resolve_name_t *mp;
21065 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21067 if (unformat (line_input, "%s", &name))
21073 if (vec_len (name) > 127)
21075 errmsg ("name too long");
21079 /* Construct the API message */
21080 M (DNS_RESOLVE_NAME, mp);
21081 memcpy (mp->name, name, vec_len (name));
21086 /* Wait for the reply */
21092 api_dns_resolve_ip (vat_main_t * vam)
21094 unformat_input_t *line_input = vam->input;
21095 vl_api_dns_resolve_ip_t *mp;
21097 ip4_address_t addr4;
21098 ip6_address_t addr6;
21101 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21103 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21105 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21113 errmsg ("missing address");
21117 /* Construct the API message */
21118 M (DNS_RESOLVE_IP, mp);
21119 mp->is_ip6 = is_ip6;
21121 memcpy (mp->address, &addr6, sizeof (addr6));
21123 memcpy (mp->address, &addr4, sizeof (addr4));
21127 /* Wait for the reply */
21133 api_dns_name_server_add_del (vat_main_t * vam)
21135 unformat_input_t *i = vam->input;
21136 vl_api_dns_name_server_add_del_t *mp;
21138 ip6_address_t ip6_server;
21139 ip4_address_t ip4_server;
21144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21146 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21148 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21150 else if (unformat (i, "del"))
21154 clib_warning ("parse error '%U'", format_unformat_error, i);
21159 if (ip4_set && ip6_set)
21161 errmsg ("Only one server address allowed per message");
21164 if ((ip4_set + ip6_set) == 0)
21166 errmsg ("Server address required");
21170 /* Construct the API message */
21171 M (DNS_NAME_SERVER_ADD_DEL, mp);
21175 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21180 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21184 mp->is_add = is_add;
21189 /* Wait for a reply, return good/bad news */
21195 api_session_rule_add_del (vat_main_t * vam)
21197 vl_api_session_rule_add_del_t *mp;
21198 unformat_input_t *i = vam->input;
21199 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21200 u32 appns_index = 0, scope = 0;
21201 ip4_address_t lcl_ip4, rmt_ip4;
21202 ip6_address_t lcl_ip6, rmt_ip6;
21203 u8 is_ip4 = 1, conn_set = 0;
21207 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21209 if (unformat (i, "del"))
21211 else if (unformat (i, "add"))
21213 else if (unformat (i, "proto tcp"))
21215 else if (unformat (i, "proto udp"))
21217 else if (unformat (i, "appns %d", &appns_index))
21219 else if (unformat (i, "scope %d", &scope))
21223 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21224 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21232 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21233 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21239 else if (unformat (i, "action %d", &action))
21244 if (proto == ~0 || !conn_set || action == ~0)
21246 errmsg ("transport proto, connection and action must be set");
21252 errmsg ("scope should be 0-3");
21256 M (SESSION_RULE_ADD_DEL, mp);
21258 mp->is_ip4 = is_ip4;
21259 mp->transport_proto = proto;
21260 mp->lcl_plen = clib_host_to_net_u16 (lcl_plen);
21261 mp->rmt_plen = clib_host_to_net_u16 (rmt_plen);
21262 mp->action_index = clib_host_to_net_u32 (action);
21263 mp->appns_index = clib_host_to_net_u32 (appns_index);
21265 mp->is_add = is_add;
21268 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21269 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21273 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21274 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21283 q_or_quit (vat_main_t * vam)
21285 #if VPP_API_TEST_BUILTIN == 0
21286 longjmp (vam->jump_buf, 1);
21288 return 0; /* not so much */
21292 q (vat_main_t * vam)
21294 return q_or_quit (vam);
21298 quit (vat_main_t * vam)
21300 return q_or_quit (vam);
21304 comment (vat_main_t * vam)
21310 cmd_cmp (void *a1, void *a2)
21315 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21319 help (vat_main_t * vam)
21324 unformat_input_t *i = vam->input;
21327 if (unformat (i, "%s", &name))
21331 vec_add1 (name, 0);
21333 hs = hash_get_mem (vam->help_by_name, name);
21335 print (vam->ofp, "usage: %s %s", name, hs[0]);
21337 print (vam->ofp, "No such msg / command '%s'", name);
21342 print (vam->ofp, "Help is available for the following:");
21345 hash_foreach_pair (p, vam->function_by_name,
21347 vec_add1 (cmds, (u8 *)(p->key));
21351 vec_sort_with_function (cmds, cmd_cmp);
21353 for (j = 0; j < vec_len (cmds); j++)
21354 print (vam->ofp, "%s", cmds[j]);
21361 set (vat_main_t * vam)
21363 u8 *name = 0, *value = 0;
21364 unformat_input_t *i = vam->input;
21366 if (unformat (i, "%s", &name))
21368 /* The input buffer is a vector, not a string. */
21369 value = vec_dup (i->buffer);
21370 vec_delete (value, i->index, 0);
21371 /* Almost certainly has a trailing newline */
21372 if (value[vec_len (value) - 1] == '\n')
21373 value[vec_len (value) - 1] = 0;
21374 /* Make sure it's a proper string, one way or the other */
21375 vec_add1 (value, 0);
21376 (void) clib_macro_set_value (&vam->macro_main,
21377 (char *) name, (char *) value);
21380 errmsg ("usage: set <name> <value>");
21388 unset (vat_main_t * vam)
21392 if (unformat (vam->input, "%s", &name))
21393 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21394 errmsg ("unset: %s wasn't set", name);
21407 macro_sort_cmp (void *a1, void *a2)
21409 macro_sort_t *s1 = a1;
21410 macro_sort_t *s2 = a2;
21412 return strcmp ((char *) (s1->name), (char *) (s2->name));
21416 dump_macro_table (vat_main_t * vam)
21418 macro_sort_t *sort_me = 0, *sm;
21423 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21425 vec_add2 (sort_me, sm, 1);
21426 sm->name = (u8 *)(p->key);
21427 sm->value = (u8 *) (p->value[0]);
21431 vec_sort_with_function (sort_me, macro_sort_cmp);
21433 if (vec_len (sort_me))
21434 print (vam->ofp, "%-15s%s", "Name", "Value");
21436 print (vam->ofp, "The macro table is empty...");
21438 for (i = 0; i < vec_len (sort_me); i++)
21439 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21444 dump_node_table (vat_main_t * vam)
21447 vlib_node_t *node, *next_node;
21449 if (vec_len (vam->graph_nodes) == 0)
21451 print (vam->ofp, "Node table empty, issue get_node_graph...");
21455 for (i = 0; i < vec_len (vam->graph_nodes); i++)
21457 node = vam->graph_nodes[i];
21458 print (vam->ofp, "[%d] %s", i, node->name);
21459 for (j = 0; j < vec_len (node->next_nodes); j++)
21461 if (node->next_nodes[j] != ~0)
21463 next_node = vam->graph_nodes[node->next_nodes[j]];
21464 print (vam->ofp, " [%d] %s", j, next_node->name);
21472 value_sort_cmp (void *a1, void *a2)
21474 name_sort_t *n1 = a1;
21475 name_sort_t *n2 = a2;
21477 if (n1->value < n2->value)
21479 if (n1->value > n2->value)
21486 dump_msg_api_table (vat_main_t * vam)
21488 api_main_t *am = &api_main;
21489 name_sort_t *nses = 0, *ns;
21494 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21496 vec_add2 (nses, ns, 1);
21497 ns->name = (u8 *)(hp->key);
21498 ns->value = (u32) hp->value[0];
21502 vec_sort_with_function (nses, value_sort_cmp);
21504 for (i = 0; i < vec_len (nses); i++)
21505 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21511 get_msg_id (vat_main_t * vam)
21516 if (unformat (vam->input, "%s", &name_and_crc))
21518 message_index = vl_api_get_msg_index (name_and_crc);
21519 if (message_index == ~0)
21521 print (vam->ofp, " '%s' not found", name_and_crc);
21524 print (vam->ofp, " '%s' has message index %d",
21525 name_and_crc, message_index);
21528 errmsg ("name_and_crc required...");
21533 search_node_table (vat_main_t * vam)
21535 unformat_input_t *line_input = vam->input;
21538 vlib_node_t *node, *next_node;
21541 if (vam->graph_node_index_by_name == 0)
21543 print (vam->ofp, "Node table empty, issue get_node_graph...");
21547 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21549 if (unformat (line_input, "%s", &node_to_find))
21551 vec_add1 (node_to_find, 0);
21552 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21555 print (vam->ofp, "%s not found...", node_to_find);
21558 node = vam->graph_nodes[p[0]];
21559 print (vam->ofp, "[%d] %s", p[0], node->name);
21560 for (j = 0; j < vec_len (node->next_nodes); j++)
21562 if (node->next_nodes[j] != ~0)
21564 next_node = vam->graph_nodes[node->next_nodes[j]];
21565 print (vam->ofp, " [%d] %s", j, next_node->name);
21572 clib_warning ("parse error '%U'", format_unformat_error,
21578 vec_free (node_to_find);
21587 script (vat_main_t * vam)
21589 #if (VPP_API_TEST_BUILTIN==0)
21591 char *save_current_file;
21592 unformat_input_t save_input;
21593 jmp_buf save_jump_buf;
21594 u32 save_line_number;
21596 FILE *new_fp, *save_ifp;
21598 if (unformat (vam->input, "%s", &s))
21600 new_fp = fopen ((char *) s, "r");
21603 errmsg ("Couldn't open script file %s", s);
21610 errmsg ("Missing script name");
21614 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21615 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21616 save_ifp = vam->ifp;
21617 save_line_number = vam->input_line_number;
21618 save_current_file = (char *) vam->current_file;
21620 vam->input_line_number = 0;
21622 vam->current_file = s;
21625 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
21626 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21627 vam->ifp = save_ifp;
21628 vam->input_line_number = save_line_number;
21629 vam->current_file = (u8 *) save_current_file;
21634 clib_warning ("use the exec command...");
21640 echo (vat_main_t * vam)
21642 print (vam->ofp, "%v", vam->input->buffer);
21646 /* List of API message constructors, CLI names map to api_xxx */
21647 #define foreach_vpe_api_msg \
21648 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21649 _(sw_interface_dump,"") \
21650 _(sw_interface_set_flags, \
21651 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21652 _(sw_interface_add_del_address, \
21653 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
21654 _(sw_interface_set_table, \
21655 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
21656 _(sw_interface_set_mpls_enable, \
21657 "<intfc> | sw_if_index [disable | dis]") \
21658 _(sw_interface_set_vpath, \
21659 "<intfc> | sw_if_index <id> enable | disable") \
21660 _(sw_interface_set_vxlan_bypass, \
21661 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21662 _(sw_interface_set_geneve_bypass, \
21663 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21664 _(sw_interface_set_l2_xconnect, \
21665 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21666 "enable | disable") \
21667 _(sw_interface_set_l2_bridge, \
21668 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
21669 "[shg <split-horizon-group>] [bvi]\n" \
21670 "enable | disable") \
21671 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
21672 _(bridge_domain_add_del, \
21673 "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") \
21674 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
21676 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
21677 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
21678 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
21680 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21682 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21684 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
21686 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
21688 "<vpp-if-name> | sw_if_index <id>") \
21689 _(sw_interface_tap_dump, "") \
21690 _(ip_table_add_del, \
21691 "table-id <n> [ipv6]\n") \
21692 _(ip_add_del_route, \
21693 "<addr>/<mask> via <addr> [table-id <n>]\n" \
21694 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
21695 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
21696 "[multipath] [count <n>]") \
21697 _(ip_mroute_add_del, \
21698 "<src> <grp>/<mask> [table-id <n>]\n" \
21699 "[<intfc> | sw_if_index <id>] [local] [del]") \
21700 _(mpls_table_add_del, \
21701 "table-id <n>\n") \
21702 _(mpls_route_add_del, \
21703 "<label> <eos> via <addr> [table-id <n>]\n" \
21704 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
21705 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
21706 "[multipath] [count <n>]") \
21707 _(mpls_ip_bind_unbind, \
21708 "<label> <addr/len>") \
21709 _(mpls_tunnel_add_del, \
21710 " via <addr> [table-id <n>]\n" \
21711 "sw_if_index <id>] [l2] [del]") \
21712 _(proxy_arp_add_del, \
21713 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
21714 _(proxy_arp_intfc_enable_disable, \
21715 "<intfc> | sw_if_index <id> enable | disable") \
21716 _(sw_interface_set_unnumbered, \
21717 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
21718 _(ip_neighbor_add_del, \
21719 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
21720 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
21721 _(reset_vrf, "vrf <id> [ipv6]") \
21722 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
21723 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
21724 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
21725 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
21726 "[outer_vlan_id_any][inner_vlan_id_any]") \
21727 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
21728 _(reset_fib, "vrf <n> [ipv6]") \
21729 _(dhcp_proxy_config, \
21730 "svr <v46-address> src <v46-address>\n" \
21731 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
21732 _(dhcp_proxy_set_vss, \
21733 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
21734 _(dhcp_proxy_dump, "ip6") \
21735 _(dhcp_client_config, \
21736 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
21737 _(set_ip_flow_hash, \
21738 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
21739 _(sw_interface_ip6_enable_disable, \
21740 "<intfc> | sw_if_index <id> enable | disable") \
21741 _(sw_interface_ip6_set_link_local_address, \
21742 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
21743 _(ip6nd_proxy_add_del, \
21744 "<intfc> | sw_if_index <id> <ip6-address>") \
21745 _(ip6nd_proxy_dump, "") \
21746 _(sw_interface_ip6nd_ra_prefix, \
21747 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
21748 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
21749 "[nolink] [isno]") \
21750 _(sw_interface_ip6nd_ra_config, \
21751 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
21752 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
21753 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
21754 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
21755 _(l2_patch_add_del, \
21756 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21757 "enable | disable") \
21758 _(sr_localsid_add_del, \
21759 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
21760 "fib-table <num> (end.psp) sw_if_index <num>") \
21761 _(classify_add_del_table, \
21762 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
21763 " [del] [del-chain] mask <mask-value>\n" \
21764 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
21765 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
21766 _(classify_add_del_session, \
21767 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
21768 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
21769 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
21770 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
21771 _(classify_set_interface_ip_table, \
21772 "<intfc> | sw_if_index <nn> table <nn>") \
21773 _(classify_set_interface_l2_tables, \
21774 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21775 " [other-table <nn>]") \
21776 _(get_node_index, "node <node-name") \
21777 _(add_node_next, "node <node-name> next <next-node-name>") \
21778 _(l2tpv3_create_tunnel, \
21779 "client_address <ip6-addr> our_address <ip6-addr>\n" \
21780 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
21781 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
21782 _(l2tpv3_set_tunnel_cookies, \
21783 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
21784 "[new_remote_cookie <nn>]\n") \
21785 _(l2tpv3_interface_enable_disable, \
21786 "<intfc> | sw_if_index <nn> enable | disable") \
21787 _(l2tpv3_set_lookup_key, \
21788 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
21789 _(sw_if_l2tpv3_tunnel_dump, "") \
21790 _(vxlan_add_del_tunnel, \
21791 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21792 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21793 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21794 _(geneve_add_del_tunnel, \
21795 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21796 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21797 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21798 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21799 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21800 _(gre_add_del_tunnel, \
21801 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
21802 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21803 _(l2_fib_clear_table, "") \
21804 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
21805 _(l2_interface_vlan_tag_rewrite, \
21806 "<intfc> | sw_if_index <nn> \n" \
21807 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
21808 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
21809 _(create_vhost_user_if, \
21810 "socket <filename> [server] [renumber <dev_instance>] " \
21811 "[mac <mac_address>]") \
21812 _(modify_vhost_user_if, \
21813 "<intfc> | sw_if_index <nn> socket <filename>\n" \
21814 "[server] [renumber <dev_instance>]") \
21815 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
21816 _(sw_interface_vhost_user_dump, "") \
21817 _(show_version, "") \
21818 _(vxlan_gpe_add_del_tunnel, \
21819 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
21820 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21821 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
21822 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
21823 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21824 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
21825 _(interface_name_renumber, \
21826 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
21827 _(input_acl_set_interface, \
21828 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21829 " [l2-table <nn>] [del]") \
21830 _(want_ip4_arp_events, "address <ip4-address> [del]") \
21831 _(want_ip6_nd_events, "address <ip6-address> [del]") \
21832 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
21833 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
21834 _(ip_dump, "ipv4 | ipv6") \
21835 _(ipsec_spd_add_del, "spd_id <n> [del]") \
21836 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
21838 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
21839 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
21840 " integ_alg <alg> integ_key <hex>") \
21841 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
21842 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
21843 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
21844 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
21845 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
21846 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
21847 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
21848 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
21849 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
21850 _(ipsec_sa_dump, "[sa_id <n>]") \
21851 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
21852 " <alg> <hex>\n") \
21853 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
21854 _(ikev2_profile_add_del, "name <profile_name> [del]") \
21855 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
21856 "(auth_data 0x<data> | auth_data <data>)") \
21857 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
21858 "(id_data 0x<data> | id_data <data>) (local|remote)") \
21859 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
21860 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
21861 "(local|remote)") \
21862 _(ikev2_set_local_key, "file <absolute_file_path>") \
21863 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
21864 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
21865 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
21866 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
21867 _(ikev2_initiate_sa_init, "<profile_name>") \
21868 _(ikev2_initiate_del_ike_sa, "<ispi>") \
21869 _(ikev2_initiate_del_child_sa, "<ispi>") \
21870 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
21871 _(delete_loopback,"sw_if_index <nn>") \
21872 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
21873 _(map_add_domain, \
21874 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
21875 "ip6-src <ip6addr> " \
21876 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
21877 _(map_del_domain, "index <n>") \
21878 _(map_add_del_rule, \
21879 "index <n> psid <n> dst <ip6addr> [del]") \
21880 _(map_domain_dump, "") \
21881 _(map_rule_dump, "index <map-domain>") \
21882 _(want_interface_events, "enable|disable") \
21883 _(want_stats,"enable|disable") \
21884 _(get_first_msg_id, "client <name>") \
21885 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
21886 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
21887 "fib-id <nn> [ip4][ip6][default]") \
21888 _(get_node_graph, " ") \
21889 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
21890 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
21891 _(ioam_disable, "") \
21892 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
21893 " sw_if_index <sw_if_index> p <priority> " \
21894 "w <weight>] [del]") \
21895 _(one_add_del_locator, "locator-set <locator_name> " \
21896 "iface <intf> | sw_if_index <sw_if_index> " \
21897 "p <priority> w <weight> [del]") \
21898 _(one_add_del_local_eid,"vni <vni> eid " \
21899 "<ipv4|ipv6>/<prefix> | <L2 address> " \
21900 "locator-set <locator_name> [del]" \
21901 "[key-id sha1|sha256 secret-key <secret-key>]")\
21902 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
21903 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
21904 _(one_enable_disable, "enable|disable") \
21905 _(one_map_register_enable_disable, "enable|disable") \
21906 _(one_map_register_fallback_threshold, "<value>") \
21907 _(one_rloc_probe_enable_disable, "enable|disable") \
21908 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
21910 "rloc <locator> p <prio> " \
21911 "w <weight> [rloc <loc> ... ] " \
21912 "action <action> [del-all]") \
21913 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21915 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21916 _(one_use_petr, "ip-address> | disable") \
21917 _(one_map_request_mode, "src-dst|dst-only") \
21918 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21919 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21920 _(one_locator_set_dump, "[local | remote]") \
21921 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
21922 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21923 "[local] | [remote]") \
21924 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
21925 _(one_ndp_bd_get, "") \
21926 _(one_ndp_entries_get, "bd <bridge-domain>") \
21927 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
21928 _(one_l2_arp_bd_get, "") \
21929 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
21930 _(one_stats_enable_disable, "enable|disalbe") \
21931 _(show_one_stats_enable_disable, "") \
21932 _(one_eid_table_vni_dump, "") \
21933 _(one_eid_table_map_dump, "l2|l3") \
21934 _(one_map_resolver_dump, "") \
21935 _(one_map_server_dump, "") \
21936 _(one_adjacencies_get, "vni <vni>") \
21937 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
21938 _(show_one_rloc_probe_state, "") \
21939 _(show_one_map_register_state, "") \
21940 _(show_one_status, "") \
21941 _(one_stats_dump, "") \
21942 _(one_stats_flush, "") \
21943 _(one_get_map_request_itr_rlocs, "") \
21944 _(one_map_register_set_ttl, "<ttl>") \
21945 _(one_set_transport_protocol, "udp|api") \
21946 _(one_get_transport_protocol, "") \
21947 _(show_one_nsh_mapping, "") \
21948 _(show_one_pitr, "") \
21949 _(show_one_use_petr, "") \
21950 _(show_one_map_request_mode, "") \
21951 _(show_one_map_register_ttl, "") \
21952 _(show_one_map_register_fallback_threshold, "") \
21953 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
21954 " sw_if_index <sw_if_index> p <priority> " \
21955 "w <weight>] [del]") \
21956 _(lisp_add_del_locator, "locator-set <locator_name> " \
21957 "iface <intf> | sw_if_index <sw_if_index> " \
21958 "p <priority> w <weight> [del]") \
21959 _(lisp_add_del_local_eid,"vni <vni> eid " \
21960 "<ipv4|ipv6>/<prefix> | <L2 address> " \
21961 "locator-set <locator_name> [del]" \
21962 "[key-id sha1|sha256 secret-key <secret-key>]") \
21963 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
21964 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
21965 _(lisp_enable_disable, "enable|disable") \
21966 _(lisp_map_register_enable_disable, "enable|disable") \
21967 _(lisp_rloc_probe_enable_disable, "enable|disable") \
21968 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
21970 "rloc <locator> p <prio> " \
21971 "w <weight> [rloc <loc> ... ] " \
21972 "action <action> [del-all]") \
21973 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21975 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21976 _(lisp_use_petr, "<ip-address> | disable") \
21977 _(lisp_map_request_mode, "src-dst|dst-only") \
21978 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21979 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21980 _(lisp_locator_set_dump, "[local | remote]") \
21981 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
21982 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21983 "[local] | [remote]") \
21984 _(lisp_eid_table_vni_dump, "") \
21985 _(lisp_eid_table_map_dump, "l2|l3") \
21986 _(lisp_map_resolver_dump, "") \
21987 _(lisp_map_server_dump, "") \
21988 _(lisp_adjacencies_get, "vni <vni>") \
21989 _(gpe_fwd_entry_vnis_get, "") \
21990 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
21991 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
21992 "[table <table-id>]") \
21993 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
21994 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
21995 _(gpe_set_encap_mode, "lisp|vxlan") \
21996 _(gpe_get_encap_mode, "") \
21997 _(lisp_gpe_add_del_iface, "up|down") \
21998 _(lisp_gpe_enable_disable, "enable|disable") \
21999 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22000 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22001 _(show_lisp_rloc_probe_state, "") \
22002 _(show_lisp_map_register_state, "") \
22003 _(show_lisp_status, "") \
22004 _(lisp_get_map_request_itr_rlocs, "") \
22005 _(show_lisp_pitr, "") \
22006 _(show_lisp_use_petr, "") \
22007 _(show_lisp_map_request_mode, "") \
22008 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22009 _(af_packet_delete, "name <host interface name>") \
22010 _(policer_add_del, "name <policer name> <params> [del]") \
22011 _(policer_dump, "[name <policer name>]") \
22012 _(policer_classify_set_interface, \
22013 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22014 " [l2-table <nn>] [del]") \
22015 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22016 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22017 "[master|slave]") \
22018 _(netmap_delete, "name <interface name>") \
22019 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22020 _(mpls_fib_dump, "") \
22021 _(classify_table_ids, "") \
22022 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22023 _(classify_table_info, "table_id <nn>") \
22024 _(classify_session_dump, "table_id <nn>") \
22025 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22026 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22027 "[template_interval <nn>] [udp_checksum]") \
22028 _(ipfix_exporter_dump, "") \
22029 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22030 _(ipfix_classify_stream_dump, "") \
22031 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22032 _(ipfix_classify_table_dump, "") \
22033 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22034 _(sw_interface_span_dump, "[l2]") \
22035 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22036 _(pg_create_interface, "if_id <nn>") \
22037 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22038 _(pg_enable_disable, "[stream <id>] disable") \
22039 _(ip_source_and_port_range_check_add_del, \
22040 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22041 _(ip_source_and_port_range_check_interface_add_del, \
22042 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22043 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22044 _(ipsec_gre_add_del_tunnel, \
22045 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22046 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22047 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22048 _(l2_interface_pbb_tag_rewrite, \
22049 "<intfc> | sw_if_index <nn> \n" \
22050 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22051 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22052 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22053 _(flow_classify_set_interface, \
22054 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22055 _(flow_classify_dump, "type [ip4|ip6]") \
22056 _(ip_fib_dump, "") \
22057 _(ip_mfib_dump, "") \
22058 _(ip6_fib_dump, "") \
22059 _(ip6_mfib_dump, "") \
22060 _(feature_enable_disable, "arc_name <arc_name> " \
22061 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22062 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22064 _(l2_xconnect_dump, "") \
22065 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
22066 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22067 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22068 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22069 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22070 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22071 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22072 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22073 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22074 _(memfd_segment_create,"size <nnn>") \
22075 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22076 _(dns_enable_disable, "[enable][disable]") \
22077 _(dns_name_server_add_del, "<ip-address> [del]") \
22078 _(dns_resolve_name, "<hostname>") \
22079 _(dns_resolve_ip, "<ip4|ip6>") \
22080 _(dns_name_server_add_del, "<ip-address> [del]") \
22081 _(dns_resolve_name, "<hostname>") \
22082 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22083 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22085 /* List of command functions, CLI names map directly to functions */
22086 #define foreach_cli_function \
22087 _(comment, "usage: comment <ignore-rest-of-line>") \
22088 _(dump_interface_table, "usage: dump_interface_table") \
22089 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22090 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22091 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22092 _(dump_stats_table, "usage: dump_stats_table") \
22093 _(dump_macro_table, "usage: dump_macro_table ") \
22094 _(dump_node_table, "usage: dump_node_table") \
22095 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22096 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22097 _(echo, "usage: echo <message>") \
22098 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22099 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22100 _(help, "usage: help") \
22101 _(q, "usage: quit") \
22102 _(quit, "usage: quit") \
22103 _(search_node_table, "usage: search_node_table <name>...") \
22104 _(set, "usage: set <variable-name> <value>") \
22105 _(script, "usage: script <file-name>") \
22106 _(unset, "usage: unset <variable-name>")
22108 static void vl_api_##n##_t_handler_uni \
22109 (vl_api_##n##_t * mp) \
22111 vat_main_t * vam = &vat_main; \
22112 if (vam->json_output) { \
22113 vl_api_##n##_t_handler_json(mp); \
22115 vl_api_##n##_t_handler(mp); \
22118 foreach_vpe_api_reply_msg;
22119 #if VPP_API_TEST_BUILTIN == 0
22120 foreach_standalone_reply_msg;
22125 vat_api_hookup (vat_main_t * vam)
22128 vl_msg_api_set_handlers(VL_API_##N, #n, \
22129 vl_api_##n##_t_handler_uni, \
22131 vl_api_##n##_t_endian, \
22132 vl_api_##n##_t_print, \
22133 sizeof(vl_api_##n##_t), 1);
22134 foreach_vpe_api_reply_msg;
22135 #if VPP_API_TEST_BUILTIN == 0
22136 foreach_standalone_reply_msg;
22140 #if (VPP_API_TEST_BUILTIN==0)
22141 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22143 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22145 vam->function_by_name = hash_create_string (0, sizeof (uword));
22147 vam->help_by_name = hash_create_string (0, sizeof (uword));
22150 /* API messages we can send */
22151 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22152 foreach_vpe_api_msg;
22156 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22157 foreach_vpe_api_msg;
22160 /* CLI functions */
22161 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22162 foreach_cli_function;
22166 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22167 foreach_cli_function;
22171 #if VPP_API_TEST_BUILTIN
22172 static clib_error_t *
22173 vat_api_hookup_shim (vlib_main_t * vm)
22175 vat_api_hookup (&vat_main);
22179 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22183 * fd.io coding-style-patch-verification: ON
22186 * eval: (c-set-style "gnu")