2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2020 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 <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/udp/udp_local.h>
32 #include <vpp/api/vpe_msg_enum.h>
33 #include <vnet/l2/l2_classify.h>
34 #include <vnet/l2/l2_vtr.h>
35 #include <vnet/classify/in_out_acl.h>
36 #include <vnet/classify/policer_classify.h>
37 #include <vnet/classify/flow_classify.h>
38 #include <vnet/mpls/mpls.h>
39 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ip/ip6_hop_by_hop.h>
42 #include <vnet/ip/ip_source_and_port_range_check.h>
43 #include <vnet/policer/xlate.h>
44 #include <vnet/span/span.h>
45 #include <vnet/policer/policer.h>
46 #include <vnet/policer/police.h>
47 #include <vnet/mfib/mfib_types.h>
48 #include <vnet/bonding/node.h>
49 #include <vnet/qos/qos_types.h>
50 #include <vnet/ethernet/ethernet_types_api.h>
51 #include <vnet/ip/ip_types_api.h>
52 #include "vat/json_format.h"
53 #include <vnet/ip/ip_types_api.h>
54 #include <vnet/ethernet/ethernet_types_api.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 #if VPP_API_TEST_BUILTIN == 0
71 #define vl_print(handle, ...)
73 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
76 #include <vpp/api/vpe_all_api_h.h>
79 #define __plugin_msg_base 0
80 #include <vlibapi/vat_helper_macros.h>
82 void vl_api_set_elog_main (elog_main_t * m);
83 int vl_api_set_elog_trace_api_messages (int enable);
85 #if VPP_API_TEST_BUILTIN == 0
95 vat_socket_connect (vat_main_t * vam)
98 api_main_t *am = vlibapi_get_main ();
99 vam->socket_client_main = &socket_client_main;
100 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
102 0 /* default socket rx, tx buffer */ )))
105 /* vpp expects the client index in network order */
106 vam->my_client_index = htonl (socket_client_main.client_index);
107 am->my_client_index = vam->my_client_index;
110 #else /* vpp built-in case, we don't do sockets... */
112 vat_socket_connect (vat_main_t * vam)
118 vl_socket_client_read (int wait)
124 vl_socket_client_write ()
130 vl_socket_client_msg_alloc (int nbytes)
138 vat_time_now (vat_main_t * vam)
140 #if VPP_API_TEST_BUILTIN
141 return vlib_time_now (vam->vlib_main);
143 return clib_time_now (&vam->clib_time);
148 errmsg (char *fmt, ...)
150 vat_main_t *vam = &vat_main;
155 s = va_format (0, fmt, &va);
160 #if VPP_API_TEST_BUILTIN
161 vlib_cli_output (vam->vlib_main, (char *) s);
164 if (vam->ifp != stdin)
165 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
166 vam->input_line_number);
168 fformat (vam->ofp, "%s\n", (char *) s);
176 #if VPP_API_TEST_BUILTIN == 0
178 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
180 vat_main_t *vam = va_arg (*args, vat_main_t *);
181 u32 *result = va_arg (*args, u32 *);
185 if (!unformat (input, "%s", &if_name))
188 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
195 /* Parse an IP4 address %d.%d.%d.%d. */
197 unformat_ip4_address (unformat_input_t * input, va_list * args)
199 u8 *result = va_arg (*args, u8 *);
202 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
205 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
217 unformat_ethernet_address (unformat_input_t * input, va_list * args)
219 u8 *result = va_arg (*args, u8 *);
222 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
223 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
227 for (i = 0; i < 6; i++)
228 if (a[i] >= (1 << 8))
231 for (i = 0; i < 6; i++)
237 /* Returns ethernet type as an int in host byte order. */
239 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
242 u16 *result = va_arg (*args, u16 *);
246 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
248 if (type >= (1 << 16))
256 /* Parse an IP46 address. */
258 unformat_ip46_address (unformat_input_t * input, va_list * args)
260 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
261 ip46_type_t type = va_arg (*args, ip46_type_t);
262 if ((type != IP46_TYPE_IP6) &&
263 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
265 ip46_address_mask_ip4 (ip46);
268 else if ((type != IP46_TYPE_IP4) &&
269 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
276 /* Parse an IP6 address. */
278 unformat_ip6_address (unformat_input_t * input, va_list * args)
280 ip6_address_t *result = va_arg (*args, ip6_address_t *);
282 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
283 uword c, n_colon, double_colon_index;
285 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
286 double_colon_index = ARRAY_LEN (hex_quads);
287 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
290 if (c >= '0' && c <= '9')
292 else if (c >= 'a' && c <= 'f')
293 hex_digit = c + 10 - 'a';
294 else if (c >= 'A' && c <= 'F')
295 hex_digit = c + 10 - 'A';
296 else if (c == ':' && n_colon < 2)
300 unformat_put_input (input);
304 /* Too many hex quads. */
305 if (n_hex_quads >= ARRAY_LEN (hex_quads))
310 hex_quad = (hex_quad << 4) | hex_digit;
312 /* Hex quad must fit in 16 bits. */
313 if (n_hex_digits >= 4)
320 /* Save position of :: */
323 /* More than one :: ? */
324 if (double_colon_index < ARRAY_LEN (hex_quads))
326 double_colon_index = n_hex_quads;
329 if (n_colon > 0 && n_hex_digits > 0)
331 hex_quads[n_hex_quads++] = hex_quad;
337 if (n_hex_digits > 0)
338 hex_quads[n_hex_quads++] = hex_quad;
343 /* Expand :: to appropriate number of zero hex quads. */
344 if (double_colon_index < ARRAY_LEN (hex_quads))
346 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
348 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
349 hex_quads[n_zero + i] = hex_quads[i];
351 for (i = 0; i < n_zero; i++)
352 hex_quads[double_colon_index + i] = 0;
354 n_hex_quads = ARRAY_LEN (hex_quads);
357 /* Too few hex quads given. */
358 if (n_hex_quads < ARRAY_LEN (hex_quads))
361 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
362 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
369 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
371 u32 *r = va_arg (*args, u32 *);
374 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
375 foreach_ipsec_policy_action
383 format_ipsec_crypto_alg (u8 * s, va_list * args)
385 u32 i = va_arg (*args, u32);
390 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
391 foreach_ipsec_crypto_alg
394 return format (s, "unknown");
396 return format (s, "%s", t);
400 format_ipsec_integ_alg (u8 * s, va_list * args)
402 u32 i = va_arg (*args, u32);
407 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
408 foreach_ipsec_integ_alg
411 return format (s, "unknown");
413 return format (s, "%s", t);
416 #else /* VPP_API_TEST_BUILTIN == 1 */
418 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
420 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
421 vnet_main_t *vnm = vnet_get_main ();
422 u32 *result = va_arg (*args, u32 *);
424 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
427 #endif /* VPP_API_TEST_BUILTIN */
430 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
432 u32 *r = va_arg (*args, u32 *);
435 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
436 foreach_ipsec_crypto_alg
444 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
446 u32 *r = va_arg (*args, u32 *);
449 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
450 foreach_ipsec_integ_alg
458 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
460 u8 *r = va_arg (*args, u8 *);
462 if (unformat (input, "kbps"))
464 else if (unformat (input, "pps"))
472 unformat_policer_round_type (unformat_input_t * input, va_list * args)
474 u8 *r = va_arg (*args, u8 *);
476 if (unformat (input, "closest"))
477 *r = QOS_ROUND_TO_CLOSEST;
478 else if (unformat (input, "up"))
479 *r = QOS_ROUND_TO_UP;
480 else if (unformat (input, "down"))
481 *r = QOS_ROUND_TO_DOWN;
488 unformat_policer_type (unformat_input_t * input, va_list * args)
490 u8 *r = va_arg (*args, u8 *);
492 if (unformat (input, "1r2c"))
493 *r = QOS_POLICER_TYPE_1R2C;
494 else if (unformat (input, "1r3c"))
495 *r = QOS_POLICER_TYPE_1R3C_RFC_2697;
496 else if (unformat (input, "2r3c-2698"))
497 *r = QOS_POLICER_TYPE_2R3C_RFC_2698;
498 else if (unformat (input, "2r3c-4115"))
499 *r = QOS_POLICER_TYPE_2R3C_RFC_4115;
500 else if (unformat (input, "2r3c-mef5cf1"))
501 *r = QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
508 unformat_dscp (unformat_input_t * input, va_list * va)
510 u8 *r = va_arg (*va, u8 *);
513 #define _(v, f) else if (unformat (input, #f)) *r = IP_DSCP_##f;
521 unformat_policer_action_type (unformat_input_t * input, va_list * va)
523 qos_pol_action_params_st *a = va_arg (*va, qos_pol_action_params_st *);
525 if (unformat (input, "drop"))
526 a->action_type = QOS_ACTION_DROP;
527 else if (unformat (input, "transmit"))
528 a->action_type = QOS_ACTION_TRANSMIT;
529 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
530 a->action_type = QOS_ACTION_MARK_AND_TRANSMIT;
536 #if (VPP_API_TEST_BUILTIN==0)
538 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
539 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
540 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
541 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
544 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
546 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
547 mfib_itf_attribute_t attr;
550 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
552 if (unformat (input, mfib_itf_flag_long_names[attr]))
553 *iflags |= (1 << attr);
555 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
557 if (unformat (input, mfib_itf_flag_names[attr]))
558 *iflags |= (1 << attr);
561 return (old == *iflags ? 0 : 1);
565 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
567 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
568 mfib_entry_attribute_t attr;
571 FOR_EACH_MFIB_ATTRIBUTE (attr)
573 if (unformat (input, mfib_flag_long_names[attr]))
574 *eflags |= (1 << attr);
576 FOR_EACH_MFIB_ATTRIBUTE (attr)
578 if (unformat (input, mfib_flag_names[attr]))
579 *eflags |= (1 << attr);
582 return (old == *eflags ? 0 : 1);
586 format_ip4_address (u8 * s, va_list * args)
588 u8 *a = va_arg (*args, u8 *);
589 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
593 format_ip6_address (u8 * s, va_list * args)
595 ip6_address_t *a = va_arg (*args, ip6_address_t *);
596 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
598 i_max_n_zero = ARRAY_LEN (a->as_u16);
600 i_first_zero = i_max_n_zero;
602 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
604 u32 is_zero = a->as_u16[i] == 0;
605 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
611 if ((!is_zero && n_zeros > max_n_zeros)
612 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
614 i_max_n_zero = i_first_zero;
615 max_n_zeros = n_zeros;
616 i_first_zero = ARRAY_LEN (a->as_u16);
621 last_double_colon = 0;
622 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
624 if (i == i_max_n_zero && max_n_zeros > 1)
626 s = format (s, "::");
627 i += max_n_zeros - 1;
628 last_double_colon = 1;
632 s = format (s, "%s%x",
633 (last_double_colon || i == 0) ? "" : ":",
634 clib_net_to_host_u16 (a->as_u16[i]));
635 last_double_colon = 0;
642 /* Format an IP46 address. */
644 format_ip46_address (u8 * s, va_list * args)
646 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
647 ip46_type_t type = va_arg (*args, ip46_type_t);
653 is_ip4 = ip46_address_is_ip4 (ip46);
664 format (s, "%U", format_ip4_address, &ip46->ip4) :
665 format (s, "%U", format_ip6_address, &ip46->ip6);
669 format_ethernet_address (u8 * s, va_list * args)
671 u8 *a = va_arg (*args, u8 *);
673 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
674 a[0], a[1], a[2], a[3], a[4], a[5]);
679 increment_v4_address (vl_api_ip4_address_t * i)
681 ip4_address_t *a = (ip4_address_t *) i;
684 v = ntohl (a->as_u32) + 1;
685 a->as_u32 = ntohl (v);
689 increment_v6_address (vl_api_ip6_address_t * i)
691 ip6_address_t *a = (ip6_address_t *) i;
694 v0 = clib_net_to_host_u64 (a->as_u64[0]);
695 v1 = clib_net_to_host_u64 (a->as_u64[1]);
700 a->as_u64[0] = clib_net_to_host_u64 (v0);
701 a->as_u64[1] = clib_net_to_host_u64 (v1);
705 increment_address (vl_api_address_t * a)
707 if (a->af == ADDRESS_IP4)
708 increment_v4_address (&a->un.ip4);
709 else if (a->af == ADDRESS_IP6)
710 increment_v6_address (&a->un.ip6);
714 set_ip4_address (vl_api_address_t * a, u32 v)
716 if (a->af == ADDRESS_IP4)
718 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
724 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
727 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
729 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
730 sizeof (ip6_address_t));
734 increment_mac_address (u8 * mac)
736 u64 tmp = *((u64 *) mac);
737 tmp = clib_net_to_host_u64 (tmp);
738 tmp += 1 << 16; /* skip unused (least significant) octets */
739 tmp = clib_host_to_net_u64 (tmp);
741 clib_memcpy (mac, &tmp, 6);
745 vat_json_object_add_address (vat_json_node_t * node,
746 const char *str, const vl_api_address_t * addr)
748 if (ADDRESS_IP6 == addr->af)
752 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
753 vat_json_object_add_ip6 (node, str, ip6);
759 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
760 vat_json_object_add_ip4 (node, str, ip4);
765 vat_json_object_add_prefix (vat_json_node_t * node,
766 const vl_api_prefix_t * prefix)
768 vat_json_object_add_uint (node, "len", prefix->len);
769 vat_json_object_add_address (node, "address", &prefix->address);
772 static void vl_api_create_loopback_reply_t_handler
773 (vl_api_create_loopback_reply_t * mp)
775 vat_main_t *vam = &vat_main;
776 i32 retval = ntohl (mp->retval);
778 vam->retval = retval;
779 vam->regenerate_interface_table = 1;
780 vam->sw_if_index = ntohl (mp->sw_if_index);
781 vam->result_ready = 1;
784 static void vl_api_create_loopback_reply_t_handler_json
785 (vl_api_create_loopback_reply_t * mp)
787 vat_main_t *vam = &vat_main;
788 vat_json_node_t node;
790 vat_json_init_object (&node);
791 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
792 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
794 vat_json_print (vam->ofp, &node);
795 vat_json_free (&node);
796 vam->retval = ntohl (mp->retval);
797 vam->result_ready = 1;
800 static void vl_api_create_loopback_instance_reply_t_handler
801 (vl_api_create_loopback_instance_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 i32 retval = ntohl (mp->retval);
806 vam->retval = retval;
807 vam->regenerate_interface_table = 1;
808 vam->sw_if_index = ntohl (mp->sw_if_index);
809 vam->result_ready = 1;
812 static void vl_api_create_loopback_instance_reply_t_handler_json
813 (vl_api_create_loopback_instance_reply_t * mp)
815 vat_main_t *vam = &vat_main;
816 vat_json_node_t node;
818 vat_json_init_object (&node);
819 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
820 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
822 vat_json_print (vam->ofp, &node);
823 vat_json_free (&node);
824 vam->retval = ntohl (mp->retval);
825 vam->result_ready = 1;
828 static void vl_api_af_packet_create_reply_t_handler
829 (vl_api_af_packet_create_reply_t * mp)
831 vat_main_t *vam = &vat_main;
832 i32 retval = ntohl (mp->retval);
834 vam->retval = retval;
835 vam->regenerate_interface_table = 1;
836 vam->sw_if_index = ntohl (mp->sw_if_index);
837 vam->result_ready = 1;
840 static void vl_api_af_packet_create_reply_t_handler_json
841 (vl_api_af_packet_create_reply_t * mp)
843 vat_main_t *vam = &vat_main;
844 vat_json_node_t node;
846 vat_json_init_object (&node);
847 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
848 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
850 vat_json_print (vam->ofp, &node);
851 vat_json_free (&node);
853 vam->retval = ntohl (mp->retval);
854 vam->result_ready = 1;
857 static void vl_api_create_vlan_subif_reply_t_handler
858 (vl_api_create_vlan_subif_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 i32 retval = ntohl (mp->retval);
863 vam->retval = retval;
864 vam->regenerate_interface_table = 1;
865 vam->sw_if_index = ntohl (mp->sw_if_index);
866 vam->result_ready = 1;
869 static void vl_api_create_vlan_subif_reply_t_handler_json
870 (vl_api_create_vlan_subif_reply_t * mp)
872 vat_main_t *vam = &vat_main;
873 vat_json_node_t node;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
879 vat_json_print (vam->ofp, &node);
880 vat_json_free (&node);
882 vam->retval = ntohl (mp->retval);
883 vam->result_ready = 1;
886 static void vl_api_create_subif_reply_t_handler
887 (vl_api_create_subif_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 i32 retval = ntohl (mp->retval);
892 vam->retval = retval;
893 vam->regenerate_interface_table = 1;
894 vam->sw_if_index = ntohl (mp->sw_if_index);
895 vam->result_ready = 1;
898 static void vl_api_create_subif_reply_t_handler_json
899 (vl_api_create_subif_reply_t * mp)
901 vat_main_t *vam = &vat_main;
902 vat_json_node_t node;
904 vat_json_init_object (&node);
905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
906 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
908 vat_json_print (vam->ofp, &node);
909 vat_json_free (&node);
911 vam->retval = ntohl (mp->retval);
912 vam->result_ready = 1;
915 static void vl_api_interface_name_renumber_reply_t_handler
916 (vl_api_interface_name_renumber_reply_t * mp)
918 vat_main_t *vam = &vat_main;
919 i32 retval = ntohl (mp->retval);
921 vam->retval = retval;
922 vam->regenerate_interface_table = 1;
923 vam->result_ready = 1;
926 static void vl_api_interface_name_renumber_reply_t_handler_json
927 (vl_api_interface_name_renumber_reply_t * mp)
929 vat_main_t *vam = &vat_main;
930 vat_json_node_t node;
932 vat_json_init_object (&node);
933 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
935 vat_json_print (vam->ofp, &node);
936 vat_json_free (&node);
938 vam->retval = ntohl (mp->retval);
939 vam->result_ready = 1;
943 * Special-case: build the interface table, maintain
944 * the next loopback sw_if_index vbl.
946 static void vl_api_sw_interface_details_t_handler
947 (vl_api_sw_interface_details_t * mp)
949 vat_main_t *vam = &vat_main;
950 u8 *s = format (0, "%s%c", mp->interface_name, 0);
952 hash_set_mem (vam->sw_if_index_by_interface_name, s,
953 ntohl (mp->sw_if_index));
955 /* In sub interface case, fill the sub interface table entry */
956 if (mp->sw_if_index != mp->sup_sw_if_index)
958 sw_interface_subif_t *sub = NULL;
960 vec_add2 (vam->sw_if_subif_table, sub, 1);
962 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
963 strncpy ((char *) sub->interface_name, (char *) s,
964 vec_len (sub->interface_name));
965 sub->sw_if_index = ntohl (mp->sw_if_index);
966 sub->sub_id = ntohl (mp->sub_id);
968 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
970 sub->sub_number_of_tags = mp->sub_number_of_tags;
971 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
972 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
974 /* vlan tag rewrite */
975 sub->vtr_op = ntohl (mp->vtr_op);
976 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
977 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
978 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
982 static void vl_api_sw_interface_details_t_handler_json
983 (vl_api_sw_interface_details_t * mp)
985 vat_main_t *vam = &vat_main;
986 vat_json_node_t *node = NULL;
988 if (VAT_JSON_ARRAY != vam->json_tree.type)
990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
991 vat_json_init_array (&vam->json_tree);
993 node = vat_json_array_add (&vam->json_tree);
995 vat_json_init_object (node);
996 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
997 vat_json_object_add_uint (node, "sup_sw_if_index",
998 ntohl (mp->sup_sw_if_index));
999 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1000 sizeof (mp->l2_address));
1001 vat_json_object_add_string_copy (node, "interface_name",
1002 mp->interface_name);
1003 vat_json_object_add_string_copy (node, "interface_dev_type",
1004 mp->interface_dev_type);
1005 vat_json_object_add_uint (node, "flags", mp->flags);
1006 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1007 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1008 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1009 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1010 vat_json_object_add_uint (node, "sub_number_of_tags",
1011 mp->sub_number_of_tags);
1012 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1013 ntohs (mp->sub_outer_vlan_id));
1014 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1015 ntohs (mp->sub_inner_vlan_id));
1016 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1017 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1018 vat_json_object_add_uint (node, "vtr_push_dot1q",
1019 ntohl (mp->vtr_push_dot1q));
1020 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1021 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1022 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1024 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1026 format_ethernet_address,
1028 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1030 format_ethernet_address,
1032 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1033 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1037 #if VPP_API_TEST_BUILTIN == 0
1038 static void vl_api_sw_interface_event_t_handler
1039 (vl_api_sw_interface_event_t * mp)
1041 vat_main_t *vam = &vat_main;
1042 if (vam->interface_event_display)
1043 errmsg ("interface flags: sw_if_index %d %s %s",
1044 ntohl (mp->sw_if_index),
1045 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1046 "admin-up" : "admin-down",
1047 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1048 "link-up" : "link-down");
1052 __clib_unused static void
1053 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1055 /* JSON output not supported */
1059 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1061 vat_main_t *vam = &vat_main;
1062 i32 retval = ntohl (mp->retval);
1064 vam->retval = retval;
1065 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1066 vam->result_ready = 1;
1070 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1072 vat_main_t *vam = &vat_main;
1073 vat_json_node_t node;
1077 vat_json_init_object (&node);
1078 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1079 vat_json_object_add_uint (&node, "reply_in_shmem",
1080 ntohl (mp->reply_in_shmem));
1081 /* Toss the shared-memory original... */
1082 oldheap = vl_msg_push_heap ();
1084 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1087 vl_msg_pop_heap (oldheap);
1089 vat_json_print (vam->ofp, &node);
1090 vat_json_free (&node);
1092 vam->retval = ntohl (mp->retval);
1093 vam->result_ready = 1;
1097 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1099 vat_main_t *vam = &vat_main;
1100 i32 retval = ntohl (mp->retval);
1102 vec_reset_length (vam->cmd_reply);
1104 vam->retval = retval;
1106 vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1107 vam->result_ready = 1;
1111 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1113 vat_main_t *vam = &vat_main;
1114 vat_json_node_t node;
1115 u8 *reply = 0; /* reply vector */
1117 reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1118 vec_reset_length (vam->cmd_reply);
1120 vat_json_init_object (&node);
1121 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1122 vat_json_object_add_string_copy (&node, "reply", reply);
1124 vat_json_print (vam->ofp, &node);
1125 vat_json_free (&node);
1128 vam->retval = ntohl (mp->retval);
1129 vam->result_ready = 1;
1132 static void vl_api_get_node_index_reply_t_handler
1133 (vl_api_get_node_index_reply_t * mp)
1135 vat_main_t *vam = &vat_main;
1136 i32 retval = ntohl (mp->retval);
1137 if (vam->async_mode)
1139 vam->async_errors += (retval < 0);
1143 vam->retval = retval;
1145 errmsg ("node index %d", ntohl (mp->node_index));
1146 vam->result_ready = 1;
1150 static void vl_api_get_node_index_reply_t_handler_json
1151 (vl_api_get_node_index_reply_t * mp)
1153 vat_main_t *vam = &vat_main;
1154 vat_json_node_t node;
1156 vat_json_init_object (&node);
1157 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1158 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1160 vat_json_print (vam->ofp, &node);
1161 vat_json_free (&node);
1163 vam->retval = ntohl (mp->retval);
1164 vam->result_ready = 1;
1167 static void vl_api_get_next_index_reply_t_handler
1168 (vl_api_get_next_index_reply_t * mp)
1170 vat_main_t *vam = &vat_main;
1171 i32 retval = ntohl (mp->retval);
1172 if (vam->async_mode)
1174 vam->async_errors += (retval < 0);
1178 vam->retval = retval;
1180 errmsg ("next node index %d", ntohl (mp->next_index));
1181 vam->result_ready = 1;
1185 static void vl_api_get_next_index_reply_t_handler_json
1186 (vl_api_get_next_index_reply_t * mp)
1188 vat_main_t *vam = &vat_main;
1189 vat_json_node_t node;
1191 vat_json_init_object (&node);
1192 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1193 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1195 vat_json_print (vam->ofp, &node);
1196 vat_json_free (&node);
1198 vam->retval = ntohl (mp->retval);
1199 vam->result_ready = 1;
1202 static void vl_api_add_node_next_reply_t_handler
1203 (vl_api_add_node_next_reply_t * mp)
1205 vat_main_t *vam = &vat_main;
1206 i32 retval = ntohl (mp->retval);
1207 if (vam->async_mode)
1209 vam->async_errors += (retval < 0);
1213 vam->retval = retval;
1215 errmsg ("next index %d", ntohl (mp->next_index));
1216 vam->result_ready = 1;
1220 static void vl_api_add_node_next_reply_t_handler_json
1221 (vl_api_add_node_next_reply_t * mp)
1223 vat_main_t *vam = &vat_main;
1224 vat_json_node_t node;
1226 vat_json_init_object (&node);
1227 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1228 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1230 vat_json_print (vam->ofp, &node);
1231 vat_json_free (&node);
1233 vam->retval = ntohl (mp->retval);
1234 vam->result_ready = 1;
1237 static void vl_api_show_version_reply_t_handler
1238 (vl_api_show_version_reply_t * mp)
1240 vat_main_t *vam = &vat_main;
1241 i32 retval = ntohl (mp->retval);
1245 errmsg (" program: %s", mp->program);
1246 errmsg (" version: %s", mp->version);
1247 errmsg (" build date: %s", mp->build_date);
1248 errmsg ("build directory: %s", mp->build_directory);
1250 vam->retval = retval;
1251 vam->result_ready = 1;
1254 static void vl_api_show_version_reply_t_handler_json
1255 (vl_api_show_version_reply_t * mp)
1257 vat_main_t *vam = &vat_main;
1258 vat_json_node_t node;
1260 vat_json_init_object (&node);
1261 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1262 vat_json_object_add_string_copy (&node, "program", mp->program);
1263 vat_json_object_add_string_copy (&node, "version", mp->version);
1264 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1265 vat_json_object_add_string_copy (&node, "build_directory",
1266 mp->build_directory);
1268 vat_json_print (vam->ofp, &node);
1269 vat_json_free (&node);
1271 vam->retval = ntohl (mp->retval);
1272 vam->result_ready = 1;
1275 static void vl_api_show_threads_reply_t_handler
1276 (vl_api_show_threads_reply_t * mp)
1278 vat_main_t *vam = &vat_main;
1279 i32 retval = ntohl (mp->retval);
1283 count = ntohl (mp->count);
1285 for (i = 0; i < count; i++)
1287 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1288 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1289 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1290 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1291 ntohl (mp->thread_data[i].cpu_socket));
1293 vam->retval = retval;
1294 vam->result_ready = 1;
1297 static void vl_api_show_threads_reply_t_handler_json
1298 (vl_api_show_threads_reply_t * mp)
1300 vat_main_t *vam = &vat_main;
1301 vat_json_node_t node;
1302 vl_api_thread_data_t *td;
1303 i32 retval = ntohl (mp->retval);
1307 count = ntohl (mp->count);
1309 vat_json_init_object (&node);
1310 vat_json_object_add_int (&node, "retval", retval);
1311 vat_json_object_add_uint (&node, "count", count);
1313 for (i = 0; i < count; i++)
1315 td = &mp->thread_data[i];
1316 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1317 vat_json_object_add_string_copy (&node, "name", td->name);
1318 vat_json_object_add_string_copy (&node, "type", td->type);
1319 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1320 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1321 vat_json_object_add_int (&node, "core", ntohl (td->id));
1322 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1325 vat_json_print (vam->ofp, &node);
1326 vat_json_free (&node);
1328 vam->retval = retval;
1329 vam->result_ready = 1;
1333 api_show_threads (vat_main_t * vam)
1335 vl_api_show_threads_t *mp;
1339 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1340 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1342 M (SHOW_THREADS, mp);
1350 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1352 u32 n_macs = ntohl (mp->n_macs);
1353 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1354 ntohl (mp->pid), mp->client_index, n_macs);
1356 for (i = 0; i < n_macs; i++)
1358 vl_api_mac_entry_t *mac = &mp->mac[i];
1359 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1360 i + 1, ntohl (mac->sw_if_index),
1361 format_ethernet_address, mac->mac_addr, mac->action);
1368 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1370 /* JSON output not supported */
1373 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1374 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1377 * Special-case: build the bridge domain table, maintain
1378 * the next bd id vbl.
1380 static void vl_api_bridge_domain_details_t_handler
1381 (vl_api_bridge_domain_details_t * mp)
1383 vat_main_t *vam = &vat_main;
1384 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1387 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1388 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1390 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1391 ntohl (mp->bd_id), mp->learn, mp->forward,
1392 mp->flood, ntohl (mp->bvi_sw_if_index),
1393 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1397 vl_api_bridge_domain_sw_if_t *sw_ifs;
1398 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1401 sw_ifs = mp->sw_if_details;
1402 for (i = 0; i < n_sw_ifs; i++)
1408 sw_if_index = ntohl (sw_ifs->sw_if_index);
1411 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1413 if ((u32) p->value[0] == sw_if_index)
1415 sw_if_name = (u8 *)(p->key);
1420 print (vam->ofp, "%7d %3d %s", sw_if_index,
1421 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1422 "sw_if_index not found!");
1429 static void vl_api_bridge_domain_details_t_handler_json
1430 (vl_api_bridge_domain_details_t * mp)
1432 vat_main_t *vam = &vat_main;
1433 vat_json_node_t *node, *array = NULL;
1434 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1436 if (VAT_JSON_ARRAY != vam->json_tree.type)
1438 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1439 vat_json_init_array (&vam->json_tree);
1441 node = vat_json_array_add (&vam->json_tree);
1443 vat_json_init_object (node);
1444 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1445 vat_json_object_add_uint (node, "flood", mp->flood);
1446 vat_json_object_add_uint (node, "forward", mp->forward);
1447 vat_json_object_add_uint (node, "learn", mp->learn);
1448 vat_json_object_add_uint (node, "bvi_sw_if_index",
1449 ntohl (mp->bvi_sw_if_index));
1450 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1451 array = vat_json_object_add (node, "sw_if");
1452 vat_json_init_array (array);
1458 vl_api_bridge_domain_sw_if_t *sw_ifs;
1461 sw_ifs = mp->sw_if_details;
1462 for (i = 0; i < n_sw_ifs; i++)
1464 node = vat_json_array_add (array);
1465 vat_json_init_object (node);
1466 vat_json_object_add_uint (node, "sw_if_index",
1467 ntohl (sw_ifs->sw_if_index));
1468 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1474 static void vl_api_control_ping_reply_t_handler
1475 (vl_api_control_ping_reply_t * mp)
1477 vat_main_t *vam = &vat_main;
1478 i32 retval = ntohl (mp->retval);
1479 if (vam->async_mode)
1481 vam->async_errors += (retval < 0);
1485 vam->retval = retval;
1486 vam->result_ready = 1;
1488 if (vam->socket_client_main)
1489 vam->socket_client_main->control_pings_outstanding--;
1492 static void vl_api_control_ping_reply_t_handler_json
1493 (vl_api_control_ping_reply_t * mp)
1495 vat_main_t *vam = &vat_main;
1496 i32 retval = ntohl (mp->retval);
1498 if (VAT_JSON_NONE != vam->json_tree.type)
1500 vat_json_print (vam->ofp, &vam->json_tree);
1501 vat_json_free (&vam->json_tree);
1502 vam->json_tree.type = VAT_JSON_NONE;
1507 vat_json_init_array (&vam->json_tree);
1508 vat_json_print (vam->ofp, &vam->json_tree);
1509 vam->json_tree.type = VAT_JSON_NONE;
1512 vam->retval = retval;
1513 vam->result_ready = 1;
1517 vl_api_bridge_domain_set_mac_age_reply_t_handler
1518 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1520 vat_main_t *vam = &vat_main;
1521 i32 retval = ntohl (mp->retval);
1522 if (vam->async_mode)
1524 vam->async_errors += (retval < 0);
1528 vam->retval = retval;
1529 vam->result_ready = 1;
1533 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1534 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1536 vat_main_t *vam = &vat_main;
1537 vat_json_node_t node;
1539 vat_json_init_object (&node);
1540 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1542 vat_json_print (vam->ofp, &node);
1543 vat_json_free (&node);
1545 vam->retval = ntohl (mp->retval);
1546 vam->result_ready = 1;
1550 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1552 vat_main_t *vam = &vat_main;
1553 i32 retval = ntohl (mp->retval);
1554 if (vam->async_mode)
1556 vam->async_errors += (retval < 0);
1560 vam->retval = retval;
1561 vam->result_ready = 1;
1565 static void vl_api_l2_flags_reply_t_handler_json
1566 (vl_api_l2_flags_reply_t * mp)
1568 vat_main_t *vam = &vat_main;
1569 vat_json_node_t node;
1571 vat_json_init_object (&node);
1572 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1573 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1574 ntohl (mp->resulting_feature_bitmap));
1576 vat_json_print (vam->ofp, &node);
1577 vat_json_free (&node);
1579 vam->retval = ntohl (mp->retval);
1580 vam->result_ready = 1;
1583 static void vl_api_bridge_flags_reply_t_handler
1584 (vl_api_bridge_flags_reply_t * mp)
1586 vat_main_t *vam = &vat_main;
1587 i32 retval = ntohl (mp->retval);
1588 if (vam->async_mode)
1590 vam->async_errors += (retval < 0);
1594 vam->retval = retval;
1595 vam->result_ready = 1;
1599 static void vl_api_bridge_flags_reply_t_handler_json
1600 (vl_api_bridge_flags_reply_t * mp)
1602 vat_main_t *vam = &vat_main;
1603 vat_json_node_t node;
1605 vat_json_init_object (&node);
1606 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1607 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1608 ntohl (mp->resulting_feature_bitmap));
1610 vat_json_print (vam->ofp, &node);
1611 vat_json_free (&node);
1613 vam->retval = ntohl (mp->retval);
1614 vam->result_ready = 1;
1618 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1620 vat_main_t *vam = &vat_main;
1621 i32 retval = ntohl (mp->retval);
1622 if (vam->async_mode)
1624 vam->async_errors += (retval < 0);
1628 vam->retval = retval;
1629 vam->sw_if_index = ntohl (mp->sw_if_index);
1630 vam->result_ready = 1;
1635 static void vl_api_tap_create_v2_reply_t_handler_json
1636 (vl_api_tap_create_v2_reply_t * mp)
1638 vat_main_t *vam = &vat_main;
1639 vat_json_node_t node;
1641 vat_json_init_object (&node);
1642 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1643 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1645 vat_json_print (vam->ofp, &node);
1646 vat_json_free (&node);
1648 vam->retval = ntohl (mp->retval);
1649 vam->result_ready = 1;
1654 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1656 vat_main_t *vam = &vat_main;
1657 i32 retval = ntohl (mp->retval);
1658 if (vam->async_mode)
1660 vam->async_errors += (retval < 0);
1664 vam->retval = retval;
1665 vam->result_ready = 1;
1669 static void vl_api_tap_delete_v2_reply_t_handler_json
1670 (vl_api_tap_delete_v2_reply_t * mp)
1672 vat_main_t *vam = &vat_main;
1673 vat_json_node_t node;
1675 vat_json_init_object (&node);
1676 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1678 vat_json_print (vam->ofp, &node);
1679 vat_json_free (&node);
1681 vam->retval = ntohl (mp->retval);
1682 vam->result_ready = 1;
1686 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1689 vat_main_t *vam = &vat_main;
1690 i32 retval = ntohl (mp->retval);
1691 if (vam->async_mode)
1693 vam->async_errors += (retval < 0);
1697 vam->retval = retval;
1698 vam->sw_if_index = ntohl (mp->sw_if_index);
1699 vam->result_ready = 1;
1703 static void vl_api_virtio_pci_create_reply_t_handler_json
1704 (vl_api_virtio_pci_create_reply_t * mp)
1706 vat_main_t *vam = &vat_main;
1707 vat_json_node_t node;
1709 vat_json_init_object (&node);
1710 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1711 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1713 vat_json_print (vam->ofp, &node);
1714 vat_json_free (&node);
1716 vam->retval = ntohl (mp->retval);
1717 vam->result_ready = 1;
1722 vl_api_virtio_pci_create_v2_reply_t_handler
1723 (vl_api_virtio_pci_create_v2_reply_t * mp)
1725 vat_main_t *vam = &vat_main;
1726 i32 retval = ntohl (mp->retval);
1727 if (vam->async_mode)
1729 vam->async_errors += (retval < 0);
1733 vam->retval = retval;
1734 vam->sw_if_index = ntohl (mp->sw_if_index);
1735 vam->result_ready = 1;
1739 static void vl_api_virtio_pci_create_v2_reply_t_handler_json
1740 (vl_api_virtio_pci_create_v2_reply_t * mp)
1742 vat_main_t *vam = &vat_main;
1743 vat_json_node_t node;
1745 vat_json_init_object (&node);
1746 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1747 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1749 vat_json_print (vam->ofp, &node);
1750 vat_json_free (&node);
1752 vam->retval = ntohl (mp->retval);
1753 vam->result_ready = 1;
1757 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1760 vat_main_t *vam = &vat_main;
1761 i32 retval = ntohl (mp->retval);
1762 if (vam->async_mode)
1764 vam->async_errors += (retval < 0);
1768 vam->retval = retval;
1769 vam->result_ready = 1;
1773 static void vl_api_virtio_pci_delete_reply_t_handler_json
1774 (vl_api_virtio_pci_delete_reply_t * mp)
1776 vat_main_t *vam = &vat_main;
1777 vat_json_node_t node;
1779 vat_json_init_object (&node);
1780 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1782 vat_json_print (vam->ofp, &node);
1783 vat_json_free (&node);
1785 vam->retval = ntohl (mp->retval);
1786 vam->result_ready = 1;
1790 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1792 vat_main_t *vam = &vat_main;
1793 i32 retval = ntohl (mp->retval);
1795 if (vam->async_mode)
1797 vam->async_errors += (retval < 0);
1801 vam->retval = retval;
1802 vam->sw_if_index = ntohl (mp->sw_if_index);
1803 vam->result_ready = 1;
1807 static void vl_api_bond_create_reply_t_handler_json
1808 (vl_api_bond_create_reply_t * mp)
1810 vat_main_t *vam = &vat_main;
1811 vat_json_node_t node;
1813 vat_json_init_object (&node);
1814 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1815 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1817 vat_json_print (vam->ofp, &node);
1818 vat_json_free (&node);
1820 vam->retval = ntohl (mp->retval);
1821 vam->result_ready = 1;
1825 vl_api_bond_create2_reply_t_handler (vl_api_bond_create2_reply_t * mp)
1827 vat_main_t *vam = &vat_main;
1828 i32 retval = ntohl (mp->retval);
1830 if (vam->async_mode)
1832 vam->async_errors += (retval < 0);
1836 vam->retval = retval;
1837 vam->sw_if_index = ntohl (mp->sw_if_index);
1838 vam->result_ready = 1;
1842 static void vl_api_bond_create2_reply_t_handler_json
1843 (vl_api_bond_create2_reply_t * mp)
1845 vat_main_t *vam = &vat_main;
1846 vat_json_node_t node;
1848 vat_json_init_object (&node);
1849 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1850 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1852 vat_json_print (vam->ofp, &node);
1853 vat_json_free (&node);
1855 vam->retval = ntohl (mp->retval);
1856 vam->result_ready = 1;
1860 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1862 vat_main_t *vam = &vat_main;
1863 i32 retval = ntohl (mp->retval);
1865 if (vam->async_mode)
1867 vam->async_errors += (retval < 0);
1871 vam->retval = retval;
1872 vam->result_ready = 1;
1876 static void vl_api_bond_delete_reply_t_handler_json
1877 (vl_api_bond_delete_reply_t * mp)
1879 vat_main_t *vam = &vat_main;
1880 vat_json_node_t node;
1882 vat_json_init_object (&node);
1883 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1885 vat_json_print (vam->ofp, &node);
1886 vat_json_free (&node);
1888 vam->retval = ntohl (mp->retval);
1889 vam->result_ready = 1;
1893 vl_api_bond_add_member_reply_t_handler (vl_api_bond_add_member_reply_t * mp)
1895 vat_main_t *vam = &vat_main;
1896 i32 retval = ntohl (mp->retval);
1898 if (vam->async_mode)
1900 vam->async_errors += (retval < 0);
1904 vam->retval = retval;
1905 vam->result_ready = 1;
1909 static void vl_api_bond_add_member_reply_t_handler_json
1910 (vl_api_bond_add_member_reply_t * mp)
1912 vat_main_t *vam = &vat_main;
1913 vat_json_node_t node;
1915 vat_json_init_object (&node);
1916 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1918 vat_json_print (vam->ofp, &node);
1919 vat_json_free (&node);
1921 vam->retval = ntohl (mp->retval);
1922 vam->result_ready = 1;
1926 vl_api_bond_detach_member_reply_t_handler (vl_api_bond_detach_member_reply_t *
1929 vat_main_t *vam = &vat_main;
1930 i32 retval = ntohl (mp->retval);
1932 if (vam->async_mode)
1934 vam->async_errors += (retval < 0);
1938 vam->retval = retval;
1939 vam->result_ready = 1;
1943 static void vl_api_bond_detach_member_reply_t_handler_json
1944 (vl_api_bond_detach_member_reply_t * mp)
1946 vat_main_t *vam = &vat_main;
1947 vat_json_node_t node;
1949 vat_json_init_object (&node);
1950 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1952 vat_json_print (vam->ofp, &node);
1953 vat_json_free (&node);
1955 vam->retval = ntohl (mp->retval);
1956 vam->result_ready = 1;
1960 api_sw_interface_set_bond_weight (vat_main_t * vam)
1962 unformat_input_t *i = vam->input;
1963 vl_api_sw_interface_set_bond_weight_t *mp;
1964 u32 sw_if_index = ~0;
1966 u8 weight_enter = 0;
1969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
1971 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
1973 else if (unformat (i, "sw_if_index %d", &sw_if_index))
1975 else if (unformat (i, "weight %u", &weight))
1981 if (sw_if_index == ~0)
1983 errmsg ("missing interface name or sw_if_index");
1986 if (weight_enter == 0)
1988 errmsg ("missing valid weight");
1992 /* Construct the API message */
1993 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
1994 mp->sw_if_index = ntohl (sw_if_index);
1995 mp->weight = ntohl (weight);
2002 static void vl_api_sw_bond_interface_details_t_handler
2003 (vl_api_sw_bond_interface_details_t * mp)
2005 vat_main_t *vam = &vat_main;
2008 "%-16s %-12d %-12U %-13U %-14u %-14u",
2009 mp->interface_name, ntohl (mp->sw_if_index),
2010 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2011 ntohl (mp->lb), ntohl (mp->active_members), ntohl (mp->members));
2014 static void vl_api_sw_bond_interface_details_t_handler_json
2015 (vl_api_sw_bond_interface_details_t * mp)
2017 vat_main_t *vam = &vat_main;
2018 vat_json_node_t *node = NULL;
2020 if (VAT_JSON_ARRAY != vam->json_tree.type)
2022 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2023 vat_json_init_array (&vam->json_tree);
2025 node = vat_json_array_add (&vam->json_tree);
2027 vat_json_init_object (node);
2028 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2029 vat_json_object_add_string_copy (node, "interface_name",
2030 mp->interface_name);
2031 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2032 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2033 vat_json_object_add_uint (node, "active_members",
2034 ntohl (mp->active_members));
2035 vat_json_object_add_uint (node, "members", ntohl (mp->members));
2039 api_sw_bond_interface_dump (vat_main_t * vam)
2041 unformat_input_t *i = vam->input;
2042 vl_api_sw_bond_interface_dump_t *mp;
2043 vl_api_control_ping_t *mp_ping;
2045 u32 sw_if_index = ~0;
2047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2049 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2051 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2058 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2059 "interface name", "sw_if_index", "mode", "load balance",
2060 "active members", "members");
2062 /* Get list of bond interfaces */
2063 M (SW_BOND_INTERFACE_DUMP, mp);
2064 mp->sw_if_index = ntohl (sw_if_index);
2067 /* Use a control ping for synchronization */
2068 MPING (CONTROL_PING, mp_ping);
2075 static void vl_api_sw_member_interface_details_t_handler
2076 (vl_api_sw_member_interface_details_t * mp)
2078 vat_main_t *vam = &vat_main;
2081 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2082 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2083 ntohl (mp->weight), mp->is_local_numa);
2086 static void vl_api_sw_member_interface_details_t_handler_json
2087 (vl_api_sw_member_interface_details_t * mp)
2089 vat_main_t *vam = &vat_main;
2090 vat_json_node_t *node = NULL;
2092 if (VAT_JSON_ARRAY != vam->json_tree.type)
2094 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2095 vat_json_init_array (&vam->json_tree);
2097 node = vat_json_array_add (&vam->json_tree);
2099 vat_json_init_object (node);
2100 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2101 vat_json_object_add_string_copy (node, "interface_name",
2102 mp->interface_name);
2103 vat_json_object_add_uint (node, "passive", mp->is_passive);
2104 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2105 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2106 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2110 api_sw_member_interface_dump (vat_main_t * vam)
2112 unformat_input_t *i = vam->input;
2113 vl_api_sw_member_interface_dump_t *mp;
2114 vl_api_control_ping_t *mp_ping;
2115 u32 sw_if_index = ~0;
2116 u8 sw_if_index_set = 0;
2119 /* Parse args required to build the message */
2120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2122 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2123 sw_if_index_set = 1;
2124 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2125 sw_if_index_set = 1;
2130 if (sw_if_index_set == 0)
2132 errmsg ("missing vpp interface name. ");
2137 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2138 "member interface name", "sw_if_index", "passive", "long_timeout",
2139 "weight", "local numa");
2141 /* Get list of bond interfaces */
2142 M (SW_MEMBER_INTERFACE_DUMP, mp);
2143 mp->sw_if_index = ntohl (sw_if_index);
2146 /* Use a control ping for synchronization */
2147 MPING (CONTROL_PING, mp_ping);
2154 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2155 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2157 vat_main_t *vam = &vat_main;
2158 i32 retval = ntohl (mp->retval);
2159 if (vam->async_mode)
2161 vam->async_errors += (retval < 0);
2165 vam->retval = retval;
2166 vam->sw_if_index = ntohl (mp->sw_if_index);
2167 vam->result_ready = 1;
2169 vam->regenerate_interface_table = 1;
2172 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2173 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2175 vat_main_t *vam = &vat_main;
2176 vat_json_node_t node;
2178 vat_json_init_object (&node);
2179 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2180 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2181 ntohl (mp->sw_if_index));
2183 vat_json_print (vam->ofp, &node);
2184 vat_json_free (&node);
2186 vam->retval = ntohl (mp->retval);
2187 vam->result_ready = 1;
2190 static void vl_api_create_vhost_user_if_reply_t_handler
2191 (vl_api_create_vhost_user_if_reply_t * mp)
2193 vat_main_t *vam = &vat_main;
2194 i32 retval = ntohl (mp->retval);
2195 if (vam->async_mode)
2197 vam->async_errors += (retval < 0);
2201 vam->retval = retval;
2202 vam->sw_if_index = ntohl (mp->sw_if_index);
2203 vam->result_ready = 1;
2205 vam->regenerate_interface_table = 1;
2208 static void vl_api_create_vhost_user_if_reply_t_handler_json
2209 (vl_api_create_vhost_user_if_reply_t * mp)
2211 vat_main_t *vam = &vat_main;
2212 vat_json_node_t node;
2214 vat_json_init_object (&node);
2215 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2216 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2218 vat_json_print (vam->ofp, &node);
2219 vat_json_free (&node);
2221 vam->retval = ntohl (mp->retval);
2222 vam->result_ready = 1;
2225 static void vl_api_create_vhost_user_if_v2_reply_t_handler
2226 (vl_api_create_vhost_user_if_v2_reply_t * mp)
2228 vat_main_t *vam = &vat_main;
2229 i32 retval = ntohl (mp->retval);
2230 if (vam->async_mode)
2232 vam->async_errors += (retval < 0);
2236 vam->retval = retval;
2237 vam->sw_if_index = ntohl (mp->sw_if_index);
2238 vam->result_ready = 1;
2240 vam->regenerate_interface_table = 1;
2243 static void vl_api_create_vhost_user_if_v2_reply_t_handler_json
2244 (vl_api_create_vhost_user_if_v2_reply_t * mp)
2246 vat_main_t *vam = &vat_main;
2247 vat_json_node_t node;
2249 vat_json_init_object (&node);
2250 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2251 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2253 vat_json_print (vam->ofp, &node);
2254 vat_json_free (&node);
2256 vam->retval = ntohl (mp->retval);
2257 vam->result_ready = 1;
2260 static void vl_api_ip_address_details_t_handler
2261 (vl_api_ip_address_details_t * mp)
2263 vat_main_t *vam = &vat_main;
2264 static ip_address_details_t empty_ip_address_details = { {0} };
2265 ip_address_details_t *address = NULL;
2266 ip_details_t *current_ip_details = NULL;
2267 ip_details_t *details = NULL;
2269 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2271 if (!details || vam->current_sw_if_index >= vec_len (details)
2272 || !details[vam->current_sw_if_index].present)
2274 errmsg ("ip address details arrived but not stored");
2275 errmsg ("ip_dump should be called first");
2279 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2281 #define addresses (current_ip_details->addr)
2283 vec_validate_init_empty (addresses, vec_len (addresses),
2284 empty_ip_address_details);
2286 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2288 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2289 address->prefix_length = mp->prefix.len;
2293 static void vl_api_ip_address_details_t_handler_json
2294 (vl_api_ip_address_details_t * mp)
2296 vat_main_t *vam = &vat_main;
2297 vat_json_node_t *node = NULL;
2299 if (VAT_JSON_ARRAY != vam->json_tree.type)
2301 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2302 vat_json_init_array (&vam->json_tree);
2304 node = vat_json_array_add (&vam->json_tree);
2306 vat_json_init_object (node);
2307 vat_json_object_add_prefix (node, &mp->prefix);
2311 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2313 vat_main_t *vam = &vat_main;
2314 static ip_details_t empty_ip_details = { 0 };
2315 ip_details_t *ip = NULL;
2316 u32 sw_if_index = ~0;
2318 sw_if_index = ntohl (mp->sw_if_index);
2320 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2321 sw_if_index, empty_ip_details);
2323 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2330 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2332 vat_main_t *vam = &vat_main;
2334 if (VAT_JSON_ARRAY != vam->json_tree.type)
2336 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2337 vat_json_init_array (&vam->json_tree);
2339 vat_json_array_add_uint (&vam->json_tree,
2340 clib_net_to_host_u32 (mp->sw_if_index));
2343 static void vl_api_get_first_msg_id_reply_t_handler
2344 (vl_api_get_first_msg_id_reply_t * mp)
2346 vat_main_t *vam = &vat_main;
2347 i32 retval = ntohl (mp->retval);
2349 if (vam->async_mode)
2351 vam->async_errors += (retval < 0);
2355 vam->retval = retval;
2356 vam->result_ready = 1;
2360 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2364 static void vl_api_get_first_msg_id_reply_t_handler_json
2365 (vl_api_get_first_msg_id_reply_t * mp)
2367 vat_main_t *vam = &vat_main;
2368 vat_json_node_t node;
2370 vat_json_init_object (&node);
2371 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2372 vat_json_object_add_uint (&node, "first_msg_id",
2373 (uint) ntohs (mp->first_msg_id));
2375 vat_json_print (vam->ofp, &node);
2376 vat_json_free (&node);
2378 vam->retval = ntohl (mp->retval);
2379 vam->result_ready = 1;
2382 static void vl_api_get_node_graph_reply_t_handler
2383 (vl_api_get_node_graph_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 i32 retval = ntohl (mp->retval);
2387 u8 *pvt_copy, *reply;
2392 if (vam->async_mode)
2394 vam->async_errors += (retval < 0);
2398 vam->retval = retval;
2399 vam->result_ready = 1;
2402 /* "Should never happen..." */
2406 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2407 pvt_copy = vec_dup (reply);
2409 /* Toss the shared-memory original... */
2410 oldheap = vl_msg_push_heap ();
2414 vl_msg_pop_heap (oldheap);
2416 if (vam->graph_nodes)
2418 hash_free (vam->graph_node_index_by_name);
2420 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2422 node = vam->graph_nodes[0][i];
2423 vec_free (node->name);
2424 vec_free (node->next_nodes);
2427 vec_free (vam->graph_nodes[0]);
2428 vec_free (vam->graph_nodes);
2431 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2432 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2433 vec_free (pvt_copy);
2435 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2437 node = vam->graph_nodes[0][i];
2438 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2442 static void vl_api_get_node_graph_reply_t_handler_json
2443 (vl_api_get_node_graph_reply_t * mp)
2445 vat_main_t *vam = &vat_main;
2447 vat_json_node_t node;
2450 /* $$$$ make this real? */
2451 vat_json_init_object (&node);
2452 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2453 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2455 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2457 /* Toss the shared-memory original... */
2458 oldheap = vl_msg_push_heap ();
2462 vl_msg_pop_heap (oldheap);
2464 vat_json_print (vam->ofp, &node);
2465 vat_json_free (&node);
2467 vam->retval = ntohl (mp->retval);
2468 vam->result_ready = 1;
2472 format_policer_type (u8 * s, va_list * va)
2474 u32 i = va_arg (*va, u32);
2476 if (i == QOS_POLICER_TYPE_1R2C)
2477 s = format (s, "1r2c");
2478 else if (i == QOS_POLICER_TYPE_1R3C_RFC_2697)
2479 s = format (s, "1r3c");
2480 else if (i == QOS_POLICER_TYPE_2R3C_RFC_2698)
2481 s = format (s, "2r3c-2698");
2482 else if (i == QOS_POLICER_TYPE_2R3C_RFC_4115)
2483 s = format (s, "2r3c-4115");
2484 else if (i == QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2485 s = format (s, "2r3c-mef5cf1");
2487 s = format (s, "ILLEGAL");
2492 format_policer_rate_type (u8 * s, va_list * va)
2494 u32 i = va_arg (*va, u32);
2496 if (i == QOS_RATE_KBPS)
2497 s = format (s, "kbps");
2498 else if (i == QOS_RATE_PPS)
2499 s = format (s, "pps");
2501 s = format (s, "ILLEGAL");
2506 format_policer_round_type (u8 * s, va_list * va)
2508 u32 i = va_arg (*va, u32);
2510 if (i == QOS_ROUND_TO_CLOSEST)
2511 s = format (s, "closest");
2512 else if (i == QOS_ROUND_TO_UP)
2513 s = format (s, "up");
2514 else if (i == QOS_ROUND_TO_DOWN)
2515 s = format (s, "down");
2517 s = format (s, "ILLEGAL");
2522 format_policer_action_type (u8 * s, va_list * va)
2524 u32 i = va_arg (*va, u32);
2526 if (i == QOS_ACTION_DROP)
2527 s = format (s, "drop");
2528 else if (i == QOS_ACTION_TRANSMIT)
2529 s = format (s, "transmit");
2530 else if (i == QOS_ACTION_MARK_AND_TRANSMIT)
2531 s = format (s, "mark-and-transmit");
2533 s = format (s, "ILLEGAL");
2538 format_dscp (u8 * s, va_list * va)
2540 u32 i = va_arg (*va, u32);
2547 return (format (s, "%s", #f));
2551 s = format (s, "%s", t);
2552 return (format (s, "ILLEGAL"));
2556 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2558 vat_main_t *vam = &vat_main;
2559 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2561 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2562 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
2564 conform_dscp_str = format (0, "");
2566 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2567 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
2569 exceed_dscp_str = format (0, "");
2571 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2572 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
2574 violate_dscp_str = format (0, "");
2576 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2577 "rate type %U, round type %U, %s rate, %s color-aware, "
2578 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2579 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2580 "conform action %U%s, exceed action %U%s, violate action %U%s",
2582 format_policer_type, mp->type,
2585 clib_net_to_host_u64 (mp->cb),
2586 clib_net_to_host_u64 (mp->eb),
2587 format_policer_rate_type, mp->rate_type,
2588 format_policer_round_type, mp->round_type,
2589 mp->single_rate ? "single" : "dual",
2590 mp->color_aware ? "is" : "not",
2591 ntohl (mp->cir_tokens_per_period),
2592 ntohl (mp->pir_tokens_per_period),
2594 ntohl (mp->current_limit),
2595 ntohl (mp->current_bucket),
2596 ntohl (mp->extended_limit),
2597 ntohl (mp->extended_bucket),
2598 clib_net_to_host_u64 (mp->last_update_time),
2599 format_policer_action_type, mp->conform_action.type,
2601 format_policer_action_type, mp->exceed_action.type,
2603 format_policer_action_type, mp->violate_action.type,
2606 vec_free (conform_dscp_str);
2607 vec_free (exceed_dscp_str);
2608 vec_free (violate_dscp_str);
2611 static void vl_api_policer_details_t_handler_json
2612 (vl_api_policer_details_t * mp)
2614 vat_main_t *vam = &vat_main;
2615 vat_json_node_t *node;
2616 u8 *rate_type_str, *round_type_str, *type_str;
2617 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2619 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2621 format (0, "%U", format_policer_round_type, mp->round_type);
2622 type_str = format (0, "%U", format_policer_type, mp->type);
2623 conform_action_str = format (0, "%U", format_policer_action_type,
2624 mp->conform_action.type);
2625 exceed_action_str = format (0, "%U", format_policer_action_type,
2626 mp->exceed_action.type);
2627 violate_action_str = format (0, "%U", format_policer_action_type,
2628 mp->violate_action.type);
2630 if (VAT_JSON_ARRAY != vam->json_tree.type)
2632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2633 vat_json_init_array (&vam->json_tree);
2635 node = vat_json_array_add (&vam->json_tree);
2637 vat_json_init_object (node);
2638 vat_json_object_add_string_copy (node, "name", mp->name);
2639 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2640 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2641 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
2642 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
2643 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2644 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2645 vat_json_object_add_string_copy (node, "type", type_str);
2646 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2647 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2648 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2649 vat_json_object_add_uint (node, "cir_tokens_per_period",
2650 ntohl (mp->cir_tokens_per_period));
2651 vat_json_object_add_uint (node, "eir_tokens_per_period",
2652 ntohl (mp->pir_tokens_per_period));
2653 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2654 vat_json_object_add_uint (node, "current_bucket",
2655 ntohl (mp->current_bucket));
2656 vat_json_object_add_uint (node, "extended_limit",
2657 ntohl (mp->extended_limit));
2658 vat_json_object_add_uint (node, "extended_bucket",
2659 ntohl (mp->extended_bucket));
2660 vat_json_object_add_uint (node, "last_update_time",
2661 ntohl (mp->last_update_time));
2662 vat_json_object_add_string_copy (node, "conform_action",
2663 conform_action_str);
2664 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2666 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
2667 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2668 vec_free (dscp_str);
2670 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2671 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2673 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
2674 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2675 vec_free (dscp_str);
2677 vat_json_object_add_string_copy (node, "violate_action",
2678 violate_action_str);
2679 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2681 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
2682 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2683 vec_free (dscp_str);
2686 vec_free (rate_type_str);
2687 vec_free (round_type_str);
2688 vec_free (type_str);
2689 vec_free (conform_action_str);
2690 vec_free (exceed_action_str);
2691 vec_free (violate_action_str);
2694 static void vl_api_policer_add_del_reply_t_handler
2695 (vl_api_policer_add_del_reply_t * mp)
2697 vat_main_t *vam = &vat_main;
2698 i32 retval = ntohl (mp->retval);
2699 if (vam->async_mode)
2701 vam->async_errors += (retval < 0);
2705 vam->retval = retval;
2706 vam->result_ready = 1;
2707 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
2709 * Note: this is just barely thread-safe, depends on
2710 * the main thread spinning waiting for an answer...
2712 errmsg ("policer index %d", ntohl (mp->policer_index));
2716 static void vl_api_policer_add_del_reply_t_handler_json
2717 (vl_api_policer_add_del_reply_t * mp)
2719 vat_main_t *vam = &vat_main;
2720 vat_json_node_t node;
2722 vat_json_init_object (&node);
2723 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2724 vat_json_object_add_uint (&node, "policer_index",
2725 ntohl (mp->policer_index));
2727 vat_json_print (vam->ofp, &node);
2728 vat_json_free (&node);
2730 vam->retval = ntohl (mp->retval);
2731 vam->result_ready = 1;
2734 /* Format hex dump. */
2736 format_hex_bytes (u8 * s, va_list * va)
2738 u8 *bytes = va_arg (*va, u8 *);
2739 int n_bytes = va_arg (*va, int);
2742 /* Print short or long form depending on byte count. */
2743 uword short_form = n_bytes <= 32;
2744 u32 indent = format_get_indent (s);
2749 for (i = 0; i < n_bytes; i++)
2751 if (!short_form && (i % 32) == 0)
2752 s = format (s, "%08x: ", i);
2753 s = format (s, "%02x", bytes[i]);
2754 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
2755 s = format (s, "\n%U", format_white_space, indent);
2761 static void vl_api_pg_create_interface_reply_t_handler
2762 (vl_api_pg_create_interface_reply_t * mp)
2764 vat_main_t *vam = &vat_main;
2766 vam->retval = ntohl (mp->retval);
2767 vam->result_ready = 1;
2770 static void vl_api_pg_create_interface_reply_t_handler_json
2771 (vl_api_pg_create_interface_reply_t * mp)
2773 vat_main_t *vam = &vat_main;
2774 vat_json_node_t node;
2776 i32 retval = ntohl (mp->retval);
2779 vat_json_init_object (&node);
2781 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
2783 vat_json_print (vam->ofp, &node);
2784 vat_json_free (&node);
2786 vam->retval = ntohl (mp->retval);
2787 vam->result_ready = 1;
2791 * Generate boilerplate reply handlers, which
2792 * dig the return value out of the xxx_reply_t API message,
2793 * stick it into vam->retval, and set vam->result_ready
2795 * Could also do this by pointing N message decode slots at
2796 * a single function, but that could break in subtle ways.
2799 #define foreach_standard_reply_retval_handler \
2800 _(sw_interface_set_flags_reply) \
2801 _(sw_interface_add_del_address_reply) \
2802 _(sw_interface_set_rx_mode_reply) \
2803 _(sw_interface_set_rx_placement_reply) \
2804 _(sw_interface_set_table_reply) \
2805 _(sw_interface_set_mpls_enable_reply) \
2806 _(sw_interface_set_vpath_reply) \
2807 _(sw_interface_set_l2_bridge_reply) \
2808 _(sw_interface_set_bond_weight_reply) \
2809 _(bridge_domain_add_del_reply) \
2810 _(sw_interface_set_l2_xconnect_reply) \
2811 _(l2fib_add_del_reply) \
2812 _(l2fib_flush_int_reply) \
2813 _(l2fib_flush_bd_reply) \
2814 _(ip_route_add_del_reply) \
2815 _(ip_table_add_del_reply) \
2816 _(ip_table_replace_begin_reply) \
2817 _(ip_table_flush_reply) \
2818 _(ip_table_replace_end_reply) \
2819 _(ip_mroute_add_del_reply) \
2820 _(mpls_route_add_del_reply) \
2821 _(mpls_table_add_del_reply) \
2822 _(mpls_ip_bind_unbind_reply) \
2823 _(sw_interface_set_unnumbered_reply) \
2824 _(set_ip_flow_hash_reply) \
2825 _(sw_interface_ip6_enable_disable_reply) \
2826 _(l2_patch_add_del_reply) \
2827 _(sr_mpls_policy_add_reply) \
2828 _(sr_mpls_policy_mod_reply) \
2829 _(sr_mpls_policy_del_reply) \
2830 _(sr_policy_add_reply) \
2831 _(sr_policy_mod_reply) \
2832 _(sr_policy_del_reply) \
2833 _(sr_localsid_add_del_reply) \
2834 _(sr_steering_add_del_reply) \
2835 _(l2_fib_clear_table_reply) \
2836 _(l2_interface_efp_filter_reply) \
2837 _(l2_interface_vlan_tag_rewrite_reply) \
2838 _(modify_vhost_user_if_reply) \
2839 _(modify_vhost_user_if_v2_reply) \
2840 _(delete_vhost_user_if_reply) \
2841 _(want_l2_macs_events_reply) \
2842 _(ipsec_spd_add_del_reply) \
2843 _(ipsec_interface_add_del_spd_reply) \
2844 _(ipsec_spd_entry_add_del_reply) \
2845 _(ipsec_sad_entry_add_del_reply) \
2846 _(delete_loopback_reply) \
2847 _(bd_ip_mac_add_del_reply) \
2848 _(bd_ip_mac_flush_reply) \
2849 _(want_interface_events_reply) \
2850 _(sw_interface_clear_stats_reply) \
2851 _(ioam_enable_reply) \
2852 _(ioam_disable_reply) \
2853 _(af_packet_delete_reply) \
2854 _(set_ipfix_exporter_reply) \
2855 _(set_ipfix_classify_stream_reply) \
2856 _(ipfix_classify_table_add_del_reply) \
2857 _(sw_interface_span_enable_disable_reply) \
2858 _(pg_capture_reply) \
2859 _(pg_enable_disable_reply) \
2860 _(pg_interface_enable_disable_coalesce_reply) \
2861 _(ip_source_and_port_range_check_add_del_reply) \
2862 _(ip_source_and_port_range_check_interface_add_del_reply)\
2863 _(delete_subif_reply) \
2864 _(l2_interface_pbb_tag_rewrite_reply) \
2866 _(feature_enable_disable_reply) \
2867 _(sw_interface_tag_add_del_reply) \
2868 _(sw_interface_add_del_mac_address_reply) \
2869 _(hw_interface_set_mtu_reply) \
2870 _(p2p_ethernet_add_reply) \
2871 _(p2p_ethernet_del_reply) \
2872 _(tcp_configure_src_addresses_reply) \
2873 _(session_rule_add_del_reply) \
2874 _(ip_container_proxy_add_del_reply) \
2875 _(qos_record_enable_disable_reply) \
2879 static void vl_api_##n##_t_handler \
2880 (vl_api_##n##_t * mp) \
2882 vat_main_t * vam = &vat_main; \
2883 i32 retval = ntohl(mp->retval); \
2884 if (vam->async_mode) { \
2885 vam->async_errors += (retval < 0); \
2887 vam->retval = retval; \
2888 vam->result_ready = 1; \
2891 foreach_standard_reply_retval_handler;
2895 static void vl_api_##n##_t_handler_json \
2896 (vl_api_##n##_t * mp) \
2898 vat_main_t * vam = &vat_main; \
2899 vat_json_node_t node; \
2900 vat_json_init_object(&node); \
2901 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
2902 vat_json_print(vam->ofp, &node); \
2903 vam->retval = ntohl(mp->retval); \
2904 vam->result_ready = 1; \
2906 foreach_standard_reply_retval_handler;
2910 * Table of message reply handlers, must include boilerplate handlers
2914 #define foreach_vpe_api_reply_msg \
2915 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
2916 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
2917 _(SW_INTERFACE_DETAILS, sw_interface_details) \
2918 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
2919 _(CONTROL_PING_REPLY, control_ping_reply) \
2920 _(CLI_REPLY, cli_reply) \
2921 _(CLI_INBAND_REPLY, cli_inband_reply) \
2922 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
2923 sw_interface_add_del_address_reply) \
2924 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
2925 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
2926 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
2927 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
2928 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
2929 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
2930 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
2931 sw_interface_set_l2_xconnect_reply) \
2932 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
2933 sw_interface_set_l2_bridge_reply) \
2934 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
2935 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
2936 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
2937 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
2938 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
2939 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
2940 _(L2_FLAGS_REPLY, l2_flags_reply) \
2941 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
2942 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
2943 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
2944 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
2945 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
2946 _(VIRTIO_PCI_CREATE_V2_REPLY, virtio_pci_create_v2_reply) \
2947 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
2948 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
2949 _(BOND_CREATE_REPLY, bond_create_reply) \
2950 _(BOND_CREATE2_REPLY, bond_create2_reply) \
2951 _(BOND_DELETE_REPLY, bond_delete_reply) \
2952 _(BOND_ADD_MEMBER_REPLY, bond_add_member_reply) \
2953 _(BOND_DETACH_MEMBER_REPLY, bond_detach_member_reply) \
2954 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
2955 _(SW_BOND_INTERFACE_DETAILS, sw_bond_interface_details) \
2956 _(SW_MEMBER_INTERFACE_DETAILS, sw_member_interface_details) \
2957 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
2958 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
2959 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
2960 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
2961 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
2962 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
2963 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
2964 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
2965 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
2966 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
2967 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
2968 sw_interface_set_unnumbered_reply) \
2969 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
2970 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2971 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2972 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2973 sw_interface_ip6_enable_disable_reply) \
2974 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2975 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
2976 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
2977 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
2978 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
2979 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
2980 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
2981 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
2982 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
2983 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2984 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2985 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2986 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2987 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2988 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
2989 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
2990 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
2991 _(CREATE_VHOST_USER_IF_V2_REPLY, create_vhost_user_if_v2_reply) \
2992 _(MODIFY_VHOST_USER_IF_V2_REPLY, modify_vhost_user_if_v2_reply) \
2993 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
2994 _(SHOW_VERSION_REPLY, show_version_reply) \
2995 _(SHOW_THREADS_REPLY, show_threads_reply) \
2996 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
2997 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2998 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
2999 _(L2_MACS_EVENT, l2_macs_event) \
3000 _(IP_ADDRESS_DETAILS, ip_address_details) \
3001 _(IP_DETAILS, ip_details) \
3002 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3003 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3004 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
3005 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
3006 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
3007 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3008 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3009 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
3010 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
3011 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3012 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3013 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3014 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3015 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3016 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3017 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3018 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3019 _(AF_PACKET_DETAILS, af_packet_details) \
3020 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3021 _(POLICER_DETAILS, policer_details) \
3022 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
3023 _(MPLS_TABLE_DETAILS, mpls_table_details) \
3024 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
3025 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3026 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3027 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3028 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3029 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3030 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3031 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
3032 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
3033 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3034 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3035 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3036 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3037 _(PG_INTERFACE_ENABLE_DISABLE_COALESCE_REPLY, pg_interface_enable_disable_coalesce_reply) \
3038 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3039 ip_source_and_port_range_check_add_del_reply) \
3040 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3041 ip_source_and_port_range_check_interface_add_del_reply) \
3042 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3043 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3044 _(SET_PUNT_REPLY, set_punt_reply) \
3045 _(IP_TABLE_DETAILS, ip_table_details) \
3046 _(IP_ROUTE_DETAILS, ip_route_details) \
3047 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
3048 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
3049 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
3050 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
3051 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
3052 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
3053 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
3054 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
3055 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
3056 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
3057 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
3058 _(SESSION_RULES_DETAILS, session_rules_details) \
3059 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
3060 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply) \
3061 _(FLOW_ADD_REPLY, flow_add_reply) \
3063 #define foreach_standalone_reply_msg \
3064 _(SW_INTERFACE_EVENT, sw_interface_event)
3072 #define STR_VTR_OP_CASE(op) \
3073 case L2_VTR_ ## op: \
3077 str_vtr_op (u32 vtr_op)
3081 STR_VTR_OP_CASE (DISABLED);
3082 STR_VTR_OP_CASE (PUSH_1);
3083 STR_VTR_OP_CASE (PUSH_2);
3084 STR_VTR_OP_CASE (POP_1);
3085 STR_VTR_OP_CASE (POP_2);
3086 STR_VTR_OP_CASE (TRANSLATE_1_1);
3087 STR_VTR_OP_CASE (TRANSLATE_1_2);
3088 STR_VTR_OP_CASE (TRANSLATE_2_1);
3089 STR_VTR_OP_CASE (TRANSLATE_2_2);
3096 dump_sub_interface_table (vat_main_t * vam)
3098 const sw_interface_subif_t *sub = NULL;
3100 if (vam->json_output)
3103 ("JSON output supported only for VPE API calls and dump_stats_table");
3108 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
3109 "Interface", "sw_if_index",
3110 "sub id", "dot1ad", "tags", "outer id",
3111 "inner id", "exact", "default", "outer any", "inner any");
3113 vec_foreach (sub, vam->sw_if_subif_table)
3116 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
3117 sub->interface_name,
3119 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3120 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3121 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3122 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3123 if (sub->vtr_op != L2_VTR_DISABLED)
3126 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3127 "tag1: %d tag2: %d ]",
3128 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3129 sub->vtr_tag1, sub->vtr_tag2);
3137 name_sort_cmp (void *a1, void *a2)
3139 name_sort_t *n1 = a1;
3140 name_sort_t *n2 = a2;
3142 return strcmp ((char *) n1->name, (char *) n2->name);
3146 dump_interface_table (vat_main_t * vam)
3149 name_sort_t *nses = 0, *ns;
3151 if (vam->json_output)
3154 ("JSON output supported only for VPE API calls and dump_stats_table");
3159 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3161 vec_add2 (nses, ns, 1);
3162 ns->name = (u8 *)(p->key);
3163 ns->value = (u32) p->value[0];
3167 vec_sort_with_function (nses, name_sort_cmp);
3169 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
3170 vec_foreach (ns, nses)
3172 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
3179 dump_ip_table (vat_main_t * vam, int is_ipv6)
3181 const ip_details_t *det = NULL;
3182 const ip_address_details_t *address = NULL;
3185 print (vam->ofp, "%-12s", "sw_if_index");
3187 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3194 print (vam->ofp, "%-12d", i);
3195 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
3200 vec_foreach (address, det->addr)
3204 is_ipv6 ? format_ip6_address : format_ip4_address,
3205 address->ip, address->prefix_length);
3213 dump_ipv4_table (vat_main_t * vam)
3215 if (vam->json_output)
3218 ("JSON output supported only for VPE API calls and dump_stats_table");
3222 return dump_ip_table (vam, 0);
3226 dump_ipv6_table (vat_main_t * vam)
3228 if (vam->json_output)
3231 ("JSON output supported only for VPE API calls and dump_stats_table");
3235 return dump_ip_table (vam, 1);
3239 * Pass CLI buffers directly in the CLI_INBAND API message,
3240 * instead of an additional shared memory area.
3243 exec_inband (vat_main_t * vam)
3245 vl_api_cli_inband_t *mp;
3246 unformat_input_t *i = vam->input;
3249 if (vec_len (i->buffer) == 0)
3252 if (vam->exec_mode == 0 && unformat (i, "mode"))
3257 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
3264 * In order for the CLI command to work, it
3265 * must be a vector ending in \n, not a C-string ending
3268 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
3269 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
3273 /* json responses may or may not include a useful reply... */
3274 if (vec_len (vam->cmd_reply))
3275 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
3280 exec (vat_main_t * vam)
3282 return exec_inband (vam);
3286 api_create_loopback (vat_main_t * vam)
3288 unformat_input_t *i = vam->input;
3289 vl_api_create_loopback_t *mp;
3290 vl_api_create_loopback_instance_t *mp_lbi;
3293 u8 is_specified = 0;
3294 u32 user_instance = 0;
3297 clib_memset (mac_address, 0, sizeof (mac_address));
3299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3301 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
3303 if (unformat (i, "instance %d", &user_instance))
3311 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
3312 mp_lbi->is_specified = is_specified;
3314 mp_lbi->user_instance = htonl (user_instance);
3316 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
3321 /* Construct the API message */
3322 M (CREATE_LOOPBACK, mp);
3324 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
3333 api_delete_loopback (vat_main_t * vam)
3335 unformat_input_t *i = vam->input;
3336 vl_api_delete_loopback_t *mp;
3337 u32 sw_if_index = ~0;
3340 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3342 if (unformat (i, "sw_if_index %d", &sw_if_index))
3348 if (sw_if_index == ~0)
3350 errmsg ("missing sw_if_index");
3354 /* Construct the API message */
3355 M (DELETE_LOOPBACK, mp);
3356 mp->sw_if_index = ntohl (sw_if_index);
3364 api_want_interface_events (vat_main_t * vam)
3366 unformat_input_t *i = vam->input;
3367 vl_api_want_interface_events_t *mp;
3371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3373 if (unformat (i, "enable"))
3375 else if (unformat (i, "disable"))
3383 errmsg ("missing enable|disable");
3387 M (WANT_INTERFACE_EVENTS, mp);
3388 mp->enable_disable = enable;
3390 vam->interface_event_display = enable;
3398 /* Note: non-static, called once to set up the initial intfc table */
3400 api_sw_interface_dump (vat_main_t * vam)
3402 vl_api_sw_interface_dump_t *mp;
3403 vl_api_control_ping_t *mp_ping;
3405 name_sort_t *nses = 0, *ns;
3406 sw_interface_subif_t *sub = NULL;
3409 /* Toss the old name table */
3411 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3413 vec_add2 (nses, ns, 1);
3414 ns->name = (u8 *)(p->key);
3415 ns->value = (u32) p->value[0];
3419 hash_free (vam->sw_if_index_by_interface_name);
3421 vec_foreach (ns, nses) vec_free (ns->name);
3425 vec_foreach (sub, vam->sw_if_subif_table)
3427 vec_free (sub->interface_name);
3429 vec_free (vam->sw_if_subif_table);
3431 /* recreate the interface name hash table */
3432 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
3435 * Ask for all interface names. Otherwise, the epic catalog of
3436 * name filters becomes ridiculously long, and vat ends up needing
3437 * to be taught about new interface types.
3439 M (SW_INTERFACE_DUMP, mp);
3442 /* Use a control ping for synchronization */
3443 MPING (CONTROL_PING, mp_ping);
3451 api_sw_interface_set_flags (vat_main_t * vam)
3453 unformat_input_t *i = vam->input;
3454 vl_api_sw_interface_set_flags_t *mp;
3456 u8 sw_if_index_set = 0;
3460 /* Parse args required to build the message */
3461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3463 if (unformat (i, "admin-up"))
3465 else if (unformat (i, "admin-down"))
3468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3469 sw_if_index_set = 1;
3470 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3471 sw_if_index_set = 1;
3476 if (sw_if_index_set == 0)
3478 errmsg ("missing interface name or sw_if_index");
3482 /* Construct the API message */
3483 M (SW_INTERFACE_SET_FLAGS, mp);
3484 mp->sw_if_index = ntohl (sw_if_index);
3485 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
3490 /* Wait for a reply, return the good/bad news... */
3496 api_sw_interface_set_rx_mode (vat_main_t * vam)
3498 unformat_input_t *i = vam->input;
3499 vl_api_sw_interface_set_rx_mode_t *mp;
3501 u8 sw_if_index_set = 0;
3503 u8 queue_id_valid = 0;
3505 vnet_hw_if_rx_mode mode = VNET_HW_IF_RX_MODE_UNKNOWN;
3507 /* Parse args required to build the message */
3508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3510 if (unformat (i, "queue %d", &queue_id))
3512 else if (unformat (i, "polling"))
3513 mode = VNET_HW_IF_RX_MODE_POLLING;
3514 else if (unformat (i, "interrupt"))
3515 mode = VNET_HW_IF_RX_MODE_INTERRUPT;
3516 else if (unformat (i, "adaptive"))
3517 mode = VNET_HW_IF_RX_MODE_ADAPTIVE;
3519 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3520 sw_if_index_set = 1;
3521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3522 sw_if_index_set = 1;
3527 if (sw_if_index_set == 0)
3529 errmsg ("missing interface name or sw_if_index");
3532 if (mode == VNET_HW_IF_RX_MODE_UNKNOWN)
3534 errmsg ("missing rx-mode");
3538 /* Construct the API message */
3539 M (SW_INTERFACE_SET_RX_MODE, mp);
3540 mp->sw_if_index = ntohl (sw_if_index);
3541 mp->mode = (vl_api_rx_mode_t) mode;
3542 mp->queue_id_valid = queue_id_valid;
3543 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
3548 /* Wait for a reply, return the good/bad news... */
3554 api_sw_interface_set_rx_placement (vat_main_t * vam)
3556 unformat_input_t *i = vam->input;
3557 vl_api_sw_interface_set_rx_placement_t *mp;
3559 u8 sw_if_index_set = 0;
3562 u32 queue_id, thread_index;
3564 /* Parse args required to build the message */
3565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3567 if (unformat (i, "queue %d", &queue_id))
3569 else if (unformat (i, "main"))
3571 else if (unformat (i, "worker %d", &thread_index))
3574 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3575 sw_if_index_set = 1;
3576 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3577 sw_if_index_set = 1;
3582 if (sw_if_index_set == 0)
3584 errmsg ("missing interface name or sw_if_index");
3590 /* Construct the API message */
3591 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
3592 mp->sw_if_index = ntohl (sw_if_index);
3593 mp->worker_id = ntohl (thread_index);
3594 mp->queue_id = ntohl (queue_id);
3595 mp->is_main = is_main;
3599 /* Wait for a reply, return the good/bad news... */
3604 static void vl_api_sw_interface_rx_placement_details_t_handler
3605 (vl_api_sw_interface_rx_placement_details_t * mp)
3607 vat_main_t *vam = &vat_main;
3608 u32 worker_id = ntohl (mp->worker_id);
3611 "\n%-11d %-11s %-6d %-5d %-9s",
3612 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
3613 worker_id, ntohl (mp->queue_id),
3615 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
3618 static void vl_api_sw_interface_rx_placement_details_t_handler_json
3619 (vl_api_sw_interface_rx_placement_details_t * mp)
3621 vat_main_t *vam = &vat_main;
3622 vat_json_node_t *node = NULL;
3624 if (VAT_JSON_ARRAY != vam->json_tree.type)
3626 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3627 vat_json_init_array (&vam->json_tree);
3629 node = vat_json_array_add (&vam->json_tree);
3631 vat_json_init_object (node);
3632 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3633 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
3634 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
3635 vat_json_object_add_uint (node, "mode", mp->mode);
3639 api_sw_interface_rx_placement_dump (vat_main_t * vam)
3641 unformat_input_t *i = vam->input;
3642 vl_api_sw_interface_rx_placement_dump_t *mp;
3643 vl_api_control_ping_t *mp_ping;
3646 u8 sw_if_index_set = 0;
3648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3650 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3652 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3659 "\n%-11s %-11s %-6s %-5s %-4s",
3660 "sw_if_index", "main/worker", "thread", "queue", "mode");
3662 /* Dump Interface rx placement */
3663 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
3665 if (sw_if_index_set)
3666 mp->sw_if_index = htonl (sw_if_index);
3668 mp->sw_if_index = ~0;
3672 /* Use a control ping for synchronization */
3673 MPING (CONTROL_PING, mp_ping);
3681 api_sw_interface_clear_stats (vat_main_t * vam)
3683 unformat_input_t *i = vam->input;
3684 vl_api_sw_interface_clear_stats_t *mp;
3686 u8 sw_if_index_set = 0;
3689 /* Parse args required to build the message */
3690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3692 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3693 sw_if_index_set = 1;
3694 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3695 sw_if_index_set = 1;
3700 /* Construct the API message */
3701 M (SW_INTERFACE_CLEAR_STATS, mp);
3703 if (sw_if_index_set == 1)
3704 mp->sw_if_index = ntohl (sw_if_index);
3706 mp->sw_if_index = ~0;
3711 /* Wait for a reply, return the good/bad news... */
3717 api_sw_interface_add_del_address (vat_main_t * vam)
3719 unformat_input_t *i = vam->input;
3720 vl_api_sw_interface_add_del_address_t *mp;
3722 u8 sw_if_index_set = 0;
3723 u8 is_add = 1, del_all = 0;
3724 u32 address_length = 0;
3725 u8 v4_address_set = 0;
3726 u8 v6_address_set = 0;
3727 ip4_address_t v4address;
3728 ip6_address_t v6address;
3731 /* Parse args required to build the message */
3732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3734 if (unformat (i, "del-all"))
3736 else if (unformat (i, "del"))
3739 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3740 sw_if_index_set = 1;
3741 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3742 sw_if_index_set = 1;
3743 else if (unformat (i, "%U/%d",
3744 unformat_ip4_address, &v4address, &address_length))
3746 else if (unformat (i, "%U/%d",
3747 unformat_ip6_address, &v6address, &address_length))
3753 if (sw_if_index_set == 0)
3755 errmsg ("missing interface name or sw_if_index");
3758 if (v4_address_set && v6_address_set)
3760 errmsg ("both v4 and v6 addresses set");
3763 if (!v4_address_set && !v6_address_set && !del_all)
3765 errmsg ("no addresses set");
3769 /* Construct the API message */
3770 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
3772 mp->sw_if_index = ntohl (sw_if_index);
3773 mp->is_add = is_add;
3774 mp->del_all = del_all;
3777 mp->prefix.address.af = ADDRESS_IP6;
3778 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
3782 mp->prefix.address.af = ADDRESS_IP4;
3783 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
3785 mp->prefix.len = address_length;
3790 /* Wait for a reply, return good/bad news */
3796 api_sw_interface_set_mpls_enable (vat_main_t * vam)
3798 unformat_input_t *i = vam->input;
3799 vl_api_sw_interface_set_mpls_enable_t *mp;
3801 u8 sw_if_index_set = 0;
3805 /* Parse args required to build the message */
3806 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3808 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3809 sw_if_index_set = 1;
3810 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3811 sw_if_index_set = 1;
3812 else if (unformat (i, "disable"))
3814 else if (unformat (i, "dis"))
3820 if (sw_if_index_set == 0)
3822 errmsg ("missing interface name or sw_if_index");
3826 /* Construct the API message */
3827 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
3829 mp->sw_if_index = ntohl (sw_if_index);
3830 mp->enable = enable;
3835 /* Wait for a reply... */
3841 api_sw_interface_set_table (vat_main_t * vam)
3843 unformat_input_t *i = vam->input;
3844 vl_api_sw_interface_set_table_t *mp;
3845 u32 sw_if_index, vrf_id = 0;
3846 u8 sw_if_index_set = 0;
3850 /* Parse args required to build the message */
3851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3853 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3854 sw_if_index_set = 1;
3855 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3856 sw_if_index_set = 1;
3857 else if (unformat (i, "vrf %d", &vrf_id))
3859 else if (unformat (i, "ipv6"))
3865 if (sw_if_index_set == 0)
3867 errmsg ("missing interface name or sw_if_index");
3871 /* Construct the API message */
3872 M (SW_INTERFACE_SET_TABLE, mp);
3874 mp->sw_if_index = ntohl (sw_if_index);
3875 mp->is_ipv6 = is_ipv6;
3876 mp->vrf_id = ntohl (vrf_id);
3881 /* Wait for a reply... */
3886 static void vl_api_sw_interface_get_table_reply_t_handler
3887 (vl_api_sw_interface_get_table_reply_t * mp)
3889 vat_main_t *vam = &vat_main;
3891 print (vam->ofp, "%d", ntohl (mp->vrf_id));
3893 vam->retval = ntohl (mp->retval);
3894 vam->result_ready = 1;
3898 static void vl_api_sw_interface_get_table_reply_t_handler_json
3899 (vl_api_sw_interface_get_table_reply_t * mp)
3901 vat_main_t *vam = &vat_main;
3902 vat_json_node_t node;
3904 vat_json_init_object (&node);
3905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3906 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
3908 vat_json_print (vam->ofp, &node);
3909 vat_json_free (&node);
3911 vam->retval = ntohl (mp->retval);
3912 vam->result_ready = 1;
3916 api_sw_interface_get_table (vat_main_t * vam)
3918 unformat_input_t *i = vam->input;
3919 vl_api_sw_interface_get_table_t *mp;
3921 u8 sw_if_index_set = 0;
3925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3927 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3928 sw_if_index_set = 1;
3929 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3930 sw_if_index_set = 1;
3931 else if (unformat (i, "ipv6"))
3937 if (sw_if_index_set == 0)
3939 errmsg ("missing interface name or sw_if_index");
3943 M (SW_INTERFACE_GET_TABLE, mp);
3944 mp->sw_if_index = htonl (sw_if_index);
3945 mp->is_ipv6 = is_ipv6;
3953 api_sw_interface_set_vpath (vat_main_t * vam)
3955 unformat_input_t *i = vam->input;
3956 vl_api_sw_interface_set_vpath_t *mp;
3957 u32 sw_if_index = 0;
3958 u8 sw_if_index_set = 0;
3962 /* Parse args required to build the message */
3963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3965 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3966 sw_if_index_set = 1;
3967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3968 sw_if_index_set = 1;
3969 else if (unformat (i, "enable"))
3971 else if (unformat (i, "disable"))
3977 if (sw_if_index_set == 0)
3979 errmsg ("missing interface name or sw_if_index");
3983 /* Construct the API message */
3984 M (SW_INTERFACE_SET_VPATH, mp);
3986 mp->sw_if_index = ntohl (sw_if_index);
3987 mp->enable = is_enable;
3992 /* Wait for a reply... */
3998 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4000 unformat_input_t *i = vam->input;
4001 vl_api_sw_interface_set_l2_xconnect_t *mp;
4003 u8 rx_sw_if_index_set = 0;
4005 u8 tx_sw_if_index_set = 0;
4009 /* Parse args required to build the message */
4010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4012 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4013 rx_sw_if_index_set = 1;
4014 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4015 tx_sw_if_index_set = 1;
4016 else if (unformat (i, "rx"))
4018 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4020 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4022 rx_sw_if_index_set = 1;
4027 else if (unformat (i, "tx"))
4029 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4031 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4033 tx_sw_if_index_set = 1;
4038 else if (unformat (i, "enable"))
4040 else if (unformat (i, "disable"))
4046 if (rx_sw_if_index_set == 0)
4048 errmsg ("missing rx interface name or rx_sw_if_index");
4052 if (enable && (tx_sw_if_index_set == 0))
4054 errmsg ("missing tx interface name or tx_sw_if_index");
4058 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
4060 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4061 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4062 mp->enable = enable;
4070 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4072 unformat_input_t *i = vam->input;
4073 vl_api_sw_interface_set_l2_bridge_t *mp;
4074 vl_api_l2_port_type_t port_type;
4076 u8 rx_sw_if_index_set = 0;
4083 port_type = L2_API_PORT_TYPE_NORMAL;
4085 /* Parse args required to build the message */
4086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4088 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4089 rx_sw_if_index_set = 1;
4090 else if (unformat (i, "bd_id %d", &bd_id))
4094 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
4095 rx_sw_if_index_set = 1;
4096 else if (unformat (i, "shg %d", &shg))
4098 else if (unformat (i, "bvi"))
4099 port_type = L2_API_PORT_TYPE_BVI;
4100 else if (unformat (i, "uu-fwd"))
4101 port_type = L2_API_PORT_TYPE_UU_FWD;
4102 else if (unformat (i, "enable"))
4104 else if (unformat (i, "disable"))
4110 if (rx_sw_if_index_set == 0)
4112 errmsg ("missing rx interface name or sw_if_index");
4116 if (enable && (bd_id_set == 0))
4118 errmsg ("missing bridge domain");
4122 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
4124 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4125 mp->bd_id = ntohl (bd_id);
4127 mp->port_type = ntohl (port_type);
4128 mp->enable = enable;
4136 api_bridge_domain_dump (vat_main_t * vam)
4138 unformat_input_t *i = vam->input;
4139 vl_api_bridge_domain_dump_t *mp;
4140 vl_api_control_ping_t *mp_ping;
4144 /* Parse args required to build the message */
4145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4147 if (unformat (i, "bd_id %d", &bd_id))
4153 M (BRIDGE_DOMAIN_DUMP, mp);
4154 mp->bd_id = ntohl (bd_id);
4157 /* Use a control ping for synchronization */
4158 MPING (CONTROL_PING, mp_ping);
4166 api_bridge_domain_add_del (vat_main_t * vam)
4168 unformat_input_t *i = vam->input;
4169 vl_api_bridge_domain_add_del_t *mp;
4172 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4177 /* Parse args required to build the message */
4178 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4180 if (unformat (i, "bd_id %d", &bd_id))
4182 else if (unformat (i, "flood %d", &flood))
4184 else if (unformat (i, "uu-flood %d", &uu_flood))
4186 else if (unformat (i, "forward %d", &forward))
4188 else if (unformat (i, "learn %d", &learn))
4190 else if (unformat (i, "arp-term %d", &arp_term))
4192 else if (unformat (i, "mac-age %d", &mac_age))
4194 else if (unformat (i, "bd-tag %s", &bd_tag))
4196 else if (unformat (i, "del"))
4199 flood = uu_flood = forward = learn = 0;
4207 errmsg ("missing bridge domain");
4214 errmsg ("mac age must be less than 256 ");
4219 if ((bd_tag) && (vec_len (bd_tag) > 63))
4221 errmsg ("bd-tag cannot be longer than 63");
4226 M (BRIDGE_DOMAIN_ADD_DEL, mp);
4228 mp->bd_id = ntohl (bd_id);
4230 mp->uu_flood = uu_flood;
4231 mp->forward = forward;
4233 mp->arp_term = arp_term;
4234 mp->is_add = is_add;
4235 mp->mac_age = (u8) mac_age;
4238 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
4239 mp->bd_tag[vec_len (bd_tag)] = 0;
4250 api_l2fib_flush_bd (vat_main_t * vam)
4252 unformat_input_t *i = vam->input;
4253 vl_api_l2fib_flush_bd_t *mp;
4257 /* Parse args required to build the message */
4258 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4260 if (unformat (i, "bd_id %d", &bd_id));
4267 errmsg ("missing bridge domain");
4271 M (L2FIB_FLUSH_BD, mp);
4273 mp->bd_id = htonl (bd_id);
4281 api_l2fib_flush_int (vat_main_t * vam)
4283 unformat_input_t *i = vam->input;
4284 vl_api_l2fib_flush_int_t *mp;
4285 u32 sw_if_index = ~0;
4288 /* Parse args required to build the message */
4289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4291 if (unformat (i, "sw_if_index %d", &sw_if_index));
4293 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
4298 if (sw_if_index == ~0)
4300 errmsg ("missing interface name or sw_if_index");
4304 M (L2FIB_FLUSH_INT, mp);
4306 mp->sw_if_index = ntohl (sw_if_index);
4314 api_l2fib_add_del (vat_main_t * vam)
4316 unformat_input_t *i = vam->input;
4317 vl_api_l2fib_add_del_t *mp;
4323 u32 sw_if_index = 0;
4324 u8 sw_if_index_set = 0;
4333 /* Parse args required to build the message */
4334 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4336 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
4338 else if (unformat (i, "bd_id %d", &bd_id))
4340 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4341 sw_if_index_set = 1;
4342 else if (unformat (i, "sw_if"))
4344 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4347 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4348 sw_if_index_set = 1;
4353 else if (unformat (i, "static"))
4355 else if (unformat (i, "filter"))
4360 else if (unformat (i, "bvi"))
4365 else if (unformat (i, "del"))
4367 else if (unformat (i, "count %d", &count))
4375 errmsg ("missing mac address");
4381 errmsg ("missing bridge domain");
4385 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
4387 errmsg ("missing interface name or sw_if_index");
4393 /* Turn on async mode */
4394 vam->async_mode = 1;
4395 vam->async_errors = 0;
4396 before = vat_time_now (vam);
4399 for (j = 0; j < count; j++)
4401 M (L2FIB_ADD_DEL, mp);
4403 clib_memcpy (mp->mac, mac, 6);
4404 mp->bd_id = ntohl (bd_id);
4405 mp->is_add = is_add;
4406 mp->sw_if_index = ntohl (sw_if_index);
4410 mp->static_mac = static_mac;
4411 mp->filter_mac = filter_mac;
4412 mp->bvi_mac = bvi_mac;
4414 increment_mac_address (mac);
4421 vl_api_control_ping_t *mp_ping;
4424 /* Shut off async mode */
4425 vam->async_mode = 0;
4427 MPING (CONTROL_PING, mp_ping);
4430 timeout = vat_time_now (vam) + 1.0;
4431 while (vat_time_now (vam) < timeout)
4432 if (vam->result_ready == 1)
4437 if (vam->retval == -99)
4440 if (vam->async_errors > 0)
4442 errmsg ("%d asynchronous errors", vam->async_errors);
4445 vam->async_errors = 0;
4446 after = vat_time_now (vam);
4448 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4449 count, after - before, count / (after - before));
4455 /* Wait for a reply... */
4459 /* Return the good/bad news */
4460 return (vam->retval);
4464 api_bridge_domain_set_mac_age (vat_main_t * vam)
4466 unformat_input_t *i = vam->input;
4467 vl_api_bridge_domain_set_mac_age_t *mp;
4472 /* Parse args required to build the message */
4473 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4475 if (unformat (i, "bd_id %d", &bd_id));
4476 else if (unformat (i, "mac-age %d", &mac_age));
4483 errmsg ("missing bridge domain");
4489 errmsg ("mac age must be less than 256 ");
4493 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
4495 mp->bd_id = htonl (bd_id);
4496 mp->mac_age = (u8) mac_age;
4504 api_l2_flags (vat_main_t * vam)
4506 unformat_input_t *i = vam->input;
4507 vl_api_l2_flags_t *mp;
4510 u8 sw_if_index_set = 0;
4514 /* Parse args required to build the message */
4515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4517 if (unformat (i, "sw_if_index %d", &sw_if_index))
4518 sw_if_index_set = 1;
4519 else if (unformat (i, "sw_if"))
4521 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4524 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4525 sw_if_index_set = 1;
4530 else if (unformat (i, "learn"))
4532 else if (unformat (i, "forward"))
4534 else if (unformat (i, "flood"))
4536 else if (unformat (i, "uu-flood"))
4537 flags |= L2_UU_FLOOD;
4538 else if (unformat (i, "arp-term"))
4539 flags |= L2_ARP_TERM;
4540 else if (unformat (i, "off"))
4542 else if (unformat (i, "disable"))
4548 if (sw_if_index_set == 0)
4550 errmsg ("missing interface name or sw_if_index");
4556 mp->sw_if_index = ntohl (sw_if_index);
4557 mp->feature_bitmap = ntohl (flags);
4558 mp->is_set = is_set;
4566 api_bridge_flags (vat_main_t * vam)
4568 unformat_input_t *i = vam->input;
4569 vl_api_bridge_flags_t *mp;
4573 bd_flags_t flags = 0;
4576 /* Parse args required to build the message */
4577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4579 if (unformat (i, "bd_id %d", &bd_id))
4581 else if (unformat (i, "learn"))
4582 flags |= BRIDGE_API_FLAG_LEARN;
4583 else if (unformat (i, "forward"))
4584 flags |= BRIDGE_API_FLAG_FWD;
4585 else if (unformat (i, "flood"))
4586 flags |= BRIDGE_API_FLAG_FLOOD;
4587 else if (unformat (i, "uu-flood"))
4588 flags |= BRIDGE_API_FLAG_UU_FLOOD;
4589 else if (unformat (i, "arp-term"))
4590 flags |= BRIDGE_API_FLAG_ARP_TERM;
4591 else if (unformat (i, "off"))
4593 else if (unformat (i, "disable"))
4601 errmsg ("missing bridge domain");
4605 M (BRIDGE_FLAGS, mp);
4607 mp->bd_id = ntohl (bd_id);
4608 mp->flags = ntohl (flags);
4609 mp->is_set = is_set;
4617 api_bd_ip_mac_add_del (vat_main_t * vam)
4619 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
4620 vl_api_mac_address_t mac = { 0 };
4621 unformat_input_t *i = vam->input;
4622 vl_api_bd_ip_mac_add_del_t *mp;
4631 /* Parse args required to build the message */
4632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4634 if (unformat (i, "bd_id %d", &bd_id))
4638 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
4642 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
4646 else if (unformat (i, "del"))
4654 errmsg ("missing bridge domain");
4657 else if (ip_set == 0)
4659 errmsg ("missing IP address");
4662 else if (mac_set == 0)
4664 errmsg ("missing MAC address");
4668 M (BD_IP_MAC_ADD_DEL, mp);
4670 mp->entry.bd_id = ntohl (bd_id);
4671 mp->is_add = is_add;
4673 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
4674 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
4682 api_bd_ip_mac_flush (vat_main_t * vam)
4684 unformat_input_t *i = vam->input;
4685 vl_api_bd_ip_mac_flush_t *mp;
4690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4692 if (unformat (i, "bd_id %d", &bd_id))
4702 errmsg ("missing bridge domain");
4706 M (BD_IP_MAC_FLUSH, mp);
4708 mp->bd_id = ntohl (bd_id);
4715 static void vl_api_bd_ip_mac_details_t_handler
4716 (vl_api_bd_ip_mac_details_t * mp)
4718 vat_main_t *vam = &vat_main;
4722 ntohl (mp->entry.bd_id),
4723 format_vl_api_mac_address, mp->entry.mac,
4724 format_vl_api_address, &mp->entry.ip);
4727 static void vl_api_bd_ip_mac_details_t_handler_json
4728 (vl_api_bd_ip_mac_details_t * mp)
4730 vat_main_t *vam = &vat_main;
4731 vat_json_node_t *node = NULL;
4733 if (VAT_JSON_ARRAY != vam->json_tree.type)
4735 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4736 vat_json_init_array (&vam->json_tree);
4738 node = vat_json_array_add (&vam->json_tree);
4740 vat_json_init_object (node);
4741 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
4742 vat_json_object_add_string_copy (node, "mac_address",
4743 format (0, "%U", format_vl_api_mac_address,
4747 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
4748 vat_json_object_add_string_copy (node, "ip_address", ip);
4753 api_bd_ip_mac_dump (vat_main_t * vam)
4755 unformat_input_t *i = vam->input;
4756 vl_api_bd_ip_mac_dump_t *mp;
4757 vl_api_control_ping_t *mp_ping;
4762 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4764 if (unformat (i, "bd_id %d", &bd_id))
4773 "\n%-5s %-7s %-20s %-30s",
4774 "bd_id", "is_ipv6", "mac_address", "ip_address");
4776 /* Dump Bridge Domain Ip to Mac entries */
4777 M (BD_IP_MAC_DUMP, mp);
4780 mp->bd_id = htonl (bd_id);
4786 /* Use a control ping for synchronization */
4787 MPING (CONTROL_PING, mp_ping);
4795 api_tap_create_v2 (vat_main_t * vam)
4797 unformat_input_t *i = vam->input;
4798 vl_api_tap_create_v2_t *mp;
4802 u32 num_rx_queues = 0;
4803 u8 *host_if_name = 0;
4804 u8 host_if_name_set = 0;
4807 u8 host_mac_addr[6];
4808 u8 host_mac_addr_set = 0;
4809 u8 *host_bridge = 0;
4810 u8 host_bridge_set = 0;
4811 u8 host_ip4_prefix_set = 0;
4812 u8 host_ip6_prefix_set = 0;
4813 ip4_address_t host_ip4_addr;
4814 ip4_address_t host_ip4_gw;
4815 u8 host_ip4_gw_set = 0;
4816 u32 host_ip4_prefix_len = 0;
4817 ip6_address_t host_ip6_addr;
4818 ip6_address_t host_ip6_gw;
4819 u8 host_ip6_gw_set = 0;
4820 u32 host_ip6_prefix_len = 0;
4821 u32 host_mtu_size = 0;
4822 u8 host_mtu_set = 0;
4825 u32 rx_ring_sz = 0, tx_ring_sz = 0;
4827 clib_memset (mac_address, 0, sizeof (mac_address));
4829 /* Parse args required to build the message */
4830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4832 if (unformat (i, "id %u", &id))
4836 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
4838 else if (unformat (i, "host-if-name %s", &host_if_name))
4839 host_if_name_set = 1;
4840 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
4842 else if (unformat (i, "host-ns %s", &host_ns))
4844 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
4846 host_mac_addr_set = 1;
4847 else if (unformat (i, "host-bridge %s", &host_bridge))
4848 host_bridge_set = 1;
4849 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
4850 &host_ip4_addr, &host_ip4_prefix_len))
4851 host_ip4_prefix_set = 1;
4852 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
4853 &host_ip6_addr, &host_ip6_prefix_len))
4854 host_ip6_prefix_set = 1;
4855 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
4857 host_ip4_gw_set = 1;
4858 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
4860 host_ip6_gw_set = 1;
4861 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
4863 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
4865 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
4867 else if (unformat (i, "no-gso"))
4868 tap_flags &= ~TAP_API_FLAG_GSO;
4869 else if (unformat (i, "gso"))
4870 tap_flags |= TAP_API_FLAG_GSO;
4871 else if (unformat (i, "csum-offload"))
4872 tap_flags |= TAP_API_FLAG_CSUM_OFFLOAD;
4873 else if (unformat (i, "persist"))
4874 tap_flags |= TAP_API_FLAG_PERSIST;
4875 else if (unformat (i, "attach"))
4876 tap_flags |= TAP_API_FLAG_ATTACH;
4877 else if (unformat (i, "tun"))
4878 tap_flags |= TAP_API_FLAG_TUN;
4879 else if (unformat (i, "gro-coalesce"))
4880 tap_flags |= TAP_API_FLAG_GRO_COALESCE;
4881 else if (unformat (i, "packed"))
4882 tap_flags |= TAP_API_FLAG_PACKED;
4883 else if (unformat (i, "in-order"))
4884 tap_flags |= TAP_API_FLAG_IN_ORDER;
4889 if (vec_len (host_if_name) > 63)
4891 errmsg ("tap name too long. ");
4894 if (vec_len (host_ns) > 63)
4896 errmsg ("host name space too long. ");
4899 if (vec_len (host_bridge) > 63)
4901 errmsg ("host bridge name too long. ");
4904 if (host_ip4_prefix_len > 32)
4906 errmsg ("host ip4 prefix length not valid. ");
4909 if (host_ip6_prefix_len > 128)
4911 errmsg ("host ip6 prefix length not valid. ");
4914 if (!is_pow2 (rx_ring_sz))
4916 errmsg ("rx ring size must be power of 2. ");
4919 if (rx_ring_sz > 32768)
4921 errmsg ("rx ring size must be 32768 or lower. ");
4924 if (!is_pow2 (tx_ring_sz))
4926 errmsg ("tx ring size must be power of 2. ");
4929 if (tx_ring_sz > 32768)
4931 errmsg ("tx ring size must be 32768 or lower. ");
4934 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
4936 errmsg ("host MTU size must be in between 64 and 65355. ");
4940 /* Construct the API message */
4941 M (TAP_CREATE_V2, mp);
4943 mp->id = ntohl (id);
4944 mp->use_random_mac = random_mac;
4945 mp->num_rx_queues = (u8) num_rx_queues;
4946 mp->tx_ring_sz = ntohs (tx_ring_sz);
4947 mp->rx_ring_sz = ntohs (rx_ring_sz);
4948 mp->host_mtu_set = host_mtu_set;
4949 mp->host_mtu_size = ntohl (host_mtu_size);
4950 mp->host_mac_addr_set = host_mac_addr_set;
4951 mp->host_ip4_prefix_set = host_ip4_prefix_set;
4952 mp->host_ip6_prefix_set = host_ip6_prefix_set;
4953 mp->host_ip4_gw_set = host_ip4_gw_set;
4954 mp->host_ip6_gw_set = host_ip6_gw_set;
4955 mp->tap_flags = ntohl (tap_flags);
4956 mp->host_namespace_set = host_ns_set;
4957 mp->host_if_name_set = host_if_name_set;
4958 mp->host_bridge_set = host_bridge_set;
4960 if (random_mac == 0)
4961 clib_memcpy (mp->mac_address, mac_address, 6);
4962 if (host_mac_addr_set)
4963 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
4964 if (host_if_name_set)
4965 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
4967 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
4968 if (host_bridge_set)
4969 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
4970 if (host_ip4_prefix_set)
4972 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
4973 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
4975 if (host_ip6_prefix_set)
4977 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
4978 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
4980 if (host_ip4_gw_set)
4981 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
4982 if (host_ip6_gw_set)
4983 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
4986 vec_free (host_if_name);
4987 vec_free (host_bridge);
4992 /* Wait for a reply... */
4998 api_tap_delete_v2 (vat_main_t * vam)
5000 unformat_input_t *i = vam->input;
5001 vl_api_tap_delete_v2_t *mp;
5002 u32 sw_if_index = ~0;
5003 u8 sw_if_index_set = 0;
5006 /* Parse args required to build the message */
5007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5009 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5010 sw_if_index_set = 1;
5011 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5012 sw_if_index_set = 1;
5017 if (sw_if_index_set == 0)
5019 errmsg ("missing vpp interface name. ");
5023 /* Construct the API message */
5024 M (TAP_DELETE_V2, mp);
5026 mp->sw_if_index = ntohl (sw_if_index);
5031 /* Wait for a reply... */
5037 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
5039 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
5042 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
5045 addr->domain = x[0];
5048 addr->function = x[3];
5054 api_virtio_pci_create_v2 (vat_main_t * vam)
5056 unformat_input_t *i = vam->input;
5057 vl_api_virtio_pci_create_v2_t *mp;
5061 u64 features = (u64) ~ (0ULL);
5062 u32 virtio_flags = 0;
5065 clib_memset (mac_address, 0, sizeof (mac_address));
5067 /* Parse args required to build the message */
5068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5070 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
5074 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
5076 else if (unformat (i, "features 0x%llx", &features))
5078 else if (unformat (i, "gso-enabled"))
5079 virtio_flags |= VIRTIO_API_FLAG_GSO;
5080 else if (unformat (i, "csum-offload-enabled"))
5081 virtio_flags |= VIRTIO_API_FLAG_CSUM_OFFLOAD;
5082 else if (unformat (i, "gro-coalesce"))
5083 virtio_flags |= VIRTIO_API_FLAG_GRO_COALESCE;
5084 else if (unformat (i, "packed"))
5085 virtio_flags |= VIRTIO_API_FLAG_PACKED;
5086 else if (unformat (i, "in-order"))
5087 virtio_flags |= VIRTIO_API_FLAG_IN_ORDER;
5088 else if (unformat (i, "buffering"))
5089 virtio_flags |= VIRTIO_API_FLAG_BUFFERING;
5096 errmsg ("pci address must be non zero. ");
5100 /* Construct the API message */
5101 M (VIRTIO_PCI_CREATE_V2, mp);
5103 mp->use_random_mac = random_mac;
5105 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
5106 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
5107 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
5108 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
5110 mp->features = clib_host_to_net_u64 (features);
5111 mp->virtio_flags = clib_host_to_net_u32 (virtio_flags);
5113 if (random_mac == 0)
5114 clib_memcpy (mp->mac_address, mac_address, 6);
5119 /* Wait for a reply... */
5125 api_virtio_pci_delete (vat_main_t * vam)
5127 unformat_input_t *i = vam->input;
5128 vl_api_virtio_pci_delete_t *mp;
5129 u32 sw_if_index = ~0;
5130 u8 sw_if_index_set = 0;
5133 /* Parse args required to build the message */
5134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5137 sw_if_index_set = 1;
5138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5139 sw_if_index_set = 1;
5144 if (sw_if_index_set == 0)
5146 errmsg ("missing vpp interface name. ");
5150 /* Construct the API message */
5151 M (VIRTIO_PCI_DELETE, mp);
5153 mp->sw_if_index = htonl (sw_if_index);
5158 /* Wait for a reply... */
5164 api_bond_create (vat_main_t * vam)
5166 unformat_input_t *i = vam->input;
5167 vl_api_bond_create_t *mp;
5177 clib_memset (mac_address, 0, sizeof (mac_address));
5180 /* Parse args required to build the message */
5181 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5183 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
5185 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
5186 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
5188 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
5191 else if (unformat (i, "numa-only"))
5193 else if (unformat (i, "id %u", &id))
5199 if (mode_is_set == 0)
5201 errmsg ("Missing bond mode. ");
5205 /* Construct the API message */
5206 M (BOND_CREATE, mp);
5208 mp->use_custom_mac = custom_mac;
5210 mp->mode = htonl (mode);
5211 mp->lb = htonl (lb);
5212 mp->id = htonl (id);
5213 mp->numa_only = numa_only;
5216 clib_memcpy (mp->mac_address, mac_address, 6);
5221 /* Wait for a reply... */
5227 api_bond_create2 (vat_main_t * vam)
5229 unformat_input_t *i = vam->input;
5230 vl_api_bond_create2_t *mp;
5241 clib_memset (mac_address, 0, sizeof (mac_address));
5244 /* Parse args required to build the message */
5245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5247 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
5249 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
5250 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
5252 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
5255 else if (unformat (i, "numa-only"))
5257 else if (unformat (i, "gso"))
5259 else if (unformat (i, "id %u", &id))
5265 if (mode_is_set == 0)
5267 errmsg ("Missing bond mode. ");
5271 /* Construct the API message */
5272 M (BOND_CREATE2, mp);
5274 mp->use_custom_mac = custom_mac;
5276 mp->mode = htonl (mode);
5277 mp->lb = htonl (lb);
5278 mp->id = htonl (id);
5279 mp->numa_only = numa_only;
5280 mp->enable_gso = gso;
5283 clib_memcpy (mp->mac_address, mac_address, 6);
5288 /* Wait for a reply... */
5294 api_bond_delete (vat_main_t * vam)
5296 unformat_input_t *i = vam->input;
5297 vl_api_bond_delete_t *mp;
5298 u32 sw_if_index = ~0;
5299 u8 sw_if_index_set = 0;
5302 /* Parse args required to build the message */
5303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5306 sw_if_index_set = 1;
5307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5308 sw_if_index_set = 1;
5313 if (sw_if_index_set == 0)
5315 errmsg ("missing vpp interface name. ");
5319 /* Construct the API message */
5320 M (BOND_DELETE, mp);
5322 mp->sw_if_index = ntohl (sw_if_index);
5327 /* Wait for a reply... */
5333 api_bond_add_member (vat_main_t * vam)
5335 unformat_input_t *i = vam->input;
5336 vl_api_bond_add_member_t *mp;
5337 u32 bond_sw_if_index;
5341 u32 bond_sw_if_index_is_set = 0;
5343 u8 sw_if_index_is_set = 0;
5345 /* Parse args required to build the message */
5346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5348 if (unformat (i, "sw_if_index %d", &sw_if_index))
5349 sw_if_index_is_set = 1;
5350 else if (unformat (i, "bond %u", &bond_sw_if_index))
5351 bond_sw_if_index_is_set = 1;
5352 else if (unformat (i, "passive %d", &is_passive))
5354 else if (unformat (i, "long-timeout %d", &is_long_timeout))
5360 if (bond_sw_if_index_is_set == 0)
5362 errmsg ("Missing bond sw_if_index. ");
5365 if (sw_if_index_is_set == 0)
5367 errmsg ("Missing member sw_if_index. ");
5371 /* Construct the API message */
5372 M (BOND_ADD_MEMBER, mp);
5374 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
5375 mp->sw_if_index = ntohl (sw_if_index);
5376 mp->is_long_timeout = is_long_timeout;
5377 mp->is_passive = is_passive;
5382 /* Wait for a reply... */
5388 api_bond_detach_member (vat_main_t * vam)
5390 unformat_input_t *i = vam->input;
5391 vl_api_bond_detach_member_t *mp;
5392 u32 sw_if_index = ~0;
5393 u8 sw_if_index_set = 0;
5396 /* Parse args required to build the message */
5397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5399 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5400 sw_if_index_set = 1;
5401 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5402 sw_if_index_set = 1;
5407 if (sw_if_index_set == 0)
5409 errmsg ("missing vpp interface name. ");
5413 /* Construct the API message */
5414 M (BOND_DETACH_MEMBER, mp);
5416 mp->sw_if_index = ntohl (sw_if_index);
5421 /* Wait for a reply... */
5427 api_ip_table_add_del (vat_main_t * vam)
5429 unformat_input_t *i = vam->input;
5430 vl_api_ip_table_add_del_t *mp;
5436 /* Parse args required to build the message */
5437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5439 if (unformat (i, "ipv6"))
5441 else if (unformat (i, "del"))
5443 else if (unformat (i, "add"))
5445 else if (unformat (i, "table %d", &table_id))
5449 clib_warning ("parse error '%U'", format_unformat_error, i);
5456 errmsg ("missing table-ID");
5460 /* Construct the API message */
5461 M (IP_TABLE_ADD_DEL, mp);
5463 mp->table.table_id = ntohl (table_id);
5464 mp->table.is_ip6 = is_ipv6;
5465 mp->is_add = is_add;
5470 /* Wait for a reply... */
5477 unformat_fib_path (unformat_input_t * input, va_list * args)
5479 vat_main_t *vam = va_arg (*args, vat_main_t *);
5480 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
5481 u32 weight, preference;
5482 mpls_label_t out_label;
5484 clib_memset (path, 0, sizeof (*path));
5486 path->sw_if_index = ~0;
5490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5492 if (unformat (input, "%U %U",
5493 unformat_vl_api_ip4_address,
5494 &path->nh.address.ip4,
5495 api_unformat_sw_if_index, vam, &path->sw_if_index))
5497 path->proto = FIB_API_PATH_NH_PROTO_IP4;
5499 else if (unformat (input, "%U %U",
5500 unformat_vl_api_ip6_address,
5501 &path->nh.address.ip6,
5502 api_unformat_sw_if_index, vam, &path->sw_if_index))
5504 path->proto = FIB_API_PATH_NH_PROTO_IP6;
5506 else if (unformat (input, "weight %u", &weight))
5508 path->weight = weight;
5510 else if (unformat (input, "preference %u", &preference))
5512 path->preference = preference;
5514 else if (unformat (input, "%U next-hop-table %d",
5515 unformat_vl_api_ip4_address,
5516 &path->nh.address.ip4, &path->table_id))
5518 path->proto = FIB_API_PATH_NH_PROTO_IP4;
5520 else if (unformat (input, "%U next-hop-table %d",
5521 unformat_vl_api_ip6_address,
5522 &path->nh.address.ip6, &path->table_id))
5524 path->proto = FIB_API_PATH_NH_PROTO_IP6;
5526 else if (unformat (input, "%U",
5527 unformat_vl_api_ip4_address, &path->nh.address.ip4))
5530 * the recursive next-hops are by default in the default table
5533 path->sw_if_index = ~0;
5534 path->proto = FIB_API_PATH_NH_PROTO_IP4;
5536 else if (unformat (input, "%U",
5537 unformat_vl_api_ip6_address, &path->nh.address.ip6))
5540 * the recursive next-hops are by default in the default table
5543 path->sw_if_index = ~0;
5544 path->proto = FIB_API_PATH_NH_PROTO_IP6;
5546 else if (unformat (input, "resolve-via-host"))
5548 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
5550 else if (unformat (input, "resolve-via-attached"))
5552 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
5554 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
5556 path->type = FIB_API_PATH_TYPE_LOCAL;
5557 path->sw_if_index = ~0;
5558 path->proto = FIB_API_PATH_NH_PROTO_IP4;
5560 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
5562 path->type = FIB_API_PATH_TYPE_LOCAL;
5563 path->sw_if_index = ~0;
5564 path->proto = FIB_API_PATH_NH_PROTO_IP6;
5566 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
5568 else if (unformat (input, "via-label %d", &path->nh.via_label))
5570 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
5571 path->sw_if_index = ~0;
5573 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
5575 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
5576 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
5578 else if (unformat (input, "local"))
5580 path->type = FIB_API_PATH_TYPE_LOCAL;
5582 else if (unformat (input, "out-labels"))
5584 while (unformat (input, "%d", &out_label))
5586 path->label_stack[path->n_labels].label = out_label;
5587 path->label_stack[path->n_labels].is_uniform = 0;
5588 path->label_stack[path->n_labels].ttl = 64;
5592 else if (unformat (input, "via"))
5594 /* new path, back up and return */
5595 unformat_put_input (input);
5596 unformat_put_input (input);
5597 unformat_put_input (input);
5598 unformat_put_input (input);
5607 path->proto = ntohl (path->proto);
5608 path->type = ntohl (path->type);
5609 path->flags = ntohl (path->flags);
5610 path->table_id = ntohl (path->table_id);
5611 path->sw_if_index = ntohl (path->sw_if_index);
5617 api_ip_route_add_del (vat_main_t * vam)
5619 unformat_input_t *i = vam->input;
5620 vl_api_ip_route_add_del_t *mp;
5623 u8 is_multipath = 0;
5626 vl_api_prefix_t pfx = { };
5627 vl_api_fib_path_t paths[8];
5631 u32 random_add_del = 0;
5632 u32 *random_vector = 0;
5633 u32 random_seed = 0xdeaddabe;
5635 /* Parse args required to build the message */
5636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5638 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
5640 else if (unformat (i, "del"))
5642 else if (unformat (i, "add"))
5644 else if (unformat (i, "vrf %d", &vrf_id))
5646 else if (unformat (i, "count %d", &count))
5648 else if (unformat (i, "random"))
5650 else if (unformat (i, "multipath"))
5652 else if (unformat (i, "seed %d", &random_seed))
5656 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
5659 if (8 == path_count)
5661 errmsg ("max 8 paths");
5667 clib_warning ("parse error '%U'", format_unformat_error, i);
5674 errmsg ("specify a path; via ...");
5677 if (prefix_set == 0)
5679 errmsg ("missing prefix");
5683 /* Generate a pile of unique, random routes */
5686 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
5687 u32 this_random_address;
5690 random_hash = hash_create (count, sizeof (uword));
5692 hash_set (random_hash, i->as_u32, 1);
5693 for (j = 0; j <= count; j++)
5697 this_random_address = random_u32 (&random_seed);
5698 this_random_address =
5699 clib_host_to_net_u32 (this_random_address);
5701 while (hash_get (random_hash, this_random_address));
5702 vec_add1 (random_vector, this_random_address);
5703 hash_set (random_hash, this_random_address, 1);
5705 hash_free (random_hash);
5706 set_ip4_address (&pfx.address, random_vector[0]);
5711 /* Turn on async mode */
5712 vam->async_mode = 1;
5713 vam->async_errors = 0;
5714 before = vat_time_now (vam);
5717 for (j = 0; j < count; j++)
5719 /* Construct the API message */
5720 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
5722 mp->is_add = is_add;
5723 mp->is_multipath = is_multipath;
5725 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
5726 mp->route.table_id = ntohl (vrf_id);
5727 mp->route.n_paths = path_count;
5729 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
5732 set_ip4_address (&pfx.address, random_vector[j + 1]);
5734 increment_address (&pfx.address);
5737 /* If we receive SIGTERM, stop now... */
5742 /* When testing multiple add/del ops, use a control-ping to sync */
5745 vl_api_control_ping_t *mp_ping;
5749 /* Shut off async mode */
5750 vam->async_mode = 0;
5752 MPING (CONTROL_PING, mp_ping);
5755 timeout = vat_time_now (vam) + 1.0;
5756 while (vat_time_now (vam) < timeout)
5757 if (vam->result_ready == 1)
5762 if (vam->retval == -99)
5765 if (vam->async_errors > 0)
5767 errmsg ("%d asynchronous errors", vam->async_errors);
5770 vam->async_errors = 0;
5771 after = vat_time_now (vam);
5773 /* slim chance, but we might have eaten SIGTERM on the first iteration */
5777 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5778 count, after - before, count / (after - before));
5784 /* Wait for a reply... */
5789 /* Return the good/bad news */
5790 return (vam->retval);
5794 api_ip_mroute_add_del (vat_main_t * vam)
5796 unformat_input_t *i = vam->input;
5797 u8 path_set = 0, prefix_set = 0, is_add = 1;
5798 vl_api_ip_mroute_add_del_t *mp;
5799 mfib_entry_flags_t eflags = 0;
5800 vl_api_mfib_path_t path;
5801 vl_api_mprefix_t pfx = { };
5805 /* Parse args required to build the message */
5806 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5808 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
5811 pfx.grp_address_length = htons (pfx.grp_address_length);
5813 else if (unformat (i, "del"))
5815 else if (unformat (i, "add"))
5817 else if (unformat (i, "vrf %d", &vrf_id))
5819 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
5820 path.itf_flags = htonl (path.itf_flags);
5821 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
5823 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
5827 clib_warning ("parse error '%U'", format_unformat_error, i);
5832 if (prefix_set == 0)
5834 errmsg ("missing addresses\n");
5839 errmsg ("missing path\n");
5843 /* Construct the API message */
5844 M (IP_MROUTE_ADD_DEL, mp);
5846 mp->is_add = is_add;
5847 mp->is_multipath = 1;
5849 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
5850 mp->route.table_id = htonl (vrf_id);
5851 mp->route.n_paths = 1;
5852 mp->route.entry_flags = htonl (eflags);
5854 clib_memcpy (&mp->route.paths, &path, sizeof (path));
5858 /* Wait for a reply... */
5864 api_mpls_table_add_del (vat_main_t * vam)
5866 unformat_input_t *i = vam->input;
5867 vl_api_mpls_table_add_del_t *mp;
5872 /* Parse args required to build the message */
5873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5875 if (unformat (i, "table %d", &table_id))
5877 else if (unformat (i, "del"))
5879 else if (unformat (i, "add"))
5883 clib_warning ("parse error '%U'", format_unformat_error, i);
5890 errmsg ("missing table-ID");
5894 /* Construct the API message */
5895 M (MPLS_TABLE_ADD_DEL, mp);
5897 mp->mt_table.mt_table_id = ntohl (table_id);
5898 mp->mt_is_add = is_add;
5903 /* Wait for a reply... */
5910 api_mpls_route_add_del (vat_main_t * vam)
5912 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
5913 mpls_label_t local_label = MPLS_LABEL_INVALID;
5914 unformat_input_t *i = vam->input;
5915 vl_api_mpls_route_add_del_t *mp;
5916 vl_api_fib_path_t paths[8];
5920 /* Parse args required to build the message */
5921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5923 if (unformat (i, "%d", &local_label))
5925 else if (unformat (i, "eos"))
5927 else if (unformat (i, "non-eos"))
5929 else if (unformat (i, "del"))
5931 else if (unformat (i, "add"))
5933 else if (unformat (i, "multipath"))
5935 else if (unformat (i, "count %d", &count))
5939 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
5942 if (8 == path_count)
5944 errmsg ("max 8 paths");
5950 clib_warning ("parse error '%U'", format_unformat_error, i);
5957 errmsg ("specify a path; via ...");
5961 if (MPLS_LABEL_INVALID == local_label)
5963 errmsg ("missing label");
5969 /* Turn on async mode */
5970 vam->async_mode = 1;
5971 vam->async_errors = 0;
5972 before = vat_time_now (vam);
5975 for (j = 0; j < count; j++)
5977 /* Construct the API message */
5978 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
5980 mp->mr_is_add = is_add;
5981 mp->mr_is_multipath = is_multipath;
5983 mp->mr_route.mr_label = local_label;
5984 mp->mr_route.mr_eos = is_eos;
5985 mp->mr_route.mr_table_id = 0;
5986 mp->mr_route.mr_n_paths = path_count;
5988 clib_memcpy (&mp->mr_route.mr_paths, paths,
5989 sizeof (paths[0]) * path_count);
5995 /* If we receive SIGTERM, stop now... */
6000 /* When testing multiple add/del ops, use a control-ping to sync */
6003 vl_api_control_ping_t *mp_ping;
6007 /* Shut off async mode */
6008 vam->async_mode = 0;
6010 MPING (CONTROL_PING, mp_ping);
6013 timeout = vat_time_now (vam) + 1.0;
6014 while (vat_time_now (vam) < timeout)
6015 if (vam->result_ready == 1)
6020 if (vam->retval == -99)
6023 if (vam->async_errors > 0)
6025 errmsg ("%d asynchronous errors", vam->async_errors);
6028 vam->async_errors = 0;
6029 after = vat_time_now (vam);
6031 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6035 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6036 count, after - before, count / (after - before));
6042 /* Wait for a reply... */
6047 /* Return the good/bad news */
6048 return (vam->retval);
6053 api_mpls_ip_bind_unbind (vat_main_t * vam)
6055 unformat_input_t *i = vam->input;
6056 vl_api_mpls_ip_bind_unbind_t *mp;
6057 u32 ip_table_id = 0;
6059 vl_api_prefix_t pfx;
6061 mpls_label_t local_label = MPLS_LABEL_INVALID;
6064 /* Parse args required to build the message */
6065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6067 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
6069 else if (unformat (i, "%d", &local_label))
6071 else if (unformat (i, "table-id %d", &ip_table_id))
6073 else if (unformat (i, "unbind"))
6075 else if (unformat (i, "bind"))
6079 clib_warning ("parse error '%U'", format_unformat_error, i);
6086 errmsg ("IP prefix not set");
6090 if (MPLS_LABEL_INVALID == local_label)
6092 errmsg ("missing label");
6096 /* Construct the API message */
6097 M (MPLS_IP_BIND_UNBIND, mp);
6099 mp->mb_is_bind = is_bind;
6100 mp->mb_ip_table_id = ntohl (ip_table_id);
6101 mp->mb_mpls_table_id = 0;
6102 mp->mb_label = ntohl (local_label);
6103 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
6108 /* Wait for a reply... */
6115 api_sr_mpls_policy_add (vat_main_t * vam)
6117 unformat_input_t *i = vam->input;
6118 vl_api_sr_mpls_policy_add_t *mp;
6124 u32 *segments = NULL;
6127 /* Parse args required to build the message */
6128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6130 if (unformat (i, "bsid %d", &bsid))
6132 else if (unformat (i, "weight %d", &weight))
6134 else if (unformat (i, "spray"))
6136 else if (unformat (i, "next %d", &sid))
6139 vec_add1 (segments, htonl (sid));
6143 clib_warning ("parse error '%U'", format_unformat_error, i);
6150 errmsg ("bsid not set");
6154 if (n_segments == 0)
6156 errmsg ("no sid in segment stack");
6160 /* Construct the API message */
6161 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
6163 mp->bsid = htonl (bsid);
6164 mp->weight = htonl (weight);
6165 mp->is_spray = type;
6166 mp->n_segments = n_segments;
6167 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
6168 vec_free (segments);
6173 /* Wait for a reply... */
6179 api_sr_mpls_policy_del (vat_main_t * vam)
6181 unformat_input_t *i = vam->input;
6182 vl_api_sr_mpls_policy_del_t *mp;
6186 /* Parse args required to build the message */
6187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6189 if (unformat (i, "bsid %d", &bsid))
6193 clib_warning ("parse error '%U'", format_unformat_error, i);
6200 errmsg ("bsid not set");
6204 /* Construct the API message */
6205 M (SR_MPLS_POLICY_DEL, mp);
6207 mp->bsid = htonl (bsid);
6212 /* Wait for a reply... */
6218 api_mpls_tunnel_add_del (vat_main_t * vam)
6220 unformat_input_t *i = vam->input;
6221 vl_api_mpls_tunnel_add_del_t *mp;
6223 vl_api_fib_path_t paths[8];
6224 u32 sw_if_index = ~0;
6230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6232 if (unformat (i, "add"))
6236 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
6238 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
6240 else if (unformat (i, "l2-only"))
6244 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
6247 if (8 == path_count)
6249 errmsg ("max 8 paths");
6255 clib_warning ("parse error '%U'", format_unformat_error, i);
6260 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
6262 mp->mt_is_add = is_add;
6263 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
6264 mp->mt_tunnel.mt_l2_only = l2_only;
6265 mp->mt_tunnel.mt_is_multicast = 0;
6266 mp->mt_tunnel.mt_n_paths = path_count;
6268 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
6269 sizeof (paths[0]) * path_count);
6277 api_sw_interface_set_unnumbered (vat_main_t * vam)
6279 unformat_input_t *i = vam->input;
6280 vl_api_sw_interface_set_unnumbered_t *mp;
6282 u32 unnum_sw_index = ~0;
6284 u8 sw_if_index_set = 0;
6287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6289 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6290 sw_if_index_set = 1;
6291 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6292 sw_if_index_set = 1;
6293 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6295 else if (unformat (i, "del"))
6299 clib_warning ("parse error '%U'", format_unformat_error, i);
6304 if (sw_if_index_set == 0)
6306 errmsg ("missing interface name or sw_if_index");
6310 M (SW_INTERFACE_SET_UNNUMBERED, mp);
6312 mp->sw_if_index = ntohl (sw_if_index);
6313 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6314 mp->is_add = is_add;
6323 api_create_vlan_subif (vat_main_t * vam)
6325 unformat_input_t *i = vam->input;
6326 vl_api_create_vlan_subif_t *mp;
6328 u8 sw_if_index_set = 0;
6333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6335 if (unformat (i, "sw_if_index %d", &sw_if_index))
6336 sw_if_index_set = 1;
6338 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6339 sw_if_index_set = 1;
6340 else if (unformat (i, "vlan %d", &vlan_id))
6344 clib_warning ("parse error '%U'", format_unformat_error, i);
6349 if (sw_if_index_set == 0)
6351 errmsg ("missing interface name or sw_if_index");
6355 if (vlan_id_set == 0)
6357 errmsg ("missing vlan_id");
6360 M (CREATE_VLAN_SUBIF, mp);
6362 mp->sw_if_index = ntohl (sw_if_index);
6363 mp->vlan_id = ntohl (vlan_id);
6370 #define foreach_create_subif_bit \
6377 _(outer_vlan_id_any) \
6378 _(inner_vlan_id_any)
6380 #define foreach_create_subif_flag \
6385 _(4, "exact_match") \
6386 _(5, "default_sub") \
6387 _(6, "outer_vlan_id_any") \
6388 _(7, "inner_vlan_id_any")
6391 api_create_subif (vat_main_t * vam)
6393 unformat_input_t *i = vam->input;
6394 vl_api_create_subif_t *mp;
6396 u8 sw_if_index_set = 0;
6399 u32 __attribute__ ((unused)) no_tags = 0;
6400 u32 __attribute__ ((unused)) one_tag = 0;
6401 u32 __attribute__ ((unused)) two_tags = 0;
6402 u32 __attribute__ ((unused)) dot1ad = 0;
6403 u32 __attribute__ ((unused)) exact_match = 0;
6404 u32 __attribute__ ((unused)) default_sub = 0;
6405 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
6406 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
6408 u16 outer_vlan_id = 0;
6409 u16 inner_vlan_id = 0;
6412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6414 if (unformat (i, "sw_if_index %d", &sw_if_index))
6415 sw_if_index_set = 1;
6417 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6418 sw_if_index_set = 1;
6419 else if (unformat (i, "sub_id %d", &sub_id))
6421 else if (unformat (i, "outer_vlan_id %d", &tmp))
6422 outer_vlan_id = tmp;
6423 else if (unformat (i, "inner_vlan_id %d", &tmp))
6424 inner_vlan_id = tmp;
6426 #define _(a) else if (unformat (i, #a)) a = 1 ;
6427 foreach_create_subif_bit
6431 clib_warning ("parse error '%U'", format_unformat_error, i);
6436 if (sw_if_index_set == 0)
6438 errmsg ("missing interface name or sw_if_index");
6442 if (sub_id_set == 0)
6444 errmsg ("missing sub_id");
6447 M (CREATE_SUBIF, mp);
6449 mp->sw_if_index = ntohl (sw_if_index);
6450 mp->sub_id = ntohl (sub_id);
6452 #define _(a,b) mp->sub_if_flags |= (1 << a);
6453 foreach_create_subif_flag;
6456 mp->outer_vlan_id = ntohs (outer_vlan_id);
6457 mp->inner_vlan_id = ntohs (inner_vlan_id);
6465 api_ip_table_replace_begin (vat_main_t * vam)
6467 unformat_input_t *i = vam->input;
6468 vl_api_ip_table_replace_begin_t *mp;
6473 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6475 if (unformat (i, "table %d", &table_id))
6477 else if (unformat (i, "ipv6"))
6481 clib_warning ("parse error '%U'", format_unformat_error, i);
6486 M (IP_TABLE_REPLACE_BEGIN, mp);
6488 mp->table.table_id = ntohl (table_id);
6489 mp->table.is_ip6 = is_ipv6;
6497 api_ip_table_flush (vat_main_t * vam)
6499 unformat_input_t *i = vam->input;
6500 vl_api_ip_table_flush_t *mp;
6505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6507 if (unformat (i, "table %d", &table_id))
6509 else if (unformat (i, "ipv6"))
6513 clib_warning ("parse error '%U'", format_unformat_error, i);
6518 M (IP_TABLE_FLUSH, mp);
6520 mp->table.table_id = ntohl (table_id);
6521 mp->table.is_ip6 = is_ipv6;
6529 api_ip_table_replace_end (vat_main_t * vam)
6531 unformat_input_t *i = vam->input;
6532 vl_api_ip_table_replace_end_t *mp;
6537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6539 if (unformat (i, "table %d", &table_id))
6541 else if (unformat (i, "ipv6"))
6545 clib_warning ("parse error '%U'", format_unformat_error, i);
6550 M (IP_TABLE_REPLACE_END, mp);
6552 mp->table.table_id = ntohl (table_id);
6553 mp->table.is_ip6 = is_ipv6;
6561 api_set_ip_flow_hash (vat_main_t * vam)
6563 unformat_input_t *i = vam->input;
6564 vl_api_set_ip_flow_hash_t *mp;
6576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6578 if (unformat (i, "vrf %d", &vrf_id))
6580 else if (unformat (i, "ipv6"))
6582 else if (unformat (i, "src"))
6584 else if (unformat (i, "dst"))
6586 else if (unformat (i, "sport"))
6588 else if (unformat (i, "dport"))
6590 else if (unformat (i, "proto"))
6592 else if (unformat (i, "reverse"))
6597 clib_warning ("parse error '%U'", format_unformat_error, i);
6602 if (vrf_id_set == 0)
6604 errmsg ("missing vrf id");
6608 M (SET_IP_FLOW_HASH, mp);
6614 mp->reverse = reverse;
6615 mp->vrf_id = ntohl (vrf_id);
6616 mp->is_ipv6 = is_ipv6;
6624 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6626 unformat_input_t *i = vam->input;
6627 vl_api_sw_interface_ip6_enable_disable_t *mp;
6629 u8 sw_if_index_set = 0;
6633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6635 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6636 sw_if_index_set = 1;
6637 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6638 sw_if_index_set = 1;
6639 else if (unformat (i, "enable"))
6641 else if (unformat (i, "disable"))
6645 clib_warning ("parse error '%U'", format_unformat_error, i);
6650 if (sw_if_index_set == 0)
6652 errmsg ("missing interface name or sw_if_index");
6656 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
6658 mp->sw_if_index = ntohl (sw_if_index);
6659 mp->enable = enable;
6668 api_l2_patch_add_del (vat_main_t * vam)
6670 unformat_input_t *i = vam->input;
6671 vl_api_l2_patch_add_del_t *mp;
6673 u8 rx_sw_if_index_set = 0;
6675 u8 tx_sw_if_index_set = 0;
6679 /* Parse args required to build the message */
6680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6682 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6683 rx_sw_if_index_set = 1;
6684 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6685 tx_sw_if_index_set = 1;
6686 else if (unformat (i, "rx"))
6688 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6690 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6692 rx_sw_if_index_set = 1;
6697 else if (unformat (i, "tx"))
6699 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6701 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6703 tx_sw_if_index_set = 1;
6708 else if (unformat (i, "del"))
6714 if (rx_sw_if_index_set == 0)
6716 errmsg ("missing rx interface name or rx_sw_if_index");
6720 if (tx_sw_if_index_set == 0)
6722 errmsg ("missing tx interface name or tx_sw_if_index");
6726 M (L2_PATCH_ADD_DEL, mp);
6728 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6729 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6730 mp->is_add = is_add;
6738 u8 localsid_addr[16];
6747 api_sr_localsid_add_del (vat_main_t * vam)
6749 unformat_input_t *i = vam->input;
6750 vl_api_sr_localsid_add_del_t *mp;
6753 ip6_address_t localsid;
6757 u32 fib_table = ~(u32) 0;
6758 ip46_address_t nh_addr;
6759 clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
6761 bool nexthop_set = 0;
6765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6767 if (unformat (i, "del"))
6769 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
6770 else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
6772 else if (unformat (i, "behavior %u", &behavior));
6773 else if (unformat (i, "sw_if_index %u", &sw_if_index));
6774 else if (unformat (i, "fib-table %u", &fib_table));
6775 else if (unformat (i, "end.psp %u", &behavior));
6780 M (SR_LOCALSID_ADD_DEL, mp);
6782 clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
6786 clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
6788 mp->behavior = behavior;
6789 mp->sw_if_index = ntohl (sw_if_index);
6790 mp->fib_table = ntohl (fib_table);
6791 mp->end_psp = end_psp;
6792 mp->is_del = is_del;
6800 api_ioam_enable (vat_main_t * vam)
6802 unformat_input_t *input = vam->input;
6803 vl_api_ioam_enable_t *mp;
6805 int has_trace_option = 0;
6806 int has_pot_option = 0;
6807 int has_seqno_option = 0;
6808 int has_analyse_option = 0;
6811 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6813 if (unformat (input, "trace"))
6814 has_trace_option = 1;
6815 else if (unformat (input, "pot"))
6817 else if (unformat (input, "seqno"))
6818 has_seqno_option = 1;
6819 else if (unformat (input, "analyse"))
6820 has_analyse_option = 1;
6824 M (IOAM_ENABLE, mp);
6825 mp->id = htons (id);
6826 mp->seqno = has_seqno_option;
6827 mp->analyse = has_analyse_option;
6828 mp->pot_enable = has_pot_option;
6829 mp->trace_enable = has_trace_option;
6838 api_ioam_disable (vat_main_t * vam)
6840 vl_api_ioam_disable_t *mp;
6843 M (IOAM_DISABLE, mp);
6849 #define foreach_tcp_proto_field \
6853 #define foreach_udp_proto_field \
6857 #define foreach_ip4_proto_field \
6869 u16 src_port, dst_port;
6872 #if VPP_API_TEST_BUILTIN == 0
6874 unformat_tcp_mask (unformat_input_t * input, va_list * args)
6876 u8 **maskp = va_arg (*args, u8 **);
6878 u8 found_something = 0;
6881 #define _(a) u8 a=0;
6882 foreach_tcp_proto_field;
6885 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6888 #define _(a) else if (unformat (input, #a)) a=1;
6889 foreach_tcp_proto_field
6895 #define _(a) found_something += a;
6896 foreach_tcp_proto_field;
6899 if (found_something == 0)
6902 vec_validate (mask, sizeof (*tcp) - 1);
6904 tcp = (tcp_header_t *) mask;
6906 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
6907 foreach_tcp_proto_field;
6915 unformat_udp_mask (unformat_input_t * input, va_list * args)
6917 u8 **maskp = va_arg (*args, u8 **);
6919 u8 found_something = 0;
6922 #define _(a) u8 a=0;
6923 foreach_udp_proto_field;
6926 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6929 #define _(a) else if (unformat (input, #a)) a=1;
6930 foreach_udp_proto_field
6936 #define _(a) found_something += a;
6937 foreach_udp_proto_field;
6940 if (found_something == 0)
6943 vec_validate (mask, sizeof (*udp) - 1);
6945 udp = (udp_header_t *) mask;
6947 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
6948 foreach_udp_proto_field;
6956 unformat_l4_mask (unformat_input_t * input, va_list * args)
6958 u8 **maskp = va_arg (*args, u8 **);
6959 u16 src_port = 0, dst_port = 0;
6960 tcpudp_header_t *tcpudp;
6962 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6964 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
6966 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
6968 else if (unformat (input, "src_port"))
6970 else if (unformat (input, "dst_port"))
6976 if (!src_port && !dst_port)
6980 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
6982 tcpudp = (tcpudp_header_t *) mask;
6983 tcpudp->src_port = src_port;
6984 tcpudp->dst_port = dst_port;
6992 unformat_ip4_mask (unformat_input_t * input, va_list * args)
6994 u8 **maskp = va_arg (*args, u8 **);
6996 u8 found_something = 0;
6999 #define _(a) u8 a=0;
7000 foreach_ip4_proto_field;
7006 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7008 if (unformat (input, "version"))
7010 else if (unformat (input, "hdr_length"))
7012 else if (unformat (input, "src"))
7014 else if (unformat (input, "dst"))
7016 else if (unformat (input, "proto"))
7019 #define _(a) else if (unformat (input, #a)) a=1;
7020 foreach_ip4_proto_field
7026 #define _(a) found_something += a;
7027 foreach_ip4_proto_field;
7030 if (found_something == 0)
7033 vec_validate (mask, sizeof (*ip) - 1);
7035 ip = (ip4_header_t *) mask;
7037 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
7038 foreach_ip4_proto_field;
7041 ip->ip_version_and_header_length = 0;
7044 ip->ip_version_and_header_length |= 0xF0;
7047 ip->ip_version_and_header_length |= 0x0F;
7053 #define foreach_ip6_proto_field \
7061 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7063 u8 **maskp = va_arg (*args, u8 **);
7065 u8 found_something = 0;
7067 u32 ip_version_traffic_class_and_flow_label;
7069 #define _(a) u8 a=0;
7070 foreach_ip6_proto_field;
7073 u8 traffic_class = 0;
7076 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7078 if (unformat (input, "version"))
7080 else if (unformat (input, "traffic-class"))
7082 else if (unformat (input, "flow-label"))
7084 else if (unformat (input, "src"))
7086 else if (unformat (input, "dst"))
7088 else if (unformat (input, "proto"))
7091 #define _(a) else if (unformat (input, #a)) a=1;
7092 foreach_ip6_proto_field
7098 #define _(a) found_something += a;
7099 foreach_ip6_proto_field;
7102 if (found_something == 0)
7105 vec_validate (mask, sizeof (*ip) - 1);
7107 ip = (ip6_header_t *) mask;
7109 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
7110 foreach_ip6_proto_field;
7113 ip_version_traffic_class_and_flow_label = 0;
7116 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7119 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7122 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7124 ip->ip_version_traffic_class_and_flow_label =
7125 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7132 unformat_l3_mask (unformat_input_t * input, va_list * args)
7134 u8 **maskp = va_arg (*args, u8 **);
7136 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7138 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7140 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7149 unformat_l2_mask (unformat_input_t * input, va_list * args)
7151 u8 **maskp = va_arg (*args, u8 **);
7166 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7168 if (unformat (input, "src"))
7170 else if (unformat (input, "dst"))
7172 else if (unformat (input, "proto"))
7174 else if (unformat (input, "tag1"))
7176 else if (unformat (input, "tag2"))
7178 else if (unformat (input, "ignore-tag1"))
7180 else if (unformat (input, "ignore-tag2"))
7182 else if (unformat (input, "cos1"))
7184 else if (unformat (input, "cos2"))
7186 else if (unformat (input, "dot1q"))
7188 else if (unformat (input, "dot1ad"))
7193 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7194 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7197 if (tag1 || ignore_tag1 || cos1 || dot1q)
7199 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7202 vec_validate (mask, len - 1);
7205 clib_memset (mask, 0xff, 6);
7208 clib_memset (mask + 6, 0xff, 6);
7212 /* inner vlan tag */
7221 mask[21] = mask[20] = 0xff;
7242 mask[16] = mask[17] = 0xff;
7252 mask[12] = mask[13] = 0xff;
7259 unformat_classify_mask (unformat_input_t * input, va_list * args)
7261 u8 **maskp = va_arg (*args, u8 **);
7262 u32 *skipp = va_arg (*args, u32 *);
7263 u32 *matchp = va_arg (*args, u32 *);
7271 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7273 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7275 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7277 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7279 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
7293 if (mask || l2 || l3 || l4)
7297 /* "With a free Ethernet header in every package" */
7299 vec_validate (l2, 13);
7303 vec_append (mask, l3);
7308 vec_append (mask, l4);
7313 /* Scan forward looking for the first significant mask octet */
7314 for (i = 0; i < vec_len (mask); i++)
7318 /* compute (skip, match) params */
7319 *skipp = i / sizeof (u32x4);
7320 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7322 /* Pad mask to an even multiple of the vector size */
7323 while (vec_len (mask) % sizeof (u32x4))
7326 match = vec_len (mask) / sizeof (u32x4);
7328 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7330 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7331 if (*tmp || *(tmp + 1))
7336 clib_warning ("BUG: match 0");
7338 _vec_len (mask) = match * sizeof (u32x4);
7348 #endif /* VPP_API_TEST_BUILTIN */
7350 #define foreach_l2_next \
7352 _(ethernet, ETHERNET_INPUT) \
7357 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7359 u32 *miss_next_indexp = va_arg (*args, u32 *);
7364 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
7368 if (unformat (input, "%d", &tmp))
7377 *miss_next_indexp = next_index;
7381 #define foreach_ip_next \
7387 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
7389 u32 *miss_next_indexp = va_arg (*args, u32 *);
7394 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7398 if (unformat (input, "%d", &tmp))
7407 *miss_next_indexp = next_index;
7411 #define foreach_acl_next \
7415 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
7417 u32 *miss_next_indexp = va_arg (*args, u32 *);
7422 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7426 if (unformat (input, "permit"))
7431 else if (unformat (input, "%d", &tmp))
7440 *miss_next_indexp = next_index;
7445 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7447 u32 *r = va_arg (*args, u32 *);
7449 if (unformat (input, "conform-color"))
7450 *r = POLICE_CONFORM;
7451 else if (unformat (input, "exceed-color"))
7459 #if VPP_API_TEST_BUILTIN == 0
7461 unformat_l4_match (unformat_input_t * input, va_list * args)
7463 u8 **matchp = va_arg (*args, u8 **);
7465 u8 *proto_header = 0;
7471 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7473 if (unformat (input, "src_port %d", &src_port))
7475 else if (unformat (input, "dst_port %d", &dst_port))
7481 h.src_port = clib_host_to_net_u16 (src_port);
7482 h.dst_port = clib_host_to_net_u16 (dst_port);
7483 vec_validate (proto_header, sizeof (h) - 1);
7484 memcpy (proto_header, &h, sizeof (h));
7486 *matchp = proto_header;
7492 unformat_ip4_match (unformat_input_t * input, va_list * args)
7494 u8 **matchp = va_arg (*args, u8 **);
7501 int src = 0, dst = 0;
7502 ip4_address_t src_val, dst_val;
7509 int fragment_id = 0;
7510 u32 fragment_id_val;
7516 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7518 if (unformat (input, "version %d", &version_val))
7520 else if (unformat (input, "hdr_length %d", &hdr_length_val))
7522 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
7524 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
7526 else if (unformat (input, "proto %d", &proto_val))
7528 else if (unformat (input, "tos %d", &tos_val))
7530 else if (unformat (input, "length %d", &length_val))
7532 else if (unformat (input, "fragment_id %d", &fragment_id_val))
7534 else if (unformat (input, "ttl %d", &ttl_val))
7536 else if (unformat (input, "checksum %d", &checksum_val))
7542 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
7543 + ttl + checksum == 0)
7547 * Aligned because we use the real comparison functions
7549 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
7551 ip = (ip4_header_t *) match;
7553 /* These are realistically matched in practice */
7555 ip->src_address.as_u32 = src_val.as_u32;
7558 ip->dst_address.as_u32 = dst_val.as_u32;
7561 ip->protocol = proto_val;
7564 /* These are not, but they're included for completeness */
7566 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
7569 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
7575 ip->length = clib_host_to_net_u16 (length_val);
7581 ip->checksum = clib_host_to_net_u16 (checksum_val);
7588 unformat_ip6_match (unformat_input_t * input, va_list * args)
7590 u8 **matchp = va_arg (*args, u8 **);
7595 u8 traffic_class = 0;
7596 u32 traffic_class_val = 0;
7599 int src = 0, dst = 0;
7600 ip6_address_t src_val, dst_val;
7603 int payload_length = 0;
7604 u32 payload_length_val;
7607 u32 ip_version_traffic_class_and_flow_label;
7609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7611 if (unformat (input, "version %d", &version_val))
7613 else if (unformat (input, "traffic_class %d", &traffic_class_val))
7615 else if (unformat (input, "flow_label %d", &flow_label_val))
7617 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
7619 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
7621 else if (unformat (input, "proto %d", &proto_val))
7623 else if (unformat (input, "payload_length %d", &payload_length_val))
7625 else if (unformat (input, "hop_limit %d", &hop_limit_val))
7631 if (version + traffic_class + flow_label + src + dst + proto +
7632 payload_length + hop_limit == 0)
7636 * Aligned because we use the real comparison functions
7638 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
7640 ip = (ip6_header_t *) match;
7643 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
7646 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
7649 ip->protocol = proto_val;
7651 ip_version_traffic_class_and_flow_label = 0;
7654 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
7657 ip_version_traffic_class_and_flow_label |=
7658 (traffic_class_val & 0xFF) << 20;
7661 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
7663 ip->ip_version_traffic_class_and_flow_label =
7664 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7667 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
7670 ip->hop_limit = hop_limit_val;
7677 unformat_l3_match (unformat_input_t * input, va_list * args)
7679 u8 **matchp = va_arg (*args, u8 **);
7681 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7683 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
7685 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
7694 unformat_vlan_tag (unformat_input_t * input, va_list * args)
7696 u8 *tagp = va_arg (*args, u8 *);
7699 if (unformat (input, "%d", &tag))
7701 tagp[0] = (tag >> 8) & 0x0F;
7702 tagp[1] = tag & 0xFF;
7710 unformat_l2_match (unformat_input_t * input, va_list * args)
7712 u8 **matchp = va_arg (*args, u8 **);
7732 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7734 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
7737 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
7739 else if (unformat (input, "proto %U",
7740 unformat_ethernet_type_host_byte_order, &proto_val))
7742 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
7744 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
7746 else if (unformat (input, "ignore-tag1"))
7748 else if (unformat (input, "ignore-tag2"))
7750 else if (unformat (input, "cos1 %d", &cos1_val))
7752 else if (unformat (input, "cos2 %d", &cos2_val))
7757 if ((src + dst + proto + tag1 + tag2 +
7758 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7761 if (tag1 || ignore_tag1 || cos1)
7763 if (tag2 || ignore_tag2 || cos2)
7766 vec_validate_aligned (match, len - 1, sizeof (u32x4));
7769 clib_memcpy (match, dst_val, 6);
7772 clib_memcpy (match + 6, src_val, 6);
7776 /* inner vlan tag */
7777 match[19] = tag2_val[1];
7778 match[18] = tag2_val[0];
7780 match[18] |= (cos2_val & 0x7) << 5;
7783 match[21] = proto_val & 0xff;
7784 match[20] = proto_val >> 8;
7788 match[15] = tag1_val[1];
7789 match[14] = tag1_val[0];
7792 match[14] |= (cos1_val & 0x7) << 5;
7798 match[15] = tag1_val[1];
7799 match[14] = tag1_val[0];
7802 match[17] = proto_val & 0xff;
7803 match[16] = proto_val >> 8;
7806 match[14] |= (cos1_val & 0x7) << 5;
7812 match[18] |= (cos2_val & 0x7) << 5;
7814 match[14] |= (cos1_val & 0x7) << 5;
7817 match[13] = proto_val & 0xff;
7818 match[12] = proto_val >> 8;
7826 unformat_qos_source (unformat_input_t * input, va_list * args)
7828 int *qs = va_arg (*args, int *);
7830 if (unformat (input, "ip"))
7831 *qs = QOS_SOURCE_IP;
7832 else if (unformat (input, "mpls"))
7833 *qs = QOS_SOURCE_MPLS;
7834 else if (unformat (input, "ext"))
7835 *qs = QOS_SOURCE_EXT;
7836 else if (unformat (input, "vlan"))
7837 *qs = QOS_SOURCE_VLAN;
7846 api_unformat_classify_match (unformat_input_t * input, va_list * args)
7848 u8 **matchp = va_arg (*args, u8 **);
7849 u32 skip_n_vectors = va_arg (*args, u32);
7850 u32 match_n_vectors = va_arg (*args, u32);
7857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7859 if (unformat (input, "hex %U", unformat_hex_string, &match))
7861 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
7863 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
7865 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
7879 if (match || l2 || l3 || l4)
7883 /* "Win a free Ethernet header in every packet" */
7885 vec_validate_aligned (l2, 13, sizeof (u32x4));
7889 vec_append_aligned (match, l3, sizeof (u32x4));
7894 vec_append_aligned (match, l4, sizeof (u32x4));
7899 /* Make sure the vector is big enough even if key is all 0's */
7900 vec_validate_aligned
7901 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
7904 /* Set size, include skipped vectors */
7905 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
7916 api_set_ipfix_exporter (vat_main_t *vam)
7918 unformat_input_t *i = vam->input;
7919 vl_api_set_ipfix_exporter_t *mp;
7920 ip4_address_t collector_address;
7921 u8 collector_address_set = 0;
7922 u32 collector_port = ~0;
7923 ip4_address_t src_address;
7924 u8 src_address_set = 0;
7927 u32 template_interval = ~0;
7928 u8 udp_checksum = 0;
7931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7933 if (unformat (i, "collector_address %U", unformat_ip4_address,
7934 &collector_address))
7935 collector_address_set = 1;
7936 else if (unformat (i, "collector_port %d", &collector_port))
7938 else if (unformat (i, "src_address %U", unformat_ip4_address,
7940 src_address_set = 1;
7941 else if (unformat (i, "vrf_id %d", &vrf_id))
7943 else if (unformat (i, "path_mtu %d", &path_mtu))
7945 else if (unformat (i, "template_interval %d", &template_interval))
7947 else if (unformat (i, "udp_checksum"))
7953 if (collector_address_set == 0)
7955 errmsg ("collector_address required");
7959 if (src_address_set == 0)
7961 errmsg ("src_address required");
7965 M (SET_IPFIX_EXPORTER, mp);
7967 memcpy (mp->collector_address.un.ip4, collector_address.data,
7968 sizeof (collector_address.data));
7969 mp->collector_port = htons ((u16) collector_port);
7970 memcpy (mp->src_address.un.ip4, src_address.data,
7971 sizeof (src_address.data));
7972 mp->vrf_id = htonl (vrf_id);
7973 mp->path_mtu = htonl (path_mtu);
7974 mp->template_interval = htonl (template_interval);
7975 mp->udp_checksum = udp_checksum;
7983 api_set_ipfix_classify_stream (vat_main_t * vam)
7985 unformat_input_t *i = vam->input;
7986 vl_api_set_ipfix_classify_stream_t *mp;
7988 u32 src_port = UDP_DST_PORT_ipfix;
7991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7993 if (unformat (i, "domain %d", &domain_id))
7995 else if (unformat (i, "src_port %d", &src_port))
7999 errmsg ("unknown input `%U'", format_unformat_error, i);
8004 M (SET_IPFIX_CLASSIFY_STREAM, mp);
8006 mp->domain_id = htonl (domain_id);
8007 mp->src_port = htons ((u16) src_port);
8015 api_ipfix_classify_table_add_del (vat_main_t * vam)
8017 unformat_input_t *i = vam->input;
8018 vl_api_ipfix_classify_table_add_del_t *mp;
8020 u32 classify_table_index = ~0;
8022 u8 transport_protocol = 255;
8025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8027 if (unformat (i, "add"))
8029 else if (unformat (i, "del"))
8031 else if (unformat (i, "table %d", &classify_table_index))
8033 else if (unformat (i, "ip4"))
8035 else if (unformat (i, "ip6"))
8037 else if (unformat (i, "tcp"))
8038 transport_protocol = 6;
8039 else if (unformat (i, "udp"))
8040 transport_protocol = 17;
8043 errmsg ("unknown input `%U'", format_unformat_error, i);
8050 errmsg ("expecting: add|del");
8053 if (classify_table_index == ~0)
8055 errmsg ("classifier table not specified");
8058 if (ip_version == 0)
8060 errmsg ("IP version not specified");
8064 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
8066 mp->is_add = is_add;
8067 mp->table_id = htonl (classify_table_index);
8068 mp->ip_version = ip_version;
8069 mp->transport_protocol = transport_protocol;
8077 api_get_node_index (vat_main_t * vam)
8079 unformat_input_t *i = vam->input;
8080 vl_api_get_node_index_t *mp;
8084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8086 if (unformat (i, "node %s", &name))
8093 errmsg ("node name required");
8096 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8098 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
8102 M (GET_NODE_INDEX, mp);
8103 clib_memcpy (mp->node_name, name, vec_len (name));
8112 api_get_next_index (vat_main_t * vam)
8114 unformat_input_t *i = vam->input;
8115 vl_api_get_next_index_t *mp;
8116 u8 *node_name = 0, *next_node_name = 0;
8119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8121 if (unformat (i, "node-name %s", &node_name))
8123 else if (unformat (i, "next-node-name %s", &next_node_name))
8129 errmsg ("node name required");
8132 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8134 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
8138 if (next_node_name == 0)
8140 errmsg ("next node name required");
8143 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8145 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
8149 M (GET_NEXT_INDEX, mp);
8150 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8151 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8152 vec_free (node_name);
8153 vec_free (next_node_name);
8161 api_add_node_next (vat_main_t * vam)
8163 unformat_input_t *i = vam->input;
8164 vl_api_add_node_next_t *mp;
8169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8171 if (unformat (i, "node %s", &name))
8173 else if (unformat (i, "next %s", &next))
8180 errmsg ("node name required");
8183 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8185 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
8190 errmsg ("next node required");
8193 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8195 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
8199 M (ADD_NODE_NEXT, mp);
8200 clib_memcpy (mp->node_name, name, vec_len (name));
8201 clib_memcpy (mp->next_name, next, vec_len (next));
8210 static void vl_api_sw_interface_tap_v2_details_t_handler
8211 (vl_api_sw_interface_tap_v2_details_t * mp)
8213 vat_main_t *vam = &vat_main;
8216 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
8217 mp->host_ip4_prefix.len);
8219 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
8220 mp->host_ip6_prefix.len);
8223 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
8224 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
8225 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
8226 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
8227 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
8233 static void vl_api_sw_interface_tap_v2_details_t_handler_json
8234 (vl_api_sw_interface_tap_v2_details_t * mp)
8236 vat_main_t *vam = &vat_main;
8237 vat_json_node_t *node = NULL;
8239 if (VAT_JSON_ARRAY != vam->json_tree.type)
8241 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8242 vat_json_init_array (&vam->json_tree);
8244 node = vat_json_array_add (&vam->json_tree);
8246 vat_json_init_object (node);
8247 vat_json_object_add_uint (node, "id", ntohl (mp->id));
8248 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8249 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
8250 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
8251 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
8252 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
8253 vat_json_object_add_string_copy (node, "host_mac_addr",
8254 format (0, "%U", format_ethernet_address,
8255 &mp->host_mac_addr));
8256 vat_json_object_add_string_copy (node, "host_namespace",
8257 mp->host_namespace);
8258 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
8259 vat_json_object_add_string_copy (node, "host_ip4_addr",
8260 format (0, "%U/%d", format_ip4_address,
8261 mp->host_ip4_prefix.address,
8262 mp->host_ip4_prefix.len));
8263 vat_json_object_add_string_copy (node, "host_ip6_prefix",
8264 format (0, "%U/%d", format_ip6_address,
8265 mp->host_ip6_prefix.address,
8266 mp->host_ip6_prefix.len));
8271 api_sw_interface_tap_v2_dump (vat_main_t * vam)
8273 vl_api_sw_interface_tap_v2_dump_t *mp;
8274 vl_api_control_ping_t *mp_ping;
8278 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
8279 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
8280 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
8283 /* Get list of tap interfaces */
8284 M (SW_INTERFACE_TAP_V2_DUMP, mp);
8287 /* Use a control ping for synchronization */
8288 MPING (CONTROL_PING, mp_ping);
8295 static void vl_api_sw_interface_virtio_pci_details_t_handler
8296 (vl_api_sw_interface_virtio_pci_details_t * mp)
8298 vat_main_t *vam = &vat_main;
8313 addr.domain = ntohs (mp->pci_addr.domain);
8314 addr.bus = mp->pci_addr.bus;
8315 addr.slot = mp->pci_addr.slot;
8316 addr.function = mp->pci_addr.function;
8318 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
8319 addr.slot, addr.function);
8322 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
8323 pci_addr, ntohl (mp->sw_if_index),
8324 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
8325 format_ethernet_address, mp->mac_addr,
8326 clib_net_to_host_u64 (mp->features));
8327 vec_free (pci_addr);
8330 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
8331 (vl_api_sw_interface_virtio_pci_details_t * mp)
8333 vat_main_t *vam = &vat_main;
8334 vat_json_node_t *node = NULL;
8335 vlib_pci_addr_t pci_addr;
8337 if (VAT_JSON_ARRAY != vam->json_tree.type)
8339 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8340 vat_json_init_array (&vam->json_tree);
8342 node = vat_json_array_add (&vam->json_tree);
8344 pci_addr.domain = ntohs (mp->pci_addr.domain);
8345 pci_addr.bus = mp->pci_addr.bus;
8346 pci_addr.slot = mp->pci_addr.slot;
8347 pci_addr.function = mp->pci_addr.function;
8349 vat_json_init_object (node);
8350 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
8351 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8352 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
8353 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
8354 vat_json_object_add_uint (node, "features",
8355 clib_net_to_host_u64 (mp->features));
8356 vat_json_object_add_string_copy (node, "mac_addr",
8357 format (0, "%U", format_ethernet_address,
8362 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
8364 vl_api_sw_interface_virtio_pci_dump_t *mp;
8365 vl_api_control_ping_t *mp_ping;
8369 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
8370 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
8371 "mac_addr", "features");
8373 /* Get list of tap interfaces */
8374 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
8377 /* Use a control ping for synchronization */
8378 MPING (CONTROL_PING, mp_ping);
8386 api_l2_fib_clear_table (vat_main_t * vam)
8388 // unformat_input_t * i = vam->input;
8389 vl_api_l2_fib_clear_table_t *mp;
8392 M (L2_FIB_CLEAR_TABLE, mp);
8400 api_l2_interface_efp_filter (vat_main_t * vam)
8402 unformat_input_t *i = vam->input;
8403 vl_api_l2_interface_efp_filter_t *mp;
8406 u8 sw_if_index_set = 0;
8409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8411 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8412 sw_if_index_set = 1;
8413 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8414 sw_if_index_set = 1;
8415 else if (unformat (i, "enable"))
8417 else if (unformat (i, "disable"))
8421 clib_warning ("parse error '%U'", format_unformat_error, i);
8426 if (sw_if_index_set == 0)
8428 errmsg ("missing sw_if_index");
8432 M (L2_INTERFACE_EFP_FILTER, mp);
8434 mp->sw_if_index = ntohl (sw_if_index);
8435 mp->enable_disable = enable;
8442 #define foreach_vtr_op \
8443 _("disable", L2_VTR_DISABLED) \
8444 _("push-1", L2_VTR_PUSH_1) \
8445 _("push-2", L2_VTR_PUSH_2) \
8446 _("pop-1", L2_VTR_POP_1) \
8447 _("pop-2", L2_VTR_POP_2) \
8448 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
8449 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
8450 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
8451 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
8454 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
8456 unformat_input_t *i = vam->input;
8457 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
8459 u8 sw_if_index_set = 0;
8467 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8469 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8470 sw_if_index_set = 1;
8471 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8472 sw_if_index_set = 1;
8473 else if (unformat (i, "vtr_op %d", &vtr_op))
8475 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
8478 else if (unformat (i, "push_dot1q %d", &push_dot1q))
8480 else if (unformat (i, "tag1 %d", &tag1))
8482 else if (unformat (i, "tag2 %d", &tag2))
8486 clib_warning ("parse error '%U'", format_unformat_error, i);
8491 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
8493 errmsg ("missing vtr operation or sw_if_index");
8497 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
8498 mp->sw_if_index = ntohl (sw_if_index);
8499 mp->vtr_op = ntohl (vtr_op);
8500 mp->push_dot1q = ntohl (push_dot1q);
8501 mp->tag1 = ntohl (tag1);
8502 mp->tag2 = ntohl (tag2);
8510 api_create_vhost_user_if (vat_main_t * vam)
8512 unformat_input_t *i = vam->input;
8513 vl_api_create_vhost_user_if_t *mp;
8516 u8 file_name_set = 0;
8517 u32 custom_dev_instance = ~0;
8519 u8 use_custom_mac = 0;
8520 u8 disable_mrg_rxbuf = 0;
8521 u8 disable_indirect_desc = 0;
8524 u8 enable_packed = 0;
8527 /* Shut up coverity */
8528 clib_memset (hwaddr, 0, sizeof (hwaddr));
8530 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8532 if (unformat (i, "socket %s", &file_name))
8536 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
8538 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
8540 else if (unformat (i, "server"))
8542 else if (unformat (i, "disable_mrg_rxbuf"))
8543 disable_mrg_rxbuf = 1;
8544 else if (unformat (i, "disable_indirect_desc"))
8545 disable_indirect_desc = 1;
8546 else if (unformat (i, "gso"))
8548 else if (unformat (i, "packed"))
8550 else if (unformat (i, "tag %s", &tag))
8556 if (file_name_set == 0)
8558 errmsg ("missing socket file name");
8562 if (vec_len (file_name) > 255)
8564 errmsg ("socket file name too long");
8567 vec_add1 (file_name, 0);
8569 M (CREATE_VHOST_USER_IF, mp);
8571 mp->is_server = is_server;
8572 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
8573 mp->disable_indirect_desc = disable_indirect_desc;
8574 mp->enable_gso = enable_gso;
8575 mp->enable_packed = enable_packed;
8576 mp->custom_dev_instance = ntohl (custom_dev_instance);
8577 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
8578 vec_free (file_name);
8579 if (custom_dev_instance != ~0)
8582 mp->use_custom_mac = use_custom_mac;
8583 clib_memcpy (mp->mac_address, hwaddr, 6);
8585 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
8594 api_modify_vhost_user_if (vat_main_t * vam)
8596 unformat_input_t *i = vam->input;
8597 vl_api_modify_vhost_user_if_t *mp;
8600 u8 file_name_set = 0;
8601 u32 custom_dev_instance = ~0;
8602 u8 sw_if_index_set = 0;
8603 u32 sw_if_index = (u32) ~ 0;
8605 u8 enable_packed = 0;
8608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8610 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8611 sw_if_index_set = 1;
8612 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8613 sw_if_index_set = 1;
8614 else if (unformat (i, "socket %s", &file_name))
8618 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
8620 else if (unformat (i, "server"))
8622 else if (unformat (i, "gso"))
8624 else if (unformat (i, "packed"))
8630 if (sw_if_index_set == 0)
8632 errmsg ("missing sw_if_index or interface name");
8636 if (file_name_set == 0)
8638 errmsg ("missing socket file name");
8642 if (vec_len (file_name) > 255)
8644 errmsg ("socket file name too long");
8647 vec_add1 (file_name, 0);
8649 M (MODIFY_VHOST_USER_IF, mp);
8651 mp->sw_if_index = ntohl (sw_if_index);
8652 mp->is_server = is_server;
8653 mp->enable_gso = enable_gso;
8654 mp->enable_packed = enable_packed;
8655 mp->custom_dev_instance = ntohl (custom_dev_instance);
8656 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
8657 vec_free (file_name);
8658 if (custom_dev_instance != ~0)
8667 api_create_vhost_user_if_v2 (vat_main_t * vam)
8669 unformat_input_t *i = vam->input;
8670 vl_api_create_vhost_user_if_v2_t *mp;
8673 u8 file_name_set = 0;
8674 u32 custom_dev_instance = ~0;
8676 u8 use_custom_mac = 0;
8677 u8 disable_mrg_rxbuf = 0;
8678 u8 disable_indirect_desc = 0;
8681 u8 enable_packed = 0;
8682 u8 enable_event_idx = 0;
8685 /* Shut up coverity */
8686 clib_memset (hwaddr, 0, sizeof (hwaddr));
8688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8690 if (unformat (i, "socket %s", &file_name))
8694 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
8696 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
8698 else if (unformat (i, "server"))
8700 else if (unformat (i, "disable_mrg_rxbuf"))
8701 disable_mrg_rxbuf = 1;
8702 else if (unformat (i, "disable_indirect_desc"))
8703 disable_indirect_desc = 1;
8704 else if (unformat (i, "gso"))
8706 else if (unformat (i, "packed"))
8708 else if (unformat (i, "event-idx"))
8709 enable_event_idx = 1;
8710 else if (unformat (i, "tag %s", &tag))
8716 if (file_name_set == 0)
8718 errmsg ("missing socket file name");
8722 if (vec_len (file_name) > 255)
8724 errmsg ("socket file name too long");
8727 vec_add1 (file_name, 0);
8729 M (CREATE_VHOST_USER_IF_V2, mp);
8731 mp->is_server = is_server;
8732 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
8733 mp->disable_indirect_desc = disable_indirect_desc;
8734 mp->enable_gso = enable_gso;
8735 mp->enable_packed = enable_packed;
8736 mp->enable_event_idx = enable_event_idx;
8737 mp->custom_dev_instance = ntohl (custom_dev_instance);
8738 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
8739 vec_free (file_name);
8740 if (custom_dev_instance != ~0)
8743 mp->use_custom_mac = use_custom_mac;
8744 clib_memcpy (mp->mac_address, hwaddr, 6);
8746 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
8755 api_modify_vhost_user_if_v2 (vat_main_t * vam)
8757 unformat_input_t *i = vam->input;
8758 vl_api_modify_vhost_user_if_v2_t *mp;
8761 u8 file_name_set = 0;
8762 u32 custom_dev_instance = ~0;
8763 u8 sw_if_index_set = 0;
8764 u32 sw_if_index = (u32) ~ 0;
8766 u8 enable_packed = 0;
8767 u8 enable_event_idx = 0;
8770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8772 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8773 sw_if_index_set = 1;
8774 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8775 sw_if_index_set = 1;
8776 else if (unformat (i, "socket %s", &file_name))
8780 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
8782 else if (unformat (i, "server"))
8784 else if (unformat (i, "gso"))
8786 else if (unformat (i, "packed"))
8788 else if (unformat (i, "event-idx"))
8789 enable_event_idx = 1;
8794 if (sw_if_index_set == 0)
8796 errmsg ("missing sw_if_index or interface name");
8800 if (file_name_set == 0)
8802 errmsg ("missing socket file name");
8806 if (vec_len (file_name) > 255)
8808 errmsg ("socket file name too long");
8811 vec_add1 (file_name, 0);
8813 M (MODIFY_VHOST_USER_IF_V2, mp);
8815 mp->sw_if_index = ntohl (sw_if_index);
8816 mp->is_server = is_server;
8817 mp->enable_gso = enable_gso;
8818 mp->enable_packed = enable_packed;
8819 mp->enable_event_idx = enable_event_idx;
8820 mp->custom_dev_instance = ntohl (custom_dev_instance);
8821 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
8822 vec_free (file_name);
8823 if (custom_dev_instance != ~0)
8832 api_delete_vhost_user_if (vat_main_t * vam)
8834 unformat_input_t *i = vam->input;
8835 vl_api_delete_vhost_user_if_t *mp;
8836 u32 sw_if_index = ~0;
8837 u8 sw_if_index_set = 0;
8840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8842 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8843 sw_if_index_set = 1;
8844 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8845 sw_if_index_set = 1;
8850 if (sw_if_index_set == 0)
8852 errmsg ("missing sw_if_index or interface name");
8857 M (DELETE_VHOST_USER_IF, mp);
8859 mp->sw_if_index = ntohl (sw_if_index);
8866 static void vl_api_sw_interface_vhost_user_details_t_handler
8867 (vl_api_sw_interface_vhost_user_details_t * mp)
8869 vat_main_t *vam = &vat_main;
8873 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
8874 clib_net_to_host_u32
8875 (mp->features_last_32) <<
8878 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %16llx %6d %7d %s",
8879 (char *) mp->interface_name, ntohl (mp->sw_if_index),
8880 ntohl (mp->virtio_net_hdr_sz), features, mp->is_server,
8881 ntohl (mp->num_regions), (char *) mp->sock_filename);
8882 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
8885 static void vl_api_sw_interface_vhost_user_details_t_handler_json
8886 (vl_api_sw_interface_vhost_user_details_t * mp)
8888 vat_main_t *vam = &vat_main;
8889 vat_json_node_t *node = NULL;
8891 if (VAT_JSON_ARRAY != vam->json_tree.type)
8893 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8894 vat_json_init_array (&vam->json_tree);
8896 node = vat_json_array_add (&vam->json_tree);
8898 vat_json_init_object (node);
8899 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8900 vat_json_object_add_string_copy (node, "interface_name",
8901 mp->interface_name);
8902 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
8903 ntohl (mp->virtio_net_hdr_sz));
8904 vat_json_object_add_uint (node, "features_first_32",
8905 clib_net_to_host_u32 (mp->features_first_32));
8906 vat_json_object_add_uint (node, "features_last_32",
8907 clib_net_to_host_u32 (mp->features_last_32));
8908 vat_json_object_add_uint (node, "is_server", mp->is_server);
8909 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
8910 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
8911 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
8915 api_sw_interface_vhost_user_dump (vat_main_t * vam)
8917 unformat_input_t *i = vam->input;
8918 vl_api_sw_interface_vhost_user_dump_t *mp;
8919 vl_api_control_ping_t *mp_ping;
8921 u32 sw_if_index = ~0;
8923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8925 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8927 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8933 print (vam->ofp, "Interface name idx hdr_sz features "
8934 "server regions filename");
8936 /* Get list of vhost-user interfaces */
8937 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
8938 mp->sw_if_index = ntohl (sw_if_index);
8941 /* Use a control ping for synchronization */
8942 MPING (CONTROL_PING, mp_ping);
8950 api_show_version (vat_main_t * vam)
8952 vl_api_show_version_t *mp;
8955 M (SHOW_VERSION, mp);
8962 static void vl_api_l2_fib_table_details_t_handler
8963 (vl_api_l2_fib_table_details_t * mp)
8965 vat_main_t *vam = &vat_main;
8967 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
8969 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
8970 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
8974 static void vl_api_l2_fib_table_details_t_handler_json
8975 (vl_api_l2_fib_table_details_t * mp)
8977 vat_main_t *vam = &vat_main;
8978 vat_json_node_t *node = NULL;
8980 if (VAT_JSON_ARRAY != vam->json_tree.type)
8982 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8983 vat_json_init_array (&vam->json_tree);
8985 node = vat_json_array_add (&vam->json_tree);
8987 vat_json_init_object (node);
8988 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
8989 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
8990 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8991 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
8992 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
8993 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
8997 api_l2_fib_table_dump (vat_main_t * vam)
8999 unformat_input_t *i = vam->input;
9000 vl_api_l2_fib_table_dump_t *mp;
9001 vl_api_control_ping_t *mp_ping;
9006 /* Parse args required to build the message */
9007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9009 if (unformat (i, "bd_id %d", &bd_id))
9017 errmsg ("missing bridge domain");
9021 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
9023 /* Get list of l2 fib entries */
9024 M (L2_FIB_TABLE_DUMP, mp);
9026 mp->bd_id = ntohl (bd_id);
9029 /* Use a control ping for synchronization */
9030 MPING (CONTROL_PING, mp_ping);
9039 api_interface_name_renumber (vat_main_t * vam)
9041 unformat_input_t *line_input = vam->input;
9042 vl_api_interface_name_renumber_t *mp;
9043 u32 sw_if_index = ~0;
9044 u32 new_show_dev_instance = ~0;
9047 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9049 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
9052 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9054 else if (unformat (line_input, "new_show_dev_instance %d",
9055 &new_show_dev_instance))
9061 if (sw_if_index == ~0)
9063 errmsg ("missing interface name or sw_if_index");
9067 if (new_show_dev_instance == ~0)
9069 errmsg ("missing new_show_dev_instance");
9073 M (INTERFACE_NAME_RENUMBER, mp);
9075 mp->sw_if_index = ntohl (sw_if_index);
9076 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
9084 api_want_l2_macs_events (vat_main_t * vam)
9086 unformat_input_t *line_input = vam->input;
9087 vl_api_want_l2_macs_events_t *mp;
9088 u8 enable_disable = 1;
9090 u32 max_macs_in_event = 0;
9091 u32 learn_limit = 0;
9094 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9096 if (unformat (line_input, "learn-limit %d", &learn_limit))
9098 else if (unformat (line_input, "scan-delay %d", &scan_delay))
9100 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
9102 else if (unformat (line_input, "disable"))
9108 M (WANT_L2_MACS_EVENTS, mp);
9109 mp->enable_disable = enable_disable;
9110 mp->pid = htonl (getpid ());
9111 mp->learn_limit = htonl (learn_limit);
9112 mp->scan_delay = (u8) scan_delay;
9113 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
9120 api_ip_address_dump (vat_main_t * vam)
9122 unformat_input_t *i = vam->input;
9123 vl_api_ip_address_dump_t *mp;
9124 vl_api_control_ping_t *mp_ping;
9125 u32 sw_if_index = ~0;
9126 u8 sw_if_index_set = 0;
9131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9133 if (unformat (i, "sw_if_index %d", &sw_if_index))
9134 sw_if_index_set = 1;
9136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9137 sw_if_index_set = 1;
9138 else if (unformat (i, "ipv4"))
9140 else if (unformat (i, "ipv6"))
9146 if (ipv4_set && ipv6_set)
9148 errmsg ("ipv4 and ipv6 flags cannot be both set");
9152 if ((!ipv4_set) && (!ipv6_set))
9154 errmsg ("no ipv4 nor ipv6 flag set");
9158 if (sw_if_index_set == 0)
9160 errmsg ("missing interface name or sw_if_index");
9164 vam->current_sw_if_index = sw_if_index;
9165 vam->is_ipv6 = ipv6_set;
9167 M (IP_ADDRESS_DUMP, mp);
9168 mp->sw_if_index = ntohl (sw_if_index);
9169 mp->is_ipv6 = ipv6_set;
9172 /* Use a control ping for synchronization */
9173 MPING (CONTROL_PING, mp_ping);
9181 api_ip_dump (vat_main_t * vam)
9183 vl_api_ip_dump_t *mp;
9184 vl_api_control_ping_t *mp_ping;
9185 unformat_input_t *in = vam->input;
9192 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
9194 if (unformat (in, "ipv4"))
9196 else if (unformat (in, "ipv6"))
9202 if (ipv4_set && ipv6_set)
9204 errmsg ("ipv4 and ipv6 flags cannot be both set");
9208 if ((!ipv4_set) && (!ipv6_set))
9210 errmsg ("no ipv4 nor ipv6 flag set");
9215 vam->is_ipv6 = is_ipv6;
9218 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
9220 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
9222 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
9225 mp->is_ipv6 = ipv6_set;
9228 /* Use a control ping for synchronization */
9229 MPING (CONTROL_PING, mp_ping);
9237 api_ipsec_spd_add_del (vat_main_t * vam)
9239 unformat_input_t *i = vam->input;
9240 vl_api_ipsec_spd_add_del_t *mp;
9245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9247 if (unformat (i, "spd_id %d", &spd_id))
9249 else if (unformat (i, "del"))
9253 clib_warning ("parse error '%U'", format_unformat_error, i);
9259 errmsg ("spd_id must be set");
9263 M (IPSEC_SPD_ADD_DEL, mp);
9265 mp->spd_id = ntohl (spd_id);
9266 mp->is_add = is_add;
9274 api_ipsec_interface_add_del_spd (vat_main_t * vam)
9276 unformat_input_t *i = vam->input;
9277 vl_api_ipsec_interface_add_del_spd_t *mp;
9279 u8 sw_if_index_set = 0;
9280 u32 spd_id = (u32) ~ 0;
9284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9286 if (unformat (i, "del"))
9288 else if (unformat (i, "spd_id %d", &spd_id))
9291 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9292 sw_if_index_set = 1;
9293 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9294 sw_if_index_set = 1;
9297 clib_warning ("parse error '%U'", format_unformat_error, i);
9303 if (spd_id == (u32) ~ 0)
9305 errmsg ("spd_id must be set");
9309 if (sw_if_index_set == 0)
9311 errmsg ("missing interface name or sw_if_index");
9315 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
9317 mp->spd_id = ntohl (spd_id);
9318 mp->sw_if_index = ntohl (sw_if_index);
9319 mp->is_add = is_add;
9327 api_ipsec_spd_entry_add_del (vat_main_t * vam)
9329 unformat_input_t *i = vam->input;
9330 vl_api_ipsec_spd_entry_add_del_t *mp;
9331 u8 is_add = 1, is_outbound = 0;
9332 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
9334 u32 rport_start = 0, rport_stop = (u32) ~ 0;
9335 u32 lport_start = 0, lport_stop = (u32) ~ 0;
9336 vl_api_address_t laddr_start = { }, laddr_stop =
9345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9347 if (unformat (i, "del"))
9349 if (unformat (i, "outbound"))
9351 if (unformat (i, "inbound"))
9353 else if (unformat (i, "spd_id %d", &spd_id))
9355 else if (unformat (i, "sa_id %d", &sa_id))
9357 else if (unformat (i, "priority %d", &priority))
9359 else if (unformat (i, "protocol %d", &protocol))
9361 else if (unformat (i, "lport_start %d", &lport_start))
9363 else if (unformat (i, "lport_stop %d", &lport_stop))
9365 else if (unformat (i, "rport_start %d", &rport_start))
9367 else if (unformat (i, "rport_stop %d", &rport_stop))
9369 else if (unformat (i, "laddr_start %U",
9370 unformat_vl_api_address, &laddr_start))
9372 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
9375 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
9378 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
9382 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
9384 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
9386 clib_warning ("unsupported action: 'resolve'");
9392 clib_warning ("parse error '%U'", format_unformat_error, i);
9398 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
9400 mp->is_add = is_add;
9402 mp->entry.spd_id = ntohl (spd_id);
9403 mp->entry.priority = ntohl (priority);
9404 mp->entry.is_outbound = is_outbound;
9406 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
9407 sizeof (vl_api_address_t));
9408 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
9409 sizeof (vl_api_address_t));
9410 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
9411 sizeof (vl_api_address_t));
9412 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
9413 sizeof (vl_api_address_t));
9415 mp->entry.protocol = (u8) protocol;
9416 mp->entry.local_port_start = ntohs ((u16) lport_start);
9417 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
9418 mp->entry.remote_port_start = ntohs ((u16) rport_start);
9419 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
9420 mp->entry.policy = (u8) policy;
9421 mp->entry.sa_id = ntohl (sa_id);
9429 api_ipsec_sad_entry_add_del (vat_main_t * vam)
9431 unformat_input_t *i = vam->input;
9432 vl_api_ipsec_sad_entry_add_del_t *mp;
9433 u32 sad_id = 0, spi = 0;
9434 u8 *ck = 0, *ik = 0;
9437 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
9438 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
9439 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
9440 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
9441 vl_api_address_t tun_src, tun_dst;
9444 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9446 if (unformat (i, "del"))
9448 else if (unformat (i, "sad_id %d", &sad_id))
9450 else if (unformat (i, "spi %d", &spi))
9452 else if (unformat (i, "esp"))
9453 protocol = IPSEC_API_PROTO_ESP;
9455 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
9457 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
9458 if (ADDRESS_IP6 == tun_src.af)
9459 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
9462 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
9464 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
9465 if (ADDRESS_IP6 == tun_src.af)
9466 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
9469 if (unformat (i, "crypto_alg %U",
9470 unformat_ipsec_api_crypto_alg, &crypto_alg))
9472 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
9474 else if (unformat (i, "integ_alg %U",
9475 unformat_ipsec_api_integ_alg, &integ_alg))
9477 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
9481 clib_warning ("parse error '%U'", format_unformat_error, i);
9487 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
9489 mp->is_add = is_add;
9490 mp->entry.sad_id = ntohl (sad_id);
9491 mp->entry.protocol = protocol;
9492 mp->entry.spi = ntohl (spi);
9493 mp->entry.flags = flags;
9495 mp->entry.crypto_algorithm = crypto_alg;
9496 mp->entry.integrity_algorithm = integ_alg;
9497 mp->entry.crypto_key.length = vec_len (ck);
9498 mp->entry.integrity_key.length = vec_len (ik);
9500 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
9501 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
9503 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
9504 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
9507 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
9509 clib_memcpy (mp->entry.integrity_key.data, ik,
9510 mp->entry.integrity_key.length);
9512 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
9514 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
9515 sizeof (mp->entry.tunnel_src));
9516 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
9517 sizeof (mp->entry.tunnel_dst));
9526 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
9528 vat_main_t *vam = &vat_main;
9530 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
9531 "crypto_key %U integ_alg %u integ_key %U flags %x "
9532 "tunnel_src_addr %U tunnel_dst_addr %U "
9533 "salt %u seq_outbound %lu last_seq_inbound %lu "
9534 "replay_window %lu stat_index %u\n",
9535 ntohl (mp->entry.sad_id),
9536 ntohl (mp->sw_if_index),
9537 ntohl (mp->entry.spi),
9538 ntohl (mp->entry.protocol),
9539 ntohl (mp->entry.crypto_algorithm),
9540 format_hex_bytes, mp->entry.crypto_key.data,
9541 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
9542 format_hex_bytes, mp->entry.integrity_key.data,
9543 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
9544 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
9545 &mp->entry.tunnel_dst, ntohl (mp->salt),
9546 clib_net_to_host_u64 (mp->seq_outbound),
9547 clib_net_to_host_u64 (mp->last_seq_inbound),
9548 clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
9551 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
9552 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
9554 static void vl_api_ipsec_sa_details_t_handler_json
9555 (vl_api_ipsec_sa_details_t * mp)
9557 vat_main_t *vam = &vat_main;
9558 vat_json_node_t *node = NULL;
9559 vl_api_ipsec_sad_flags_t flags;
9561 if (VAT_JSON_ARRAY != vam->json_tree.type)
9563 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9564 vat_json_init_array (&vam->json_tree);
9566 node = vat_json_array_add (&vam->json_tree);
9568 vat_json_init_object (node);
9569 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
9570 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9571 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
9572 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
9573 vat_json_object_add_uint (node, "crypto_alg",
9574 ntohl (mp->entry.crypto_algorithm));
9575 vat_json_object_add_uint (node, "integ_alg",
9576 ntohl (mp->entry.integrity_algorithm));
9577 flags = ntohl (mp->entry.flags);
9578 vat_json_object_add_uint (node, "use_esn",
9579 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
9580 vat_json_object_add_uint (node, "use_anti_replay",
9581 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
9582 vat_json_object_add_uint (node, "is_tunnel",
9583 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
9584 vat_json_object_add_uint (node, "is_tunnel_ip6",
9585 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
9586 vat_json_object_add_uint (node, "udp_encap",
9587 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
9588 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
9589 mp->entry.crypto_key.length);
9590 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
9591 mp->entry.integrity_key.length);
9592 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
9593 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
9594 vat_json_object_add_uint (node, "replay_window",
9595 clib_net_to_host_u64 (mp->replay_window));
9596 vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
9600 api_ipsec_sa_dump (vat_main_t * vam)
9602 unformat_input_t *i = vam->input;
9603 vl_api_ipsec_sa_dump_t *mp;
9604 vl_api_control_ping_t *mp_ping;
9608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9610 if (unformat (i, "sa_id %d", &sa_id))
9614 clib_warning ("parse error '%U'", format_unformat_error, i);
9619 M (IPSEC_SA_DUMP, mp);
9621 mp->sa_id = ntohl (sa_id);
9625 /* Use a control ping for synchronization */
9626 M (CONTROL_PING, mp_ping);
9634 api_get_first_msg_id (vat_main_t * vam)
9636 vl_api_get_first_msg_id_t *mp;
9637 unformat_input_t *i = vam->input;
9642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9644 if (unformat (i, "client %s", &name))
9652 errmsg ("missing client name");
9657 if (vec_len (name) > 63)
9659 errmsg ("client name too long");
9663 M (GET_FIRST_MSG_ID, mp);
9664 clib_memcpy (mp->name, name, vec_len (name));
9671 api_get_node_graph (vat_main_t * vam)
9673 vl_api_get_node_graph_t *mp;
9676 M (GET_NODE_GRAPH, mp);
9680 /* Wait for the reply */
9686 api_af_packet_create (vat_main_t * vam)
9688 unformat_input_t *i = vam->input;
9689 vl_api_af_packet_create_t *mp;
9690 u8 *host_if_name = 0;
9692 u8 random_hw_addr = 1;
9695 clib_memset (hw_addr, 0, sizeof (hw_addr));
9697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9699 if (unformat (i, "name %s", &host_if_name))
9700 vec_add1 (host_if_name, 0);
9701 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
9707 if (!vec_len (host_if_name))
9709 errmsg ("host-interface name must be specified");
9713 if (vec_len (host_if_name) > 64)
9715 errmsg ("host-interface name too long");
9719 M (AF_PACKET_CREATE, mp);
9721 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
9722 clib_memcpy (mp->hw_addr, hw_addr, 6);
9723 mp->use_random_hw_addr = random_hw_addr;
9724 vec_free (host_if_name);
9732 fprintf (vam->ofp ? vam->ofp : stderr,
9733 " new sw_if_index = %d\n", vam->sw_if_index);
9740 api_af_packet_delete (vat_main_t * vam)
9742 unformat_input_t *i = vam->input;
9743 vl_api_af_packet_delete_t *mp;
9744 u8 *host_if_name = 0;
9747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9749 if (unformat (i, "name %s", &host_if_name))
9750 vec_add1 (host_if_name, 0);
9755 if (!vec_len (host_if_name))
9757 errmsg ("host-interface name must be specified");
9761 if (vec_len (host_if_name) > 64)
9763 errmsg ("host-interface name too long");
9767 M (AF_PACKET_DELETE, mp);
9769 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
9770 vec_free (host_if_name);
9777 static void vl_api_af_packet_details_t_handler
9778 (vl_api_af_packet_details_t * mp)
9780 vat_main_t *vam = &vat_main;
9782 print (vam->ofp, "%-16s %d",
9783 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
9786 static void vl_api_af_packet_details_t_handler_json
9787 (vl_api_af_packet_details_t * mp)
9789 vat_main_t *vam = &vat_main;
9790 vat_json_node_t *node = NULL;
9792 if (VAT_JSON_ARRAY != vam->json_tree.type)
9794 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9795 vat_json_init_array (&vam->json_tree);
9797 node = vat_json_array_add (&vam->json_tree);
9799 vat_json_init_object (node);
9800 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9801 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
9805 api_af_packet_dump (vat_main_t * vam)
9807 vl_api_af_packet_dump_t *mp;
9808 vl_api_control_ping_t *mp_ping;
9811 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
9812 /* Get list of tap interfaces */
9813 M (AF_PACKET_DUMP, mp);
9816 /* Use a control ping for synchronization */
9817 MPING (CONTROL_PING, mp_ping);
9825 api_policer_add_del (vat_main_t * vam)
9827 unformat_input_t *i = vam->input;
9828 vl_api_policer_add_del_t *mp;
9839 qos_pol_action_params_st conform_action, exceed_action, violate_action;
9842 conform_action.action_type = QOS_ACTION_TRANSMIT;
9843 conform_action.dscp = 0;
9844 exceed_action.action_type = QOS_ACTION_MARK_AND_TRANSMIT;
9845 exceed_action.dscp = 0;
9846 violate_action.action_type = QOS_ACTION_DROP;
9847 violate_action.dscp = 0;
9849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9851 if (unformat (i, "del"))
9853 else if (unformat (i, "name %s", &name))
9855 else if (unformat (i, "cir %u", &cir))
9857 else if (unformat (i, "eir %u", &eir))
9859 else if (unformat (i, "cb %u", &cb))
9861 else if (unformat (i, "eb %u", &eb))
9863 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
9866 else if (unformat (i, "round_type %U", unformat_policer_round_type,
9869 else if (unformat (i, "type %U", unformat_policer_type, &type))
9871 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
9874 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
9877 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
9880 else if (unformat (i, "color-aware"))
9886 if (!vec_len (name))
9888 errmsg ("policer name must be specified");
9892 if (vec_len (name) > 64)
9894 errmsg ("policer name too long");
9898 M (POLICER_ADD_DEL, mp);
9900 clib_memcpy (mp->name, name, vec_len (name));
9902 mp->is_add = is_add;
9903 mp->cir = ntohl (cir);
9904 mp->eir = ntohl (eir);
9905 mp->cb = clib_net_to_host_u64 (cb);
9906 mp->eb = clib_net_to_host_u64 (eb);
9907 mp->rate_type = rate_type;
9908 mp->round_type = round_type;
9910 mp->conform_action.type =
9911 (vl_api_sse2_qos_action_type_t) conform_action.action_type;
9912 mp->conform_action.dscp = conform_action.dscp;
9913 mp->exceed_action.type =
9914 (vl_api_sse2_qos_action_type_t) exceed_action.action_type;
9915 mp->exceed_action.dscp = exceed_action.dscp;
9916 mp->violate_action.type =
9917 (vl_api_sse2_qos_action_type_t) violate_action.action_type;
9918 mp->violate_action.dscp = violate_action.dscp;
9919 mp->color_aware = color_aware;
9927 api_policer_dump (vat_main_t * vam)
9929 unformat_input_t *i = vam->input;
9930 vl_api_policer_dump_t *mp;
9931 vl_api_control_ping_t *mp_ping;
9933 u8 match_name_valid = 0;
9936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9938 if (unformat (i, "name %s", &match_name))
9940 vec_add1 (match_name, 0);
9941 match_name_valid = 1;
9947 M (POLICER_DUMP, mp);
9948 mp->match_name_valid = match_name_valid;
9949 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
9950 vec_free (match_name);
9954 /* Use a control ping for synchronization */
9955 MPING (CONTROL_PING, mp_ping);
9958 /* Wait for a reply... */
9964 format_fib_api_path_nh_proto (u8 * s, va_list * args)
9966 vl_api_fib_path_nh_proto_t proto =
9967 va_arg (*args, vl_api_fib_path_nh_proto_t);
9971 case FIB_API_PATH_NH_PROTO_IP4:
9972 s = format (s, "ip4");
9974 case FIB_API_PATH_NH_PROTO_IP6:
9975 s = format (s, "ip6");
9977 case FIB_API_PATH_NH_PROTO_MPLS:
9978 s = format (s, "mpls");
9980 case FIB_API_PATH_NH_PROTO_BIER:
9981 s = format (s, "bier");
9983 case FIB_API_PATH_NH_PROTO_ETHERNET:
9984 s = format (s, "ethernet");
9992 format_vl_api_ip_address_union (u8 * s, va_list * args)
9994 vl_api_address_family_t af = va_arg (*args, int);
9995 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
10000 s = format (s, "%U", format_ip4_address, u->ip4);
10003 s = format (s, "%U", format_ip6_address, u->ip6);
10010 format_vl_api_fib_path_type (u8 * s, va_list * args)
10012 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
10016 case FIB_API_PATH_TYPE_NORMAL:
10017 s = format (s, "normal");
10019 case FIB_API_PATH_TYPE_LOCAL:
10020 s = format (s, "local");
10022 case FIB_API_PATH_TYPE_DROP:
10023 s = format (s, "drop");
10025 case FIB_API_PATH_TYPE_UDP_ENCAP:
10026 s = format (s, "udp-encap");
10028 case FIB_API_PATH_TYPE_BIER_IMP:
10029 s = format (s, "bier-imp");
10031 case FIB_API_PATH_TYPE_ICMP_UNREACH:
10032 s = format (s, "unreach");
10034 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
10035 s = format (s, "prohibit");
10037 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
10038 s = format (s, "src-lookup");
10040 case FIB_API_PATH_TYPE_DVR:
10041 s = format (s, "dvr");
10043 case FIB_API_PATH_TYPE_INTERFACE_RX:
10044 s = format (s, "interface-rx");
10046 case FIB_API_PATH_TYPE_CLASSIFY:
10047 s = format (s, "classify");
10055 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
10058 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
10059 ntohl (fp->weight), ntohl (fp->sw_if_index),
10060 format_vl_api_fib_path_type, fp->type,
10061 format_fib_api_path_nh_proto, fp->proto,
10062 format_vl_api_ip_address_union, &fp->nh.address);
10066 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
10067 vl_api_fib_path_t * fp)
10069 struct in_addr ip4;
10070 struct in6_addr ip6;
10072 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
10073 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
10074 vat_json_object_add_uint (node, "type", fp->type);
10075 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
10076 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
10078 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
10079 vat_json_object_add_ip4 (node, "next_hop", ip4);
10081 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
10083 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
10084 vat_json_object_add_ip6 (node, "next_hop", ip6);
10089 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
10091 vat_main_t *vam = &vat_main;
10092 int count = ntohl (mp->mt_tunnel.mt_n_paths);
10093 vl_api_fib_path_t *fp;
10096 print (vam->ofp, "sw_if_index %d via:",
10097 ntohl (mp->mt_tunnel.mt_sw_if_index));
10098 fp = mp->mt_tunnel.mt_paths;
10099 for (i = 0; i < count; i++)
10101 vl_api_fib_path_print (vam, fp);
10105 print (vam->ofp, "");
10108 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
10109 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
10112 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
10114 vat_main_t *vam = &vat_main;
10115 vat_json_node_t *node = NULL;
10116 int count = ntohl (mp->mt_tunnel.mt_n_paths);
10117 vl_api_fib_path_t *fp;
10120 if (VAT_JSON_ARRAY != vam->json_tree.type)
10122 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10123 vat_json_init_array (&vam->json_tree);
10125 node = vat_json_array_add (&vam->json_tree);
10127 vat_json_init_object (node);
10128 vat_json_object_add_uint (node, "sw_if_index",
10129 ntohl (mp->mt_tunnel.mt_sw_if_index));
10131 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
10133 fp = mp->mt_tunnel.mt_paths;
10134 for (i = 0; i < count; i++)
10136 vl_api_mpls_fib_path_json_print (node, fp);
10142 api_mpls_tunnel_dump (vat_main_t * vam)
10144 vl_api_mpls_tunnel_dump_t *mp;
10145 vl_api_control_ping_t *mp_ping;
10148 M (MPLS_TUNNEL_DUMP, mp);
10152 /* Use a control ping for synchronization */
10153 MPING (CONTROL_PING, mp_ping);
10160 #define vl_api_mpls_table_details_t_endian vl_noop_handler
10161 #define vl_api_mpls_table_details_t_print vl_noop_handler
10165 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
10167 vat_main_t *vam = &vat_main;
10169 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
10172 static void vl_api_mpls_table_details_t_handler_json
10173 (vl_api_mpls_table_details_t * mp)
10175 vat_main_t *vam = &vat_main;
10176 vat_json_node_t *node = NULL;
10178 if (VAT_JSON_ARRAY != vam->json_tree.type)
10180 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10181 vat_json_init_array (&vam->json_tree);
10183 node = vat_json_array_add (&vam->json_tree);
10185 vat_json_init_object (node);
10186 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
10190 api_mpls_table_dump (vat_main_t * vam)
10192 vl_api_mpls_table_dump_t *mp;
10193 vl_api_control_ping_t *mp_ping;
10196 M (MPLS_TABLE_DUMP, mp);
10199 /* Use a control ping for synchronization */
10200 MPING (CONTROL_PING, mp_ping);
10207 #define vl_api_mpls_route_details_t_endian vl_noop_handler
10208 #define vl_api_mpls_route_details_t_print vl_noop_handler
10211 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
10213 vat_main_t *vam = &vat_main;
10214 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
10215 vl_api_fib_path_t *fp;
10219 "table-id %d, label %u, ess_bit %u",
10220 ntohl (mp->mr_route.mr_table_id),
10221 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
10222 fp = mp->mr_route.mr_paths;
10223 for (i = 0; i < count; i++)
10225 vl_api_fib_path_print (vam, fp);
10230 static void vl_api_mpls_route_details_t_handler_json
10231 (vl_api_mpls_route_details_t * mp)
10233 vat_main_t *vam = &vat_main;
10234 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
10235 vat_json_node_t *node = NULL;
10236 vl_api_fib_path_t *fp;
10239 if (VAT_JSON_ARRAY != vam->json_tree.type)
10241 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10242 vat_json_init_array (&vam->json_tree);
10244 node = vat_json_array_add (&vam->json_tree);
10246 vat_json_init_object (node);
10247 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
10248 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
10249 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
10250 vat_json_object_add_uint (node, "path_count", count);
10251 fp = mp->mr_route.mr_paths;
10252 for (i = 0; i < count; i++)
10254 vl_api_mpls_fib_path_json_print (node, fp);
10260 api_mpls_route_dump (vat_main_t * vam)
10262 unformat_input_t *input = vam->input;
10263 vl_api_mpls_route_dump_t *mp;
10264 vl_api_control_ping_t *mp_ping;
10268 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10270 if (unformat (input, "table_id %d", &table_id))
10275 if (table_id == ~0)
10277 errmsg ("missing table id");
10281 M (MPLS_ROUTE_DUMP, mp);
10283 mp->table.mt_table_id = ntohl (table_id);
10286 /* Use a control ping for synchronization */
10287 MPING (CONTROL_PING, mp_ping);
10294 #define vl_api_ip_table_details_t_endian vl_noop_handler
10295 #define vl_api_ip_table_details_t_print vl_noop_handler
10298 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
10300 vat_main_t *vam = &vat_main;
10303 "%s; table-id %d, prefix %U/%d",
10304 mp->table.name, ntohl (mp->table.table_id));
10308 static void vl_api_ip_table_details_t_handler_json
10309 (vl_api_ip_table_details_t * mp)
10311 vat_main_t *vam = &vat_main;
10312 vat_json_node_t *node = NULL;
10314 if (VAT_JSON_ARRAY != vam->json_tree.type)
10316 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10317 vat_json_init_array (&vam->json_tree);
10319 node = vat_json_array_add (&vam->json_tree);
10321 vat_json_init_object (node);
10322 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
10326 api_ip_table_dump (vat_main_t * vam)
10328 vl_api_ip_table_dump_t *mp;
10329 vl_api_control_ping_t *mp_ping;
10332 M (IP_TABLE_DUMP, mp);
10335 /* Use a control ping for synchronization */
10336 MPING (CONTROL_PING, mp_ping);
10344 api_ip_mtable_dump (vat_main_t * vam)
10346 vl_api_ip_mtable_dump_t *mp;
10347 vl_api_control_ping_t *mp_ping;
10350 M (IP_MTABLE_DUMP, mp);
10353 /* Use a control ping for synchronization */
10354 MPING (CONTROL_PING, mp_ping);
10362 api_ip_mroute_dump (vat_main_t * vam)
10364 unformat_input_t *input = vam->input;
10365 vl_api_control_ping_t *mp_ping;
10366 vl_api_ip_mroute_dump_t *mp;
10371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10373 if (unformat (input, "table_id %d", &table_id))
10375 else if (unformat (input, "ip6"))
10377 else if (unformat (input, "ip4"))
10382 if (table_id == ~0)
10384 errmsg ("missing table id");
10388 M (IP_MROUTE_DUMP, mp);
10389 mp->table.table_id = table_id;
10390 mp->table.is_ip6 = is_ip6;
10393 /* Use a control ping for synchronization */
10394 MPING (CONTROL_PING, mp_ping);
10401 #define vl_api_ip_route_details_t_endian vl_noop_handler
10402 #define vl_api_ip_route_details_t_print vl_noop_handler
10405 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
10407 vat_main_t *vam = &vat_main;
10408 u8 count = mp->route.n_paths;
10409 vl_api_fib_path_t *fp;
10413 "table-id %d, prefix %U/%d",
10414 ntohl (mp->route.table_id),
10415 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
10416 for (i = 0; i < count; i++)
10418 fp = &mp->route.paths[i];
10420 vl_api_fib_path_print (vam, fp);
10425 static void vl_api_ip_route_details_t_handler_json
10426 (vl_api_ip_route_details_t * mp)
10428 vat_main_t *vam = &vat_main;
10429 u8 count = mp->route.n_paths;
10430 vat_json_node_t *node = NULL;
10431 struct in_addr ip4;
10432 struct in6_addr ip6;
10433 vl_api_fib_path_t *fp;
10436 if (VAT_JSON_ARRAY != vam->json_tree.type)
10438 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10439 vat_json_init_array (&vam->json_tree);
10441 node = vat_json_array_add (&vam->json_tree);
10443 vat_json_init_object (node);
10444 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
10445 if (ADDRESS_IP6 == mp->route.prefix.address.af)
10447 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
10448 vat_json_object_add_ip6 (node, "prefix", ip6);
10452 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
10453 vat_json_object_add_ip4 (node, "prefix", ip4);
10455 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
10456 vat_json_object_add_uint (node, "path_count", count);
10457 for (i = 0; i < count; i++)
10459 fp = &mp->route.paths[i];
10460 vl_api_mpls_fib_path_json_print (node, fp);
10465 api_ip_route_dump (vat_main_t * vam)
10467 unformat_input_t *input = vam->input;
10468 vl_api_ip_route_dump_t *mp;
10469 vl_api_control_ping_t *mp_ping;
10475 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10477 if (unformat (input, "table_id %d", &table_id))
10479 else if (unformat (input, "ip6"))
10481 else if (unformat (input, "ip4"))
10486 if (table_id == ~0)
10488 errmsg ("missing table id");
10492 M (IP_ROUTE_DUMP, mp);
10494 mp->table.table_id = table_id;
10495 mp->table.is_ip6 = is_ip6;
10499 /* Use a control ping for synchronization */
10500 MPING (CONTROL_PING, mp_ping);
10508 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
10510 vat_main_t *vam = &vat_main;
10512 print (vam->ofp, "collector_address %U, collector_port %d, "
10513 "src_address %U, vrf_id %d, path_mtu %u, "
10514 "template_interval %u, udp_checksum %d",
10515 format_ip4_address, mp->collector_address,
10516 ntohs (mp->collector_port),
10517 format_ip4_address, mp->src_address,
10518 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
10519 ntohl (mp->template_interval), mp->udp_checksum);
10522 vam->result_ready = 1;
10526 vl_api_ipfix_exporter_details_t_handler_json
10527 (vl_api_ipfix_exporter_details_t * mp)
10529 vat_main_t *vam = &vat_main;
10530 vat_json_node_t node;
10531 struct in_addr collector_address;
10532 struct in_addr src_address;
10534 vat_json_init_object (&node);
10535 clib_memcpy (&collector_address, &mp->collector_address,
10536 sizeof (collector_address));
10537 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
10538 vat_json_object_add_uint (&node, "collector_port",
10539 ntohs (mp->collector_port));
10540 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
10541 vat_json_object_add_ip4 (&node, "src_address", src_address);
10542 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
10543 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
10544 vat_json_object_add_uint (&node, "template_interval",
10545 ntohl (mp->template_interval));
10546 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
10548 vat_json_print (vam->ofp, &node);
10549 vat_json_free (&node);
10551 vam->result_ready = 1;
10555 api_ipfix_exporter_dump (vat_main_t * vam)
10557 vl_api_ipfix_exporter_dump_t *mp;
10560 /* Construct the API message */
10561 M (IPFIX_EXPORTER_DUMP, mp);
10570 api_ipfix_classify_stream_dump (vat_main_t * vam)
10572 vl_api_ipfix_classify_stream_dump_t *mp;
10575 /* Construct the API message */
10576 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
10587 vl_api_ipfix_classify_stream_details_t_handler
10588 (vl_api_ipfix_classify_stream_details_t * mp)
10590 vat_main_t *vam = &vat_main;
10591 print (vam->ofp, "domain_id %d, src_port %d",
10592 ntohl (mp->domain_id), ntohs (mp->src_port));
10594 vam->result_ready = 1;
10598 vl_api_ipfix_classify_stream_details_t_handler_json
10599 (vl_api_ipfix_classify_stream_details_t * mp)
10601 vat_main_t *vam = &vat_main;
10602 vat_json_node_t node;
10604 vat_json_init_object (&node);
10605 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
10606 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
10608 vat_json_print (vam->ofp, &node);
10609 vat_json_free (&node);
10611 vam->result_ready = 1;
10615 api_ipfix_classify_table_dump (vat_main_t * vam)
10617 vl_api_ipfix_classify_table_dump_t *mp;
10618 vl_api_control_ping_t *mp_ping;
10621 if (!vam->json_output)
10623 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
10624 "transport_protocol");
10627 /* Construct the API message */
10628 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
10633 /* Use a control ping for synchronization */
10634 MPING (CONTROL_PING, mp_ping);
10642 vl_api_ipfix_classify_table_details_t_handler
10643 (vl_api_ipfix_classify_table_details_t * mp)
10645 vat_main_t *vam = &vat_main;
10646 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
10647 mp->transport_protocol);
10651 vl_api_ipfix_classify_table_details_t_handler_json
10652 (vl_api_ipfix_classify_table_details_t * mp)
10654 vat_json_node_t *node = NULL;
10655 vat_main_t *vam = &vat_main;
10657 if (VAT_JSON_ARRAY != vam->json_tree.type)
10659 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10660 vat_json_init_array (&vam->json_tree);
10663 node = vat_json_array_add (&vam->json_tree);
10664 vat_json_init_object (node);
10666 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
10667 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
10668 vat_json_object_add_uint (node, "transport_protocol",
10669 mp->transport_protocol);
10673 api_sw_interface_span_enable_disable (vat_main_t * vam)
10675 unformat_input_t *i = vam->input;
10676 vl_api_sw_interface_span_enable_disable_t *mp;
10677 u32 src_sw_if_index = ~0;
10678 u32 dst_sw_if_index = ~0;
10683 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10686 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
10688 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
10692 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
10694 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
10696 else if (unformat (i, "disable"))
10698 else if (unformat (i, "rx"))
10700 else if (unformat (i, "tx"))
10702 else if (unformat (i, "both"))
10704 else if (unformat (i, "l2"))
10710 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
10712 mp->sw_if_index_from = htonl (src_sw_if_index);
10713 mp->sw_if_index_to = htonl (dst_sw_if_index);
10723 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
10726 vat_main_t *vam = &vat_main;
10727 u8 *sw_if_from_name = 0;
10728 u8 *sw_if_to_name = 0;
10729 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
10730 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
10731 char *states[] = { "none", "rx", "tx", "both" };
10735 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
10737 if ((u32) p->value[0] == sw_if_index_from)
10739 sw_if_from_name = (u8 *)(p->key);
10743 if ((u32) p->value[0] == sw_if_index_to)
10745 sw_if_to_name = (u8 *)(p->key);
10746 if (sw_if_from_name)
10751 print (vam->ofp, "%20s => %20s (%s) %s",
10752 sw_if_from_name, sw_if_to_name, states[mp->state],
10753 mp->is_l2 ? "l2" : "device");
10757 vl_api_sw_interface_span_details_t_handler_json
10758 (vl_api_sw_interface_span_details_t * mp)
10760 vat_main_t *vam = &vat_main;
10761 vat_json_node_t *node = NULL;
10762 u8 *sw_if_from_name = 0;
10763 u8 *sw_if_to_name = 0;
10764 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
10765 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
10769 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
10771 if ((u32) p->value[0] == sw_if_index_from)
10773 sw_if_from_name = (u8 *)(p->key);
10777 if ((u32) p->value[0] == sw_if_index_to)
10779 sw_if_to_name = (u8 *)(p->key);
10780 if (sw_if_from_name)
10786 if (VAT_JSON_ARRAY != vam->json_tree.type)
10788 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10789 vat_json_init_array (&vam->json_tree);
10791 node = vat_json_array_add (&vam->json_tree);
10793 vat_json_init_object (node);
10794 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
10795 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
10796 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
10797 if (0 != sw_if_to_name)
10799 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
10801 vat_json_object_add_uint (node, "state", mp->state);
10802 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
10806 api_sw_interface_span_dump (vat_main_t * vam)
10808 unformat_input_t *input = vam->input;
10809 vl_api_sw_interface_span_dump_t *mp;
10810 vl_api_control_ping_t *mp_ping;
10814 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10816 if (unformat (input, "l2"))
10822 M (SW_INTERFACE_SPAN_DUMP, mp);
10826 /* Use a control ping for synchronization */
10827 MPING (CONTROL_PING, mp_ping);
10835 api_pg_create_interface (vat_main_t * vam)
10837 unformat_input_t *input = vam->input;
10838 vl_api_pg_create_interface_t *mp;
10840 u32 if_id = ~0, gso_size = 0;
10841 u8 gso_enabled = 0;
10843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10845 if (unformat (input, "if_id %d", &if_id))
10847 else if (unformat (input, "gso-enabled"))
10850 if (unformat (input, "gso-size %u", &gso_size))
10854 errmsg ("missing gso-size");
10863 errmsg ("missing pg interface index");
10867 /* Construct the API message */
10868 M (PG_CREATE_INTERFACE, mp);
10870 mp->interface_id = ntohl (if_id);
10871 mp->gso_enabled = gso_enabled;
10879 api_pg_capture (vat_main_t * vam)
10881 unformat_input_t *input = vam->input;
10882 vl_api_pg_capture_t *mp;
10887 u8 pcap_file_set = 0;
10890 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10892 if (unformat (input, "if_id %d", &if_id))
10894 else if (unformat (input, "pcap %s", &pcap_file))
10896 else if (unformat (input, "count %d", &count))
10898 else if (unformat (input, "disable"))
10905 errmsg ("missing pg interface index");
10908 if (pcap_file_set > 0)
10910 if (vec_len (pcap_file) > 255)
10912 errmsg ("pcap file name is too long");
10917 /* Construct the API message */
10918 M (PG_CAPTURE, mp);
10920 mp->interface_id = ntohl (if_id);
10921 mp->is_enabled = enable;
10922 mp->count = ntohl (count);
10923 if (pcap_file_set != 0)
10925 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
10927 vec_free (pcap_file);
10935 api_pg_enable_disable (vat_main_t * vam)
10937 unformat_input_t *input = vam->input;
10938 vl_api_pg_enable_disable_t *mp;
10941 u8 stream_name_set = 0;
10942 u8 *stream_name = 0;
10944 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10946 if (unformat (input, "stream %s", &stream_name))
10947 stream_name_set = 1;
10948 else if (unformat (input, "disable"))
10954 if (stream_name_set > 0)
10956 if (vec_len (stream_name) > 255)
10958 errmsg ("stream name too long");
10963 /* Construct the API message */
10964 M (PG_ENABLE_DISABLE, mp);
10966 mp->is_enabled = enable;
10967 if (stream_name_set != 0)
10969 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
10971 vec_free (stream_name);
10979 api_pg_interface_enable_disable_coalesce (vat_main_t * vam)
10981 unformat_input_t *input = vam->input;
10982 vl_api_pg_interface_enable_disable_coalesce_t *mp;
10984 u32 sw_if_index = ~0;
10987 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10989 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10991 else if (unformat (input, "sw_if_index %d", &sw_if_index))
10993 else if (unformat (input, "disable"))
10999 if (sw_if_index == ~0)
11001 errmsg ("Interface required but not specified");
11005 /* Construct the API message */
11006 M (PG_INTERFACE_ENABLE_DISABLE_COALESCE, mp);
11008 mp->coalesce_enabled = enable;
11009 mp->sw_if_index = htonl (sw_if_index);
11017 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
11019 unformat_input_t *input = vam->input;
11020 vl_api_ip_source_and_port_range_check_add_del_t *mp;
11022 u16 *low_ports = 0;
11023 u16 *high_ports = 0;
11026 vl_api_prefix_t prefix;
11033 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11035 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
11037 else if (unformat (input, "vrf %d", &vrf_id))
11039 else if (unformat (input, "del"))
11041 else if (unformat (input, "port %d", &tmp))
11043 if (tmp == 0 || tmp > 65535)
11045 errmsg ("port %d out of range", tmp);
11049 this_hi = this_low + 1;
11050 vec_add1 (low_ports, this_low);
11051 vec_add1 (high_ports, this_hi);
11053 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
11055 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
11057 errmsg ("incorrect range parameters");
11061 /* Note: in debug CLI +1 is added to high before
11062 passing to real fn that does "the work"
11063 (ip_source_and_port_range_check_add_del).
11064 This fn is a wrapper around the binary API fn a
11065 control plane will call, which expects this increment
11066 to have occurred. Hence letting the binary API control
11067 plane fn do the increment for consistency between VAT
11068 and other control planes.
11071 vec_add1 (low_ports, this_low);
11072 vec_add1 (high_ports, this_hi);
11078 if (prefix_set == 0)
11080 errmsg ("<address>/<mask> not specified");
11086 errmsg ("VRF ID required, not specified");
11093 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
11097 if (vec_len (low_ports) == 0)
11099 errmsg ("At least one port or port range required");
11103 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
11105 mp->is_add = is_add;
11107 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
11109 mp->number_of_ranges = vec_len (low_ports);
11111 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
11112 vec_free (low_ports);
11114 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
11115 vec_free (high_ports);
11117 mp->vrf_id = ntohl (vrf_id);
11125 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
11127 unformat_input_t *input = vam->input;
11128 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
11129 u32 sw_if_index = ~0;
11131 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
11132 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
11136 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11138 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11140 else if (unformat (input, "sw_if_index %d", &sw_if_index))
11142 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
11144 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
11146 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
11148 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
11150 else if (unformat (input, "del"))
11156 if (sw_if_index == ~0)
11158 errmsg ("Interface required but not specified");
11164 errmsg ("VRF ID required but not specified");
11168 if (tcp_out_vrf_id == 0
11169 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
11172 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
11176 /* Construct the API message */
11177 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
11179 mp->sw_if_index = ntohl (sw_if_index);
11180 mp->is_add = is_add;
11181 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
11182 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
11183 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
11184 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
11189 /* Wait for a reply... */
11195 api_set_punt (vat_main_t * vam)
11197 unformat_input_t *i = vam->input;
11198 vl_api_address_family_t af;
11199 vl_api_set_punt_t *mp;
11205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11207 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
11209 else if (unformat (i, "protocol %d", &protocol))
11211 else if (unformat (i, "port %d", &port))
11213 else if (unformat (i, "del"))
11217 clib_warning ("parse error '%U'", format_unformat_error, i);
11224 mp->is_add = (u8) is_add;
11225 mp->punt.type = PUNT_API_TYPE_L4;
11226 mp->punt.punt.l4.af = af;
11227 mp->punt.punt.l4.protocol = (u8) protocol;
11228 mp->punt.punt.l4.port = htons ((u16) port);
11236 api_delete_subif (vat_main_t * vam)
11238 unformat_input_t *i = vam->input;
11239 vl_api_delete_subif_t *mp;
11240 u32 sw_if_index = ~0;
11243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11245 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11247 if (unformat (i, "sw_if_index %d", &sw_if_index))
11253 if (sw_if_index == ~0)
11255 errmsg ("missing sw_if_index");
11259 /* Construct the API message */
11260 M (DELETE_SUBIF, mp);
11261 mp->sw_if_index = ntohl (sw_if_index);
11268 #define foreach_pbb_vtr_op \
11269 _("disable", L2_VTR_DISABLED) \
11270 _("pop", L2_VTR_POP_2) \
11271 _("push", L2_VTR_PUSH_2)
11274 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
11276 unformat_input_t *i = vam->input;
11277 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
11278 u32 sw_if_index = ~0, vtr_op = ~0;
11279 u16 outer_tag = ~0;
11280 u8 dmac[6], smac[6];
11281 u8 dmac_set = 0, smac_set = 0;
11287 /* Shut up coverity */
11288 clib_memset (dmac, 0, sizeof (dmac));
11289 clib_memset (smac, 0, sizeof (smac));
11291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11293 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11295 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11297 else if (unformat (i, "vtr_op %d", &vtr_op))
11299 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
11302 else if (unformat (i, "translate_pbb_stag"))
11304 if (unformat (i, "%d", &tmp))
11306 vtr_op = L2_VTR_TRANSLATE_2_1;
11312 ("translate_pbb_stag operation requires outer tag definition");
11316 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
11318 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
11320 else if (unformat (i, "sid %d", &sid))
11322 else if (unformat (i, "vlanid %d", &tmp))
11326 clib_warning ("parse error '%U'", format_unformat_error, i);
11331 if ((sw_if_index == ~0) || (vtr_op == ~0))
11333 errmsg ("missing sw_if_index or vtr operation");
11336 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
11337 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
11340 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
11344 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
11345 mp->sw_if_index = ntohl (sw_if_index);
11346 mp->vtr_op = ntohl (vtr_op);
11347 mp->outer_tag = ntohs (outer_tag);
11348 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
11349 clib_memcpy (mp->b_smac, smac, sizeof (smac));
11350 mp->b_vlanid = ntohs (vlanid);
11351 mp->i_sid = ntohl (sid);
11359 api_feature_enable_disable (vat_main_t * vam)
11361 unformat_input_t *i = vam->input;
11362 vl_api_feature_enable_disable_t *mp;
11364 u8 *feature_name = 0;
11365 u32 sw_if_index = ~0;
11369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11371 if (unformat (i, "arc_name %s", &arc_name))
11373 else if (unformat (i, "feature_name %s", &feature_name))
11376 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11378 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11380 else if (unformat (i, "disable"))
11388 errmsg ("missing arc name");
11391 if (vec_len (arc_name) > 63)
11393 errmsg ("arc name too long");
11396 if (feature_name == 0)
11398 errmsg ("missing feature name");
11401 if (vec_len (feature_name) > 63)
11403 errmsg ("feature name too long");
11406 if (sw_if_index == ~0)
11408 errmsg ("missing interface name or sw_if_index");
11412 /* Construct the API message */
11413 M (FEATURE_ENABLE_DISABLE, mp);
11414 mp->sw_if_index = ntohl (sw_if_index);
11415 mp->enable = enable;
11416 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
11417 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
11418 vec_free (arc_name);
11419 vec_free (feature_name);
11427 api_sw_interface_tag_add_del (vat_main_t * vam)
11429 unformat_input_t *i = vam->input;
11430 vl_api_sw_interface_tag_add_del_t *mp;
11431 u32 sw_if_index = ~0;
11436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11438 if (unformat (i, "tag %s", &tag))
11440 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11442 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11444 else if (unformat (i, "del"))
11450 if (sw_if_index == ~0)
11452 errmsg ("missing interface name or sw_if_index");
11456 if (enable && (tag == 0))
11458 errmsg ("no tag specified");
11462 /* Construct the API message */
11463 M (SW_INTERFACE_TAG_ADD_DEL, mp);
11464 mp->sw_if_index = ntohl (sw_if_index);
11465 mp->is_add = enable;
11467 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11476 api_sw_interface_add_del_mac_address (vat_main_t * vam)
11478 unformat_input_t *i = vam->input;
11479 vl_api_mac_address_t mac = { 0 };
11480 vl_api_sw_interface_add_del_mac_address_t *mp;
11481 u32 sw_if_index = ~0;
11486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11488 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11490 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11492 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
11494 else if (unformat (i, "del"))
11500 if (sw_if_index == ~0)
11502 errmsg ("missing interface name or sw_if_index");
11508 errmsg ("missing MAC address");
11512 /* Construct the API message */
11513 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
11514 mp->sw_if_index = ntohl (sw_if_index);
11515 mp->is_add = is_add;
11516 clib_memcpy (&mp->addr, &mac, sizeof (mac));
11523 static void vl_api_l2_xconnect_details_t_handler
11524 (vl_api_l2_xconnect_details_t * mp)
11526 vat_main_t *vam = &vat_main;
11528 print (vam->ofp, "%15d%15d",
11529 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
11532 static void vl_api_l2_xconnect_details_t_handler_json
11533 (vl_api_l2_xconnect_details_t * mp)
11535 vat_main_t *vam = &vat_main;
11536 vat_json_node_t *node = NULL;
11538 if (VAT_JSON_ARRAY != vam->json_tree.type)
11540 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11541 vat_json_init_array (&vam->json_tree);
11543 node = vat_json_array_add (&vam->json_tree);
11545 vat_json_init_object (node);
11546 vat_json_object_add_uint (node, "rx_sw_if_index",
11547 ntohl (mp->rx_sw_if_index));
11548 vat_json_object_add_uint (node, "tx_sw_if_index",
11549 ntohl (mp->tx_sw_if_index));
11553 api_l2_xconnect_dump (vat_main_t * vam)
11555 vl_api_l2_xconnect_dump_t *mp;
11556 vl_api_control_ping_t *mp_ping;
11559 if (!vam->json_output)
11561 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
11564 M (L2_XCONNECT_DUMP, mp);
11568 /* Use a control ping for synchronization */
11569 MPING (CONTROL_PING, mp_ping);
11577 api_hw_interface_set_mtu (vat_main_t * vam)
11579 unformat_input_t *i = vam->input;
11580 vl_api_hw_interface_set_mtu_t *mp;
11581 u32 sw_if_index = ~0;
11585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11587 if (unformat (i, "mtu %d", &mtu))
11589 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11591 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11597 if (sw_if_index == ~0)
11599 errmsg ("missing interface name or sw_if_index");
11605 errmsg ("no mtu specified");
11609 /* Construct the API message */
11610 M (HW_INTERFACE_SET_MTU, mp);
11611 mp->sw_if_index = ntohl (sw_if_index);
11612 mp->mtu = ntohs ((u16) mtu);
11620 api_p2p_ethernet_add (vat_main_t * vam)
11622 unformat_input_t *i = vam->input;
11623 vl_api_p2p_ethernet_add_t *mp;
11624 u32 parent_if_index = ~0;
11630 clib_memset (remote_mac, 0, sizeof (remote_mac));
11631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11633 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
11635 else if (unformat (i, "sw_if_index %d", &parent_if_index))
11639 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
11641 else if (unformat (i, "sub_id %d", &sub_id))
11645 clib_warning ("parse error '%U'", format_unformat_error, i);
11650 if (parent_if_index == ~0)
11652 errmsg ("missing interface name or sw_if_index");
11657 errmsg ("missing remote mac address");
11662 errmsg ("missing sub-interface id");
11666 M (P2P_ETHERNET_ADD, mp);
11667 mp->parent_if_index = ntohl (parent_if_index);
11668 mp->subif_id = ntohl (sub_id);
11669 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
11677 api_p2p_ethernet_del (vat_main_t * vam)
11679 unformat_input_t *i = vam->input;
11680 vl_api_p2p_ethernet_del_t *mp;
11681 u32 parent_if_index = ~0;
11686 clib_memset (remote_mac, 0, sizeof (remote_mac));
11687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11689 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
11691 else if (unformat (i, "sw_if_index %d", &parent_if_index))
11695 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
11699 clib_warning ("parse error '%U'", format_unformat_error, i);
11704 if (parent_if_index == ~0)
11706 errmsg ("missing interface name or sw_if_index");
11711 errmsg ("missing remote mac address");
11715 M (P2P_ETHERNET_DEL, mp);
11716 mp->parent_if_index = ntohl (parent_if_index);
11717 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
11725 api_tcp_configure_src_addresses (vat_main_t * vam)
11727 vl_api_tcp_configure_src_addresses_t *mp;
11728 unformat_input_t *i = vam->input;
11729 vl_api_address_t first, last;
11734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11736 if (unformat (i, "%U - %U",
11737 unformat_vl_api_address, &first,
11738 unformat_vl_api_address, &last))
11742 errmsg ("one range per message (range already set)");
11747 else if (unformat (i, "vrf %d", &vrf_id))
11753 if (range_set == 0)
11755 errmsg ("address range not set");
11759 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
11761 mp->vrf_id = ntohl (vrf_id);
11762 clib_memcpy (&mp->first_address, &first, sizeof (first));
11763 clib_memcpy (&mp->last_address, &last, sizeof (last));
11770 static void vl_api_app_namespace_add_del_reply_t_handler
11771 (vl_api_app_namespace_add_del_reply_t * mp)
11773 vat_main_t *vam = &vat_main;
11774 i32 retval = ntohl (mp->retval);
11775 if (vam->async_mode)
11777 vam->async_errors += (retval < 0);
11781 vam->retval = retval;
11783 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
11784 vam->result_ready = 1;
11788 static void vl_api_app_namespace_add_del_reply_t_handler_json
11789 (vl_api_app_namespace_add_del_reply_t * mp)
11791 vat_main_t *vam = &vat_main;
11792 vat_json_node_t node;
11794 vat_json_init_object (&node);
11795 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11796 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
11798 vat_json_print (vam->ofp, &node);
11799 vat_json_free (&node);
11801 vam->retval = ntohl (mp->retval);
11802 vam->result_ready = 1;
11806 api_app_namespace_add_del (vat_main_t * vam)
11808 vl_api_app_namespace_add_del_t *mp;
11809 unformat_input_t *i = vam->input;
11810 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
11811 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
11815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11817 if (unformat (i, "id %_%v%_", &ns_id))
11819 else if (unformat (i, "secret %lu", &secret))
11821 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11822 sw_if_index_set = 1;
11823 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
11825 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
11830 if (!ns_id || !secret_set || !sw_if_index_set)
11832 errmsg ("namespace id, secret and sw_if_index must be set");
11835 if (vec_len (ns_id) > 64)
11837 errmsg ("namespace id too long");
11840 M (APP_NAMESPACE_ADD_DEL, mp);
11842 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
11843 mp->secret = clib_host_to_net_u64 (secret);
11844 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
11845 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
11846 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
11854 api_sock_init_shm (vat_main_t * vam)
11856 #if VPP_API_TEST_BUILTIN == 0
11857 unformat_input_t *i = vam->input;
11858 vl_api_shm_elem_config_t *config = 0;
11859 u64 size = 64 << 20;
11862 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11864 if (unformat (i, "size %U", unformat_memory_size, &size))
11871 * Canned custom ring allocator config.
11872 * Should probably parse all of this
11874 vec_validate (config, 6);
11875 config[0].type = VL_API_VLIB_RING;
11876 config[0].size = 256;
11877 config[0].count = 32;
11879 config[1].type = VL_API_VLIB_RING;
11880 config[1].size = 1024;
11881 config[1].count = 16;
11883 config[2].type = VL_API_VLIB_RING;
11884 config[2].size = 4096;
11885 config[2].count = 2;
11887 config[3].type = VL_API_CLIENT_RING;
11888 config[3].size = 256;
11889 config[3].count = 32;
11891 config[4].type = VL_API_CLIENT_RING;
11892 config[4].size = 1024;
11893 config[4].count = 16;
11895 config[5].type = VL_API_CLIENT_RING;
11896 config[5].size = 4096;
11897 config[5].count = 2;
11899 config[6].type = VL_API_QUEUE;
11900 config[6].count = 128;
11901 config[6].size = sizeof (uword);
11903 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
11905 vam->client_index_invalid = 1;
11913 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
11915 vat_main_t *vam = &vat_main;
11916 fib_prefix_t lcl, rmt;
11918 ip_prefix_decode (&mp->lcl, &lcl);
11919 ip_prefix_decode (&mp->rmt, &rmt);
11921 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
11924 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
11925 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
11926 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
11927 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
11928 &rmt.fp_addr.ip4, rmt.fp_len,
11929 clib_net_to_host_u16 (mp->rmt_port),
11930 clib_net_to_host_u32 (mp->action_index), mp->tag);
11935 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
11936 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
11937 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
11938 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
11939 &rmt.fp_addr.ip6, rmt.fp_len,
11940 clib_net_to_host_u16 (mp->rmt_port),
11941 clib_net_to_host_u32 (mp->action_index), mp->tag);
11946 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
11949 vat_main_t *vam = &vat_main;
11950 vat_json_node_t *node = NULL;
11951 struct in6_addr ip6;
11952 struct in_addr ip4;
11954 fib_prefix_t lcl, rmt;
11956 ip_prefix_decode (&mp->lcl, &lcl);
11957 ip_prefix_decode (&mp->rmt, &rmt);
11959 if (VAT_JSON_ARRAY != vam->json_tree.type)
11961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11962 vat_json_init_array (&vam->json_tree);
11964 node = vat_json_array_add (&vam->json_tree);
11965 vat_json_init_object (node);
11967 vat_json_object_add_uint (node, "appns_index",
11968 clib_net_to_host_u32 (mp->appns_index));
11969 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
11970 vat_json_object_add_uint (node, "scope", mp->scope);
11971 vat_json_object_add_uint (node, "action_index",
11972 clib_net_to_host_u32 (mp->action_index));
11973 vat_json_object_add_uint (node, "lcl_port",
11974 clib_net_to_host_u16 (mp->lcl_port));
11975 vat_json_object_add_uint (node, "rmt_port",
11976 clib_net_to_host_u16 (mp->rmt_port));
11977 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
11978 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
11979 vat_json_object_add_string_copy (node, "tag", mp->tag);
11980 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
11982 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
11983 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
11984 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
11985 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
11989 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
11990 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
11991 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
11992 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
11997 api_session_rule_add_del (vat_main_t * vam)
11999 vl_api_session_rule_add_del_t *mp;
12000 unformat_input_t *i = vam->input;
12001 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
12002 u32 appns_index = 0, scope = 0;
12003 ip4_address_t lcl_ip4, rmt_ip4;
12004 ip6_address_t lcl_ip6, rmt_ip6;
12005 u8 is_ip4 = 1, conn_set = 0;
12006 u8 is_add = 1, *tag = 0;
12008 fib_prefix_t lcl, rmt;
12010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12012 if (unformat (i, "del"))
12014 else if (unformat (i, "add"))
12016 else if (unformat (i, "proto tcp"))
12018 else if (unformat (i, "proto udp"))
12020 else if (unformat (i, "appns %d", &appns_index))
12022 else if (unformat (i, "scope %d", &scope))
12024 else if (unformat (i, "tag %_%v%_", &tag))
12028 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
12029 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
12037 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
12038 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
12044 else if (unformat (i, "action %d", &action))
12049 if (proto == ~0 || !conn_set || action == ~0)
12051 errmsg ("transport proto, connection and action must be set");
12057 errmsg ("scope should be 0-3");
12061 M (SESSION_RULE_ADD_DEL, mp);
12063 clib_memset (&lcl, 0, sizeof (lcl));
12064 clib_memset (&rmt, 0, sizeof (rmt));
12067 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
12068 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
12069 lcl.fp_len = lcl_plen;
12070 rmt.fp_len = rmt_plen;
12074 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
12075 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
12076 lcl.fp_len = lcl_plen;
12077 rmt.fp_len = rmt_plen;
12081 ip_prefix_encode (&lcl, &mp->lcl);
12082 ip_prefix_encode (&rmt, &mp->rmt);
12083 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
12084 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
12085 mp->transport_proto =
12086 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
12087 mp->action_index = clib_host_to_net_u32 (action);
12088 mp->appns_index = clib_host_to_net_u32 (appns_index);
12090 mp->is_add = is_add;
12093 clib_memcpy (mp->tag, tag, vec_len (tag));
12103 api_session_rules_dump (vat_main_t * vam)
12105 vl_api_session_rules_dump_t *mp;
12106 vl_api_control_ping_t *mp_ping;
12109 if (!vam->json_output)
12111 print (vam->ofp, "%=20s", "Session Rules");
12114 M (SESSION_RULES_DUMP, mp);
12118 /* Use a control ping for synchronization */
12119 MPING (CONTROL_PING, mp_ping);
12122 /* Wait for a reply... */
12128 api_ip_container_proxy_add_del (vat_main_t * vam)
12130 vl_api_ip_container_proxy_add_del_t *mp;
12131 unformat_input_t *i = vam->input;
12132 u32 sw_if_index = ~0;
12133 vl_api_prefix_t pfx = { };
12137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12139 if (unformat (i, "del"))
12141 else if (unformat (i, "add"))
12143 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
12145 else if (unformat (i, "sw_if_index %u", &sw_if_index))
12150 if (sw_if_index == ~0 || pfx.len == 0)
12152 errmsg ("address and sw_if_index must be set");
12156 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
12158 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
12159 mp->is_add = is_add;
12160 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
12168 api_qos_record_enable_disable (vat_main_t * vam)
12170 unformat_input_t *i = vam->input;
12171 vl_api_qos_record_enable_disable_t *mp;
12172 u32 sw_if_index, qs = 0xff;
12173 u8 sw_if_index_set = 0;
12177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12179 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12180 sw_if_index_set = 1;
12181 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12182 sw_if_index_set = 1;
12183 else if (unformat (i, "%U", unformat_qos_source, &qs))
12185 else if (unformat (i, "disable"))
12189 clib_warning ("parse error '%U'", format_unformat_error, i);
12194 if (sw_if_index_set == 0)
12196 errmsg ("missing interface name or sw_if_index");
12201 errmsg ("input location must be specified");
12205 M (QOS_RECORD_ENABLE_DISABLE, mp);
12207 mp->record.sw_if_index = ntohl (sw_if_index);
12208 mp->record.input_source = qs;
12209 mp->enable = enable;
12218 q_or_quit (vat_main_t * vam)
12220 #if VPP_API_TEST_BUILTIN == 0
12221 longjmp (vam->jump_buf, 1);
12223 return 0; /* not so much */
12227 q (vat_main_t * vam)
12229 return q_or_quit (vam);
12233 quit (vat_main_t * vam)
12235 return q_or_quit (vam);
12239 comment (vat_main_t * vam)
12245 elog_save (vat_main_t * vam)
12247 #if VPP_API_TEST_BUILTIN == 0
12248 elog_main_t *em = &vam->elog_main;
12249 unformat_input_t *i = vam->input;
12250 char *file, *chroot_file;
12251 clib_error_t *error;
12253 if (!unformat (i, "%s", &file))
12255 errmsg ("expected file name, got `%U'", format_unformat_error, i);
12259 /* It's fairly hard to get "../oopsie" through unformat; just in case */
12260 if (strstr (file, "..") || index (file, '/'))
12262 errmsg ("illegal characters in filename '%s'", file);
12266 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
12270 errmsg ("Saving %wd of %wd events to %s",
12271 elog_n_events_in_buffer (em),
12272 elog_buffer_capacity (em), chroot_file);
12274 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
12275 vec_free (chroot_file);
12278 clib_error_report (error);
12280 errmsg ("Use the vpp event loger...");
12287 elog_setup (vat_main_t * vam)
12289 #if VPP_API_TEST_BUILTIN == 0
12290 elog_main_t *em = &vam->elog_main;
12291 unformat_input_t *i = vam->input;
12292 u32 nevents = 128 << 10;
12294 (void) unformat (i, "nevents %d", &nevents);
12296 elog_init (em, nevents);
12297 vl_api_set_elog_main (em);
12298 vl_api_set_elog_trace_api_messages (1);
12299 errmsg ("Event logger initialized with %u events", nevents);
12301 errmsg ("Use the vpp event loger...");
12307 elog_enable (vat_main_t * vam)
12309 #if VPP_API_TEST_BUILTIN == 0
12310 elog_main_t *em = &vam->elog_main;
12312 elog_enable_disable (em, 1 /* enable */ );
12313 vl_api_set_elog_trace_api_messages (1);
12314 errmsg ("Event logger enabled...");
12316 errmsg ("Use the vpp event loger...");
12322 elog_disable (vat_main_t * vam)
12324 #if VPP_API_TEST_BUILTIN == 0
12325 elog_main_t *em = &vam->elog_main;
12327 elog_enable_disable (em, 0 /* enable */ );
12328 vl_api_set_elog_trace_api_messages (1);
12329 errmsg ("Event logger disabled...");
12331 errmsg ("Use the vpp event loger...");
12337 statseg (vat_main_t * vam)
12339 ssvm_private_t *ssvmp = &vam->stat_segment;
12340 ssvm_shared_header_t *shared_header = ssvmp->sh;
12341 vlib_counter_t **counters;
12342 u64 thread0_index1_packets;
12343 u64 thread0_index1_bytes;
12344 f64 vector_rate, input_rate;
12347 uword *counter_vector_by_name;
12348 if (vam->stat_segment_lockp == 0)
12350 errmsg ("Stat segment not mapped...");
12354 /* look up "/if/rx for sw_if_index 1 as a test */
12356 clib_spinlock_lock (vam->stat_segment_lockp);
12358 counter_vector_by_name = (uword *) shared_header->opaque[1];
12360 p = hash_get_mem (counter_vector_by_name, "/if/rx");
12363 clib_spinlock_unlock (vam->stat_segment_lockp);
12364 errmsg ("/if/tx not found?");
12368 /* Fish per-thread vector of combined counters from shared memory */
12369 counters = (vlib_counter_t **) p[0];
12371 if (vec_len (counters[0]) < 2)
12373 clib_spinlock_unlock (vam->stat_segment_lockp);
12374 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
12378 /* Read thread 0 sw_if_index 1 counter */
12379 thread0_index1_packets = counters[0][1].packets;
12380 thread0_index1_bytes = counters[0][1].bytes;
12382 p = hash_get_mem (counter_vector_by_name, "vector_rate");
12385 clib_spinlock_unlock (vam->stat_segment_lockp);
12386 errmsg ("vector_rate not found?");
12390 vector_rate = *(f64 *) (p[0]);
12391 p = hash_get_mem (counter_vector_by_name, "input_rate");
12394 clib_spinlock_unlock (vam->stat_segment_lockp);
12395 errmsg ("input_rate not found?");
12398 input_rate = *(f64 *) (p[0]);
12400 clib_spinlock_unlock (vam->stat_segment_lockp);
12402 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
12403 vector_rate, input_rate);
12404 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
12405 thread0_index1_packets, thread0_index1_bytes);
12411 cmd_cmp (void *a1, void *a2)
12416 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
12420 help (vat_main_t * vam)
12425 unformat_input_t *i = vam->input;
12428 if (unformat (i, "%s", &name))
12432 vec_add1 (name, 0);
12434 hs = hash_get_mem (vam->help_by_name, name);
12436 print (vam->ofp, "usage: %s %s", name, hs[0]);
12438 print (vam->ofp, "No such msg / command '%s'", name);
12443 print (vam->ofp, "Help is available for the following:");
12446 hash_foreach_pair (p, vam->function_by_name,
12448 vec_add1 (cmds, (u8 *)(p->key));
12452 vec_sort_with_function (cmds, cmd_cmp);
12454 for (j = 0; j < vec_len (cmds); j++)
12455 print (vam->ofp, "%s", cmds[j]);
12462 set (vat_main_t * vam)
12464 u8 *name = 0, *value = 0;
12465 unformat_input_t *i = vam->input;
12467 if (unformat (i, "%s", &name))
12469 /* The input buffer is a vector, not a string. */
12470 value = vec_dup (i->buffer);
12471 vec_delete (value, i->index, 0);
12472 /* Almost certainly has a trailing newline */
12473 if (value[vec_len (value) - 1] == '\n')
12474 value[vec_len (value) - 1] = 0;
12475 /* Make sure it's a proper string, one way or the other */
12476 vec_add1 (value, 0);
12477 (void) clib_macro_set_value (&vam->macro_main,
12478 (char *) name, (char *) value);
12481 errmsg ("usage: set <name> <value>");
12489 unset (vat_main_t * vam)
12493 if (unformat (vam->input, "%s", &name))
12494 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
12495 errmsg ("unset: %s wasn't set", name);
12508 macro_sort_cmp (void *a1, void *a2)
12510 macro_sort_t *s1 = a1;
12511 macro_sort_t *s2 = a2;
12513 return strcmp ((char *) (s1->name), (char *) (s2->name));
12517 dump_macro_table (vat_main_t * vam)
12519 macro_sort_t *sort_me = 0, *sm;
12524 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
12526 vec_add2 (sort_me, sm, 1);
12527 sm->name = (u8 *)(p->key);
12528 sm->value = (u8 *) (p->value[0]);
12532 vec_sort_with_function (sort_me, macro_sort_cmp);
12534 if (vec_len (sort_me))
12535 print (vam->ofp, "%-15s%s", "Name", "Value");
12537 print (vam->ofp, "The macro table is empty...");
12539 for (i = 0; i < vec_len (sort_me); i++)
12540 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
12545 dump_node_table (vat_main_t * vam)
12548 vlib_node_t *node, *next_node;
12550 if (vec_len (vam->graph_nodes) == 0)
12552 print (vam->ofp, "Node table empty, issue get_node_graph...");
12556 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
12558 node = vam->graph_nodes[0][i];
12559 print (vam->ofp, "[%d] %s", i, node->name);
12560 for (j = 0; j < vec_len (node->next_nodes); j++)
12562 if (node->next_nodes[j] != ~0)
12564 next_node = vam->graph_nodes[0][node->next_nodes[j]];
12565 print (vam->ofp, " [%d] %s", j, next_node->name);
12573 value_sort_cmp (void *a1, void *a2)
12575 name_sort_t *n1 = a1;
12576 name_sort_t *n2 = a2;
12578 if (n1->value < n2->value)
12580 if (n1->value > n2->value)
12587 dump_msg_api_table (vat_main_t * vam)
12589 api_main_t *am = vlibapi_get_main ();
12590 name_sort_t *nses = 0, *ns;
12595 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
12597 vec_add2 (nses, ns, 1);
12598 ns->name = (u8 *)(hp->key);
12599 ns->value = (u32) hp->value[0];
12603 vec_sort_with_function (nses, value_sort_cmp);
12605 for (i = 0; i < vec_len (nses); i++)
12606 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
12612 get_msg_id (vat_main_t * vam)
12617 if (unformat (vam->input, "%s", &name_and_crc))
12619 message_index = vl_msg_api_get_msg_index (name_and_crc);
12620 if (message_index == ~0)
12622 print (vam->ofp, " '%s' not found", name_and_crc);
12625 print (vam->ofp, " '%s' has message index %d",
12626 name_and_crc, message_index);
12629 errmsg ("name_and_crc required...");
12634 search_node_table (vat_main_t * vam)
12636 unformat_input_t *line_input = vam->input;
12639 vlib_node_t *node, *next_node;
12642 if (vam->graph_node_index_by_name == 0)
12644 print (vam->ofp, "Node table empty, issue get_node_graph...");
12648 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12650 if (unformat (line_input, "%s", &node_to_find))
12652 vec_add1 (node_to_find, 0);
12653 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
12656 print (vam->ofp, "%s not found...", node_to_find);
12659 node = vam->graph_nodes[0][p[0]];
12660 print (vam->ofp, "[%d] %s", p[0], node->name);
12661 for (j = 0; j < vec_len (node->next_nodes); j++)
12663 if (node->next_nodes[j] != ~0)
12665 next_node = vam->graph_nodes[0][node->next_nodes[j]];
12666 print (vam->ofp, " [%d] %s", j, next_node->name);
12673 clib_warning ("parse error '%U'", format_unformat_error,
12679 vec_free (node_to_find);
12688 script (vat_main_t * vam)
12690 #if (VPP_API_TEST_BUILTIN==0)
12692 char *save_current_file;
12693 unformat_input_t save_input;
12694 jmp_buf save_jump_buf;
12695 u32 save_line_number;
12697 FILE *new_fp, *save_ifp;
12699 if (unformat (vam->input, "%s", &s))
12701 new_fp = fopen ((char *) s, "r");
12704 errmsg ("Couldn't open script file %s", s);
12711 errmsg ("Missing script name");
12715 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
12716 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
12717 save_ifp = vam->ifp;
12718 save_line_number = vam->input_line_number;
12719 save_current_file = (char *) vam->current_file;
12721 vam->input_line_number = 0;
12723 vam->current_file = s;
12726 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
12727 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
12728 vam->ifp = save_ifp;
12729 vam->input_line_number = save_line_number;
12730 vam->current_file = (u8 *) save_current_file;
12735 clib_warning ("use the exec command...");
12741 echo (vat_main_t * vam)
12743 print (vam->ofp, "%v", vam->input->buffer);
12747 /* List of API message constructors, CLI names map to api_xxx */
12748 #define foreach_vpe_api_msg \
12749 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
12750 _(sw_interface_dump,"") \
12751 _(sw_interface_set_flags, \
12752 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
12753 _(sw_interface_add_del_address, \
12754 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
12755 _(sw_interface_set_rx_mode, \
12756 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
12757 _(sw_interface_set_rx_placement, \
12758 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
12759 _(sw_interface_rx_placement_dump, \
12760 "[<intfc> | sw_if_index <id>]") \
12761 _(sw_interface_set_table, \
12762 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
12763 _(sw_interface_set_mpls_enable, \
12764 "<intfc> | sw_if_index [disable | dis]") \
12765 _(sw_interface_set_vpath, \
12766 "<intfc> | sw_if_index <id> enable | disable") \
12767 _(sw_interface_set_l2_xconnect, \
12768 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12769 "enable | disable") \
12770 _(sw_interface_set_l2_bridge, \
12771 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
12772 "[shg <split-horizon-group>] [bvi]\n" \
12773 "enable | disable") \
12774 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
12775 _(bridge_domain_add_del, \
12776 "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 <text>] [del]\n") \
12777 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
12779 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
12780 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
12781 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
12783 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
12785 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
12787 "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload | gro-coalesce] [persist] [attach] [tun] [packed] [in-order]") \
12789 "<vpp-if-name> | sw_if_index <id>") \
12790 _(sw_interface_tap_v2_dump, "") \
12791 _(virtio_pci_create_v2, \
12792 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled [gro-coalesce] | csum-offload-enabled] [packed] [in-order] [buffering]") \
12793 _(virtio_pci_delete, \
12794 "<vpp-if-name> | sw_if_index <id>") \
12795 _(sw_interface_virtio_pci_dump, "") \
12797 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
12798 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
12801 "[hw-addr <mac-addr>] {mode round-robin | active-backup | " \
12802 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
12803 "[id <if-id>] [gso]") \
12805 "<vpp-if-name> | sw_if_index <id>") \
12806 _(bond_add_member, \
12807 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
12808 _(bond_detach_member, \
12809 "sw_if_index <n>") \
12810 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
12811 _(sw_bond_interface_dump, "<intfc> | sw_if_index <nn>") \
12812 _(sw_member_interface_dump, \
12813 "<vpp-if-name> | sw_if_index <id>") \
12814 _(ip_table_add_del, \
12815 "table <n> [ipv6] [add | del]\n") \
12816 _(ip_route_add_del, \
12817 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
12818 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
12819 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
12820 "[multipath] [count <n>] [del]") \
12821 _(ip_mroute_add_del, \
12822 "<src> <grp>/<mask> [table-id <n>]\n" \
12823 "[<intfc> | sw_if_index <id>] [local] [del]") \
12824 _(mpls_table_add_del, \
12825 "table <n> [add | del]\n") \
12826 _(mpls_route_add_del, \
12827 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
12828 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
12829 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
12830 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
12831 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
12832 "[count <n>] [del]") \
12833 _(mpls_ip_bind_unbind, \
12834 "<label> <addr/len>") \
12835 _(mpls_tunnel_add_del, \
12836 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
12837 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
12838 "[l2-only] [out-label <n>]") \
12839 _(sr_mpls_policy_add, \
12840 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
12841 _(sr_mpls_policy_del, \
12843 _(sw_interface_set_unnumbered, \
12844 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
12845 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
12846 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
12847 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
12848 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
12849 "[outer_vlan_id_any][inner_vlan_id_any]") \
12850 _(ip_table_replace_begin, "table <n> [ipv6]") \
12851 _(ip_table_flush, "table <n> [ipv6]") \
12852 _(ip_table_replace_end, "table <n> [ipv6]") \
12853 _(set_ip_flow_hash, \
12854 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
12855 _(sw_interface_ip6_enable_disable, \
12856 "<intfc> | sw_if_index <id> enable | disable") \
12857 _(l2_patch_add_del, \
12858 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12859 "enable | disable") \
12860 _(sr_localsid_add_del, \
12861 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
12862 "fib-table <num> (end.psp) sw_if_index <num>") \
12863 _(get_node_index, "node <node-name") \
12864 _(add_node_next, "node <node-name> next <next-node-name>") \
12865 _(l2_fib_clear_table, "") \
12866 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
12867 _(l2_interface_vlan_tag_rewrite, \
12868 "<intfc> | sw_if_index <nn> \n" \
12869 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
12870 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
12871 _(create_vhost_user_if, \
12872 "socket <filename> [server] [renumber <dev_instance>] " \
12873 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
12874 "[mac <mac_address>] [packed]") \
12875 _(modify_vhost_user_if, \
12876 "<intfc> | sw_if_index <nn> socket <filename>\n" \
12877 "[server] [renumber <dev_instance>] [gso] [packed]") \
12878 _(create_vhost_user_if_v2, \
12879 "socket <filename> [server] [renumber <dev_instance>] " \
12880 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
12881 "[mac <mac_address>] [packed] [event-idx]") \
12882 _(modify_vhost_user_if_v2, \
12883 "<intfc> | sw_if_index <nn> socket <filename>\n" \
12884 "[server] [renumber <dev_instance>] [gso] [packed] [event-idx]")\
12885 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
12886 _(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
12887 _(show_version, "") \
12888 _(show_threads, "") \
12889 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
12890 _(interface_name_renumber, \
12891 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
12892 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
12893 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
12894 _(ip_dump, "ipv4 | ipv6") \
12895 _(ipsec_spd_add_del, "spd_id <n> [del]") \
12896 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
12898 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
12899 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
12900 " integ_alg <alg> integ_key <hex>") \
12901 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
12902 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
12903 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
12904 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
12905 _(ipsec_sa_dump, "[sa_id <n>]") \
12906 _(delete_loopback,"sw_if_index <nn>") \
12907 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
12908 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
12909 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
12910 _(want_interface_events, "enable|disable") \
12911 _(get_first_msg_id, "client <name>") \
12912 _(get_node_graph, " ") \
12913 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
12914 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
12915 _(ioam_disable, "") \
12916 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
12917 _(af_packet_delete, "name <host interface name>") \
12918 _(af_packet_dump, "") \
12919 _(policer_add_del, "name <policer name> <params> [del]") \
12920 _(policer_dump, "[name <policer name>]") \
12921 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
12922 _(mpls_table_dump, "") \
12923 _(mpls_route_dump, "table-id <ID>") \
12924 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
12925 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
12926 "[template_interval <nn>] [udp_checksum]") \
12927 _(ipfix_exporter_dump, "") \
12928 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
12929 _(ipfix_classify_stream_dump, "") \
12930 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
12931 _(ipfix_classify_table_dump, "") \
12932 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
12933 _(sw_interface_span_dump, "[l2]") \
12934 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
12935 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
12936 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
12937 _(pg_enable_disable, "[stream <id>] disable") \
12938 _(pg_interface_enable_disable_coalesce, "<intf> | sw_if_index <nn> enable | disable") \
12939 _(ip_source_and_port_range_check_add_del, \
12940 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
12941 _(ip_source_and_port_range_check_interface_add_del, \
12942 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
12943 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
12944 _(delete_subif,"<intfc> | sw_if_index <nn>") \
12945 _(l2_interface_pbb_tag_rewrite, \
12946 "<intfc> | sw_if_index <nn> \n" \
12947 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
12948 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
12949 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
12950 _(ip_table_dump, "") \
12951 _(ip_route_dump, "table-id [ip4|ip6]") \
12952 _(ip_mtable_dump, "") \
12953 _(ip_mroute_dump, "table-id [ip4|ip6]") \
12954 _(feature_enable_disable, "arc_name <arc_name> " \
12955 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
12956 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
12958 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
12959 "mac <mac-address> [del]") \
12960 _(l2_xconnect_dump, "") \
12961 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
12962 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
12963 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
12964 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
12965 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
12966 _(sock_init_shm, "size <nnn>") \
12967 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
12968 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
12969 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
12970 _(session_rules_dump, "") \
12971 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
12972 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
12974 /* List of command functions, CLI names map directly to functions */
12975 #define foreach_cli_function \
12976 _(comment, "usage: comment <ignore-rest-of-line>") \
12977 _(dump_interface_table, "usage: dump_interface_table") \
12978 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
12979 _(dump_ipv4_table, "usage: dump_ipv4_table") \
12980 _(dump_ipv6_table, "usage: dump_ipv6_table") \
12981 _(dump_macro_table, "usage: dump_macro_table ") \
12982 _(dump_node_table, "usage: dump_node_table") \
12983 _(dump_msg_api_table, "usage: dump_msg_api_table") \
12984 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
12985 _(elog_disable, "usage: elog_disable") \
12986 _(elog_enable, "usage: elog_enable") \
12987 _(elog_save, "usage: elog_save <filename>") \
12988 _(get_msg_id, "usage: get_msg_id name_and_crc") \
12989 _(echo, "usage: echo <message>") \
12990 _(exec, "usage: exec <vpe-debug-CLI-command>") \
12991 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
12992 _(help, "usage: help") \
12993 _(q, "usage: quit") \
12994 _(quit, "usage: quit") \
12995 _(search_node_table, "usage: search_node_table <name>...") \
12996 _(set, "usage: set <variable-name> <value>") \
12997 _(script, "usage: script <file-name>") \
12998 _(statseg, "usage: statseg") \
12999 _(unset, "usage: unset <variable-name>")
13002 static void vl_api_##n##_t_handler_uni \
13003 (vl_api_##n##_t * mp) \
13005 vat_main_t * vam = &vat_main; \
13006 if (vam->json_output) { \
13007 vl_api_##n##_t_handler_json(mp); \
13009 vl_api_##n##_t_handler(mp); \
13012 foreach_vpe_api_reply_msg;
13013 #if VPP_API_TEST_BUILTIN == 0
13014 foreach_standalone_reply_msg;
13019 vat_api_hookup (vat_main_t * vam)
13022 vl_msg_api_set_handlers(VL_API_##N, #n, \
13023 vl_api_##n##_t_handler_uni, \
13025 vl_api_##n##_t_endian, \
13026 vl_api_##n##_t_print, \
13027 sizeof(vl_api_##n##_t), 1);
13028 foreach_vpe_api_reply_msg;
13029 #if VPP_API_TEST_BUILTIN == 0
13030 foreach_standalone_reply_msg;
13034 #if (VPP_API_TEST_BUILTIN==0)
13035 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
13037 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
13039 vam->function_by_name = hash_create_string (0, sizeof (uword));
13041 vam->help_by_name = hash_create_string (0, sizeof (uword));
13044 /* API messages we can send */
13045 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
13046 foreach_vpe_api_msg;
13050 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
13051 foreach_vpe_api_msg;
13054 /* CLI functions */
13055 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
13056 foreach_cli_function;
13060 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
13061 foreach_cli_function;
13065 #if VPP_API_TEST_BUILTIN
13066 static clib_error_t *
13067 vat_api_hookup_shim (vlib_main_t * vm)
13069 vat_api_hookup (&vat_main);
13073 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
13077 * fd.io coding-style-patch-verification: ON
13080 * eval: (c-set-style "gnu")