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/vxlan/vxlan.h>
31 #include <vnet/gre/gre.h>
32 #include <vnet/vxlan-gpe/vxlan_gpe.h>
34 #include <vpp/api/vpe_msg_enum.h>
35 #include <vnet/l2/l2_classify.h>
36 #include <vnet/l2/l2_vtr.h>
37 #include <vnet/classify/in_out_acl.h>
38 #include <vnet/classify/policer_classify.h>
39 #include <vnet/classify/flow_classify.h>
40 #include <vnet/mpls/mpls.h>
41 #include <vnet/ipsec/ipsec.h>
43 #include <vnet/ip/ip6_hop_by_hop.h>
44 #include <vnet/ip/ip_source_and_port_range_check.h>
45 #include <vnet/policer/xlate.h>
46 #include <vnet/span/span.h>
47 #include <vnet/policer/policer.h>
48 #include <vnet/policer/police.h>
49 #include <vnet/mfib/mfib_types.h>
50 #include <vnet/bonding/node.h>
51 #include <vnet/qos/qos_types.h>
52 #include <vnet/ethernet/ethernet_types_api.h>
53 #include <vnet/ip/ip_types_api.h>
54 #include "vat/json_format.h"
55 #include <vnet/ip/ip_types_api.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
61 #define vl_typedefs /* define message structures */
62 #include <vpp/api/vpe_all_api_h.h>
65 /* declare message handlers for each api */
67 #define vl_endianfun /* define message structures */
68 #include <vpp/api/vpe_all_api_h.h>
71 /* instantiate all the print functions we know about */
72 #if VPP_API_TEST_BUILTIN == 0
73 #define vl_print(handle, ...)
75 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
78 #include <vpp/api/vpe_all_api_h.h>
81 #define __plugin_msg_base 0
82 #include <vlibapi/vat_helper_macros.h>
84 #include <vnet/format_fns.h>
86 void vl_api_set_elog_main (elog_main_t * m);
87 int vl_api_set_elog_trace_api_messages (int enable);
89 #if VPP_API_TEST_BUILTIN == 0
99 vat_socket_connect (vat_main_t * vam)
102 api_main_t *am = vlibapi_get_main ();
103 vam->socket_client_main = &socket_client_main;
104 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
106 0 /* default socket rx, tx buffer */ )))
109 /* vpp expects the client index in network order */
110 vam->my_client_index = htonl (socket_client_main.client_index);
111 am->my_client_index = vam->my_client_index;
114 #else /* vpp built-in case, we don't do sockets... */
116 vat_socket_connect (vat_main_t * vam)
122 vl_socket_client_read (int wait)
128 vl_socket_client_write ()
134 vl_socket_client_msg_alloc (int nbytes)
142 vat_time_now (vat_main_t * vam)
144 #if VPP_API_TEST_BUILTIN
145 return vlib_time_now (vam->vlib_main);
147 return clib_time_now (&vam->clib_time);
152 errmsg (char *fmt, ...)
154 vat_main_t *vam = &vat_main;
159 s = va_format (0, fmt, &va);
164 #if VPP_API_TEST_BUILTIN
165 vlib_cli_output (vam->vlib_main, (char *) s);
168 if (vam->ifp != stdin)
169 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
170 vam->input_line_number);
172 fformat (vam->ofp, "%s\n", (char *) s);
180 #if VPP_API_TEST_BUILTIN == 0
182 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
184 vat_main_t *vam = va_arg (*args, vat_main_t *);
185 u32 *result = va_arg (*args, u32 *);
189 if (!unformat (input, "%s", &if_name))
192 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
200 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
205 /* Parse an IP4 address %d.%d.%d.%d. */
207 unformat_ip4_address (unformat_input_t * input, va_list * args)
209 u8 *result = va_arg (*args, u8 *);
212 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
215 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
227 unformat_ethernet_address (unformat_input_t * input, va_list * args)
229 u8 *result = va_arg (*args, u8 *);
232 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
233 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
237 for (i = 0; i < 6; i++)
238 if (a[i] >= (1 << 8))
241 for (i = 0; i < 6; i++)
247 /* Returns ethernet type as an int in host byte order. */
249 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
252 u16 *result = va_arg (*args, u16 *);
256 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
258 if (type >= (1 << 16))
266 /* Parse an IP46 address. */
268 unformat_ip46_address (unformat_input_t * input, va_list * args)
270 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
271 ip46_type_t type = va_arg (*args, ip46_type_t);
272 if ((type != IP46_TYPE_IP6) &&
273 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
275 ip46_address_mask_ip4 (ip46);
278 else if ((type != IP46_TYPE_IP4) &&
279 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
286 /* Parse an IP6 address. */
288 unformat_ip6_address (unformat_input_t * input, va_list * args)
290 ip6_address_t *result = va_arg (*args, ip6_address_t *);
292 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
293 uword c, n_colon, double_colon_index;
295 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
296 double_colon_index = ARRAY_LEN (hex_quads);
297 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
300 if (c >= '0' && c <= '9')
302 else if (c >= 'a' && c <= 'f')
303 hex_digit = c + 10 - 'a';
304 else if (c >= 'A' && c <= 'F')
305 hex_digit = c + 10 - 'A';
306 else if (c == ':' && n_colon < 2)
310 unformat_put_input (input);
314 /* Too many hex quads. */
315 if (n_hex_quads >= ARRAY_LEN (hex_quads))
320 hex_quad = (hex_quad << 4) | hex_digit;
322 /* Hex quad must fit in 16 bits. */
323 if (n_hex_digits >= 4)
330 /* Save position of :: */
333 /* More than one :: ? */
334 if (double_colon_index < ARRAY_LEN (hex_quads))
336 double_colon_index = n_hex_quads;
339 if (n_colon > 0 && n_hex_digits > 0)
341 hex_quads[n_hex_quads++] = hex_quad;
347 if (n_hex_digits > 0)
348 hex_quads[n_hex_quads++] = hex_quad;
353 /* Expand :: to appropriate number of zero hex quads. */
354 if (double_colon_index < ARRAY_LEN (hex_quads))
356 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
358 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
359 hex_quads[n_zero + i] = hex_quads[i];
361 for (i = 0; i < n_zero; i++)
362 hex_quads[double_colon_index + i] = 0;
364 n_hex_quads = ARRAY_LEN (hex_quads);
367 /* Too few hex quads given. */
368 if (n_hex_quads < ARRAY_LEN (hex_quads))
371 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
372 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
379 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
381 u32 *r = va_arg (*args, u32 *);
384 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
385 foreach_ipsec_policy_action
393 format_ipsec_crypto_alg (u8 * s, va_list * args)
395 u32 i = va_arg (*args, u32);
400 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
401 foreach_ipsec_crypto_alg
404 return format (s, "unknown");
406 return format (s, "%s", t);
410 format_ipsec_integ_alg (u8 * s, va_list * args)
412 u32 i = va_arg (*args, u32);
417 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
418 foreach_ipsec_integ_alg
421 return format (s, "unknown");
423 return format (s, "%s", t);
426 #else /* VPP_API_TEST_BUILTIN == 1 */
428 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
430 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
431 vnet_main_t *vnm = vnet_get_main ();
432 u32 *result = va_arg (*args, u32 *);
434 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
438 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
440 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
441 vnet_main_t *vnm = vnet_get_main ();
442 u32 *result = va_arg (*args, u32 *);
444 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
447 #endif /* VPP_API_TEST_BUILTIN */
450 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
452 u32 *r = va_arg (*args, u32 *);
455 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
456 foreach_ipsec_crypto_alg
464 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
466 u32 *r = va_arg (*args, u32 *);
469 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
470 foreach_ipsec_integ_alg
478 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
480 u8 *r = va_arg (*args, u8 *);
482 if (unformat (input, "kbps"))
483 *r = SSE2_QOS_RATE_KBPS;
484 else if (unformat (input, "pps"))
485 *r = SSE2_QOS_RATE_PPS;
492 unformat_policer_round_type (unformat_input_t * input, va_list * args)
494 u8 *r = va_arg (*args, u8 *);
496 if (unformat (input, "closest"))
497 *r = SSE2_QOS_ROUND_TO_CLOSEST;
498 else if (unformat (input, "up"))
499 *r = SSE2_QOS_ROUND_TO_UP;
500 else if (unformat (input, "down"))
501 *r = SSE2_QOS_ROUND_TO_DOWN;
508 unformat_policer_type (unformat_input_t * input, va_list * args)
510 u8 *r = va_arg (*args, u8 *);
512 if (unformat (input, "1r2c"))
513 *r = SSE2_QOS_POLICER_TYPE_1R2C;
514 else if (unformat (input, "1r3c"))
515 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
516 else if (unformat (input, "2r3c-2698"))
517 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
518 else if (unformat (input, "2r3c-4115"))
519 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
520 else if (unformat (input, "2r3c-mef5cf1"))
521 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
528 unformat_dscp (unformat_input_t * input, va_list * va)
530 u8 *r = va_arg (*va, u8 *);
533 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
542 unformat_policer_action_type (unformat_input_t * input, va_list * va)
544 sse2_qos_pol_action_params_st *a
545 = va_arg (*va, sse2_qos_pol_action_params_st *);
547 if (unformat (input, "drop"))
548 a->action_type = SSE2_QOS_ACTION_DROP;
549 else if (unformat (input, "transmit"))
550 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
551 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
552 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
559 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
561 u32 *r = va_arg (*va, u32 *);
564 if (unformat (input, "ip4"))
565 tid = POLICER_CLASSIFY_TABLE_IP4;
566 else if (unformat (input, "ip6"))
567 tid = POLICER_CLASSIFY_TABLE_IP6;
568 else if (unformat (input, "l2"))
569 tid = POLICER_CLASSIFY_TABLE_L2;
578 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
580 u32 *r = va_arg (*va, u32 *);
583 if (unformat (input, "ip4"))
584 tid = FLOW_CLASSIFY_TABLE_IP4;
585 else if (unformat (input, "ip6"))
586 tid = FLOW_CLASSIFY_TABLE_IP6;
594 #if (VPP_API_TEST_BUILTIN==0)
596 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
597 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
598 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
599 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
602 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
604 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
605 mfib_itf_attribute_t attr;
608 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
610 if (unformat (input, mfib_itf_flag_long_names[attr]))
611 *iflags |= (1 << attr);
613 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
615 if (unformat (input, mfib_itf_flag_names[attr]))
616 *iflags |= (1 << attr);
619 return (old == *iflags ? 0 : 1);
623 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
625 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
626 mfib_entry_attribute_t attr;
629 FOR_EACH_MFIB_ATTRIBUTE (attr)
631 if (unformat (input, mfib_flag_long_names[attr]))
632 *eflags |= (1 << attr);
634 FOR_EACH_MFIB_ATTRIBUTE (attr)
636 if (unformat (input, mfib_flag_names[attr]))
637 *eflags |= (1 << attr);
640 return (old == *eflags ? 0 : 1);
644 format_ip4_address (u8 * s, va_list * args)
646 u8 *a = va_arg (*args, u8 *);
647 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
651 format_ip6_address (u8 * s, va_list * args)
653 ip6_address_t *a = va_arg (*args, ip6_address_t *);
654 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
656 i_max_n_zero = ARRAY_LEN (a->as_u16);
658 i_first_zero = i_max_n_zero;
660 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
662 u32 is_zero = a->as_u16[i] == 0;
663 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
669 if ((!is_zero && n_zeros > max_n_zeros)
670 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
672 i_max_n_zero = i_first_zero;
673 max_n_zeros = n_zeros;
674 i_first_zero = ARRAY_LEN (a->as_u16);
679 last_double_colon = 0;
680 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
682 if (i == i_max_n_zero && max_n_zeros > 1)
684 s = format (s, "::");
685 i += max_n_zeros - 1;
686 last_double_colon = 1;
690 s = format (s, "%s%x",
691 (last_double_colon || i == 0) ? "" : ":",
692 clib_net_to_host_u16 (a->as_u16[i]));
693 last_double_colon = 0;
700 /* Format an IP46 address. */
702 format_ip46_address (u8 * s, va_list * args)
704 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
705 ip46_type_t type = va_arg (*args, ip46_type_t);
711 is_ip4 = ip46_address_is_ip4 (ip46);
722 format (s, "%U", format_ip4_address, &ip46->ip4) :
723 format (s, "%U", format_ip6_address, &ip46->ip6);
727 format_ethernet_address (u8 * s, va_list * args)
729 u8 *a = va_arg (*args, u8 *);
731 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
732 a[0], a[1], a[2], a[3], a[4], a[5]);
737 increment_v4_address (vl_api_ip4_address_t * i)
739 ip4_address_t *a = (ip4_address_t *) i;
742 v = ntohl (a->as_u32) + 1;
743 a->as_u32 = ntohl (v);
747 increment_v6_address (vl_api_ip6_address_t * i)
749 ip6_address_t *a = (ip6_address_t *) i;
752 v0 = clib_net_to_host_u64 (a->as_u64[0]);
753 v1 = clib_net_to_host_u64 (a->as_u64[1]);
758 a->as_u64[0] = clib_net_to_host_u64 (v0);
759 a->as_u64[1] = clib_net_to_host_u64 (v1);
763 increment_address (vl_api_address_t * a)
765 if (a->af == ADDRESS_IP4)
766 increment_v4_address (&a->un.ip4);
767 else if (a->af == ADDRESS_IP6)
768 increment_v6_address (&a->un.ip6);
772 set_ip4_address (vl_api_address_t * a, u32 v)
774 if (a->af == ADDRESS_IP4)
776 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
782 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
785 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
787 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
788 sizeof (ip6_address_t));
792 increment_mac_address (u8 * mac)
794 u64 tmp = *((u64 *) mac);
795 tmp = clib_net_to_host_u64 (tmp);
796 tmp += 1 << 16; /* skip unused (least significant) octets */
797 tmp = clib_host_to_net_u64 (tmp);
799 clib_memcpy (mac, &tmp, 6);
803 vat_json_object_add_address (vat_json_node_t * node,
804 const char *str, const vl_api_address_t * addr)
806 if (ADDRESS_IP6 == addr->af)
810 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
811 vat_json_object_add_ip6 (node, str, ip6);
817 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
818 vat_json_object_add_ip4 (node, str, ip4);
823 vat_json_object_add_prefix (vat_json_node_t * node,
824 const vl_api_prefix_t * prefix)
826 vat_json_object_add_uint (node, "len", prefix->len);
827 vat_json_object_add_address (node, "address", &prefix->address);
830 static void vl_api_create_loopback_reply_t_handler
831 (vl_api_create_loopback_reply_t * mp)
833 vat_main_t *vam = &vat_main;
834 i32 retval = ntohl (mp->retval);
836 vam->retval = retval;
837 vam->regenerate_interface_table = 1;
838 vam->sw_if_index = ntohl (mp->sw_if_index);
839 vam->result_ready = 1;
842 static void vl_api_create_loopback_reply_t_handler_json
843 (vl_api_create_loopback_reply_t * mp)
845 vat_main_t *vam = &vat_main;
846 vat_json_node_t node;
848 vat_json_init_object (&node);
849 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
850 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
852 vat_json_print (vam->ofp, &node);
853 vat_json_free (&node);
854 vam->retval = ntohl (mp->retval);
855 vam->result_ready = 1;
858 static void vl_api_create_loopback_instance_reply_t_handler
859 (vl_api_create_loopback_instance_reply_t * mp)
861 vat_main_t *vam = &vat_main;
862 i32 retval = ntohl (mp->retval);
864 vam->retval = retval;
865 vam->regenerate_interface_table = 1;
866 vam->sw_if_index = ntohl (mp->sw_if_index);
867 vam->result_ready = 1;
870 static void vl_api_create_loopback_instance_reply_t_handler_json
871 (vl_api_create_loopback_instance_reply_t * mp)
873 vat_main_t *vam = &vat_main;
874 vat_json_node_t node;
876 vat_json_init_object (&node);
877 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
878 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
880 vat_json_print (vam->ofp, &node);
881 vat_json_free (&node);
882 vam->retval = ntohl (mp->retval);
883 vam->result_ready = 1;
886 static void vl_api_af_packet_create_reply_t_handler
887 (vl_api_af_packet_create_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_af_packet_create_reply_t_handler_json
899 (vl_api_af_packet_create_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_create_vlan_subif_reply_t_handler
916 (vl_api_create_vlan_subif_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->sw_if_index = ntohl (mp->sw_if_index);
924 vam->result_ready = 1;
927 static void vl_api_create_vlan_subif_reply_t_handler_json
928 (vl_api_create_vlan_subif_reply_t * mp)
930 vat_main_t *vam = &vat_main;
931 vat_json_node_t node;
933 vat_json_init_object (&node);
934 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
935 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
937 vat_json_print (vam->ofp, &node);
938 vat_json_free (&node);
940 vam->retval = ntohl (mp->retval);
941 vam->result_ready = 1;
944 static void vl_api_create_subif_reply_t_handler
945 (vl_api_create_subif_reply_t * mp)
947 vat_main_t *vam = &vat_main;
948 i32 retval = ntohl (mp->retval);
950 vam->retval = retval;
951 vam->regenerate_interface_table = 1;
952 vam->sw_if_index = ntohl (mp->sw_if_index);
953 vam->result_ready = 1;
956 static void vl_api_create_subif_reply_t_handler_json
957 (vl_api_create_subif_reply_t * mp)
959 vat_main_t *vam = &vat_main;
960 vat_json_node_t node;
962 vat_json_init_object (&node);
963 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
964 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
966 vat_json_print (vam->ofp, &node);
967 vat_json_free (&node);
969 vam->retval = ntohl (mp->retval);
970 vam->result_ready = 1;
973 static void vl_api_interface_name_renumber_reply_t_handler
974 (vl_api_interface_name_renumber_reply_t * mp)
976 vat_main_t *vam = &vat_main;
977 i32 retval = ntohl (mp->retval);
979 vam->retval = retval;
980 vam->regenerate_interface_table = 1;
981 vam->result_ready = 1;
984 static void vl_api_interface_name_renumber_reply_t_handler_json
985 (vl_api_interface_name_renumber_reply_t * mp)
987 vat_main_t *vam = &vat_main;
988 vat_json_node_t node;
990 vat_json_init_object (&node);
991 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
993 vat_json_print (vam->ofp, &node);
994 vat_json_free (&node);
996 vam->retval = ntohl (mp->retval);
997 vam->result_ready = 1;
1001 * Special-case: build the interface table, maintain
1002 * the next loopback sw_if_index vbl.
1004 static void vl_api_sw_interface_details_t_handler
1005 (vl_api_sw_interface_details_t * mp)
1007 vat_main_t *vam = &vat_main;
1008 u8 *s = format (0, "%s%c", mp->interface_name, 0);
1010 hash_set_mem (vam->sw_if_index_by_interface_name, s,
1011 ntohl (mp->sw_if_index));
1013 /* In sub interface case, fill the sub interface table entry */
1014 if (mp->sw_if_index != mp->sup_sw_if_index)
1016 sw_interface_subif_t *sub = NULL;
1018 vec_add2 (vam->sw_if_subif_table, sub, 1);
1020 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
1021 strncpy ((char *) sub->interface_name, (char *) s,
1022 vec_len (sub->interface_name));
1023 sub->sw_if_index = ntohl (mp->sw_if_index);
1024 sub->sub_id = ntohl (mp->sub_id);
1026 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
1028 sub->sub_number_of_tags = mp->sub_number_of_tags;
1029 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1030 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1032 /* vlan tag rewrite */
1033 sub->vtr_op = ntohl (mp->vtr_op);
1034 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1035 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1036 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1040 static void vl_api_sw_interface_details_t_handler_json
1041 (vl_api_sw_interface_details_t * mp)
1043 vat_main_t *vam = &vat_main;
1044 vat_json_node_t *node = NULL;
1046 if (VAT_JSON_ARRAY != vam->json_tree.type)
1048 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1049 vat_json_init_array (&vam->json_tree);
1051 node = vat_json_array_add (&vam->json_tree);
1053 vat_json_init_object (node);
1054 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1055 vat_json_object_add_uint (node, "sup_sw_if_index",
1056 ntohl (mp->sup_sw_if_index));
1057 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1058 sizeof (mp->l2_address));
1059 vat_json_object_add_string_copy (node, "interface_name",
1060 mp->interface_name);
1061 vat_json_object_add_string_copy (node, "interface_dev_type",
1062 mp->interface_dev_type);
1063 vat_json_object_add_uint (node, "flags", mp->flags);
1064 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1065 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1066 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1067 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1068 vat_json_object_add_uint (node, "sub_number_of_tags",
1069 mp->sub_number_of_tags);
1070 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1071 ntohs (mp->sub_outer_vlan_id));
1072 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1073 ntohs (mp->sub_inner_vlan_id));
1074 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1075 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1076 vat_json_object_add_uint (node, "vtr_push_dot1q",
1077 ntohl (mp->vtr_push_dot1q));
1078 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1079 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1080 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1082 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1084 format_ethernet_address,
1086 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1088 format_ethernet_address,
1090 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1091 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1095 #if VPP_API_TEST_BUILTIN == 0
1096 static void vl_api_sw_interface_event_t_handler
1097 (vl_api_sw_interface_event_t * mp)
1099 vat_main_t *vam = &vat_main;
1100 if (vam->interface_event_display)
1101 errmsg ("interface flags: sw_if_index %d %s %s",
1102 ntohl (mp->sw_if_index),
1103 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1104 "admin-up" : "admin-down",
1105 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1106 "link-up" : "link-down");
1110 __clib_unused static void
1111 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1113 /* JSON output not supported */
1117 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1119 vat_main_t *vam = &vat_main;
1120 i32 retval = ntohl (mp->retval);
1122 vam->retval = retval;
1123 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1124 vam->result_ready = 1;
1128 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1130 vat_main_t *vam = &vat_main;
1131 vat_json_node_t node;
1135 vat_json_init_object (&node);
1136 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1137 vat_json_object_add_uint (&node, "reply_in_shmem",
1138 ntohl (mp->reply_in_shmem));
1139 /* Toss the shared-memory original... */
1140 oldheap = vl_msg_push_heap ();
1142 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1145 vl_msg_pop_heap (oldheap);
1147 vat_json_print (vam->ofp, &node);
1148 vat_json_free (&node);
1150 vam->retval = ntohl (mp->retval);
1151 vam->result_ready = 1;
1155 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1157 vat_main_t *vam = &vat_main;
1158 i32 retval = ntohl (mp->retval);
1160 vec_reset_length (vam->cmd_reply);
1162 vam->retval = retval;
1164 vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1165 vam->result_ready = 1;
1169 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1171 vat_main_t *vam = &vat_main;
1172 vat_json_node_t node;
1173 u8 *reply = 0; /* reply vector */
1175 reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1176 vec_reset_length (vam->cmd_reply);
1178 vat_json_init_object (&node);
1179 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1180 vat_json_object_add_string_copy (&node, "reply", reply);
1182 vat_json_print (vam->ofp, &node);
1183 vat_json_free (&node);
1186 vam->retval = ntohl (mp->retval);
1187 vam->result_ready = 1;
1190 static void vl_api_classify_add_del_table_reply_t_handler
1191 (vl_api_classify_add_del_table_reply_t * mp)
1193 vat_main_t *vam = &vat_main;
1194 i32 retval = ntohl (mp->retval);
1195 if (vam->async_mode)
1197 vam->async_errors += (retval < 0);
1201 vam->retval = retval;
1203 ((mp->new_table_index != 0xFFFFFFFF) ||
1204 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1205 (mp->match_n_vectors != 0xFFFFFFFF)))
1207 * Note: this is just barely thread-safe, depends on
1208 * the main thread spinning waiting for an answer...
1210 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1211 ntohl (mp->new_table_index),
1212 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1213 vam->result_ready = 1;
1217 static void vl_api_classify_add_del_table_reply_t_handler_json
1218 (vl_api_classify_add_del_table_reply_t * mp)
1220 vat_main_t *vam = &vat_main;
1221 vat_json_node_t node;
1223 vat_json_init_object (&node);
1224 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1225 vat_json_object_add_uint (&node, "new_table_index",
1226 ntohl (mp->new_table_index));
1227 vat_json_object_add_uint (&node, "skip_n_vectors",
1228 ntohl (mp->skip_n_vectors));
1229 vat_json_object_add_uint (&node, "match_n_vectors",
1230 ntohl (mp->match_n_vectors));
1232 vat_json_print (vam->ofp, &node);
1233 vat_json_free (&node);
1235 vam->retval = ntohl (mp->retval);
1236 vam->result_ready = 1;
1239 static void vl_api_get_node_index_reply_t_handler
1240 (vl_api_get_node_index_reply_t * mp)
1242 vat_main_t *vam = &vat_main;
1243 i32 retval = ntohl (mp->retval);
1244 if (vam->async_mode)
1246 vam->async_errors += (retval < 0);
1250 vam->retval = retval;
1252 errmsg ("node index %d", ntohl (mp->node_index));
1253 vam->result_ready = 1;
1257 static void vl_api_get_node_index_reply_t_handler_json
1258 (vl_api_get_node_index_reply_t * mp)
1260 vat_main_t *vam = &vat_main;
1261 vat_json_node_t node;
1263 vat_json_init_object (&node);
1264 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1265 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1267 vat_json_print (vam->ofp, &node);
1268 vat_json_free (&node);
1270 vam->retval = ntohl (mp->retval);
1271 vam->result_ready = 1;
1274 static void vl_api_get_next_index_reply_t_handler
1275 (vl_api_get_next_index_reply_t * mp)
1277 vat_main_t *vam = &vat_main;
1278 i32 retval = ntohl (mp->retval);
1279 if (vam->async_mode)
1281 vam->async_errors += (retval < 0);
1285 vam->retval = retval;
1287 errmsg ("next node index %d", ntohl (mp->next_index));
1288 vam->result_ready = 1;
1292 static void vl_api_get_next_index_reply_t_handler_json
1293 (vl_api_get_next_index_reply_t * mp)
1295 vat_main_t *vam = &vat_main;
1296 vat_json_node_t node;
1298 vat_json_init_object (&node);
1299 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1300 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1302 vat_json_print (vam->ofp, &node);
1303 vat_json_free (&node);
1305 vam->retval = ntohl (mp->retval);
1306 vam->result_ready = 1;
1309 static void vl_api_add_node_next_reply_t_handler
1310 (vl_api_add_node_next_reply_t * mp)
1312 vat_main_t *vam = &vat_main;
1313 i32 retval = ntohl (mp->retval);
1314 if (vam->async_mode)
1316 vam->async_errors += (retval < 0);
1320 vam->retval = retval;
1322 errmsg ("next index %d", ntohl (mp->next_index));
1323 vam->result_ready = 1;
1327 static void vl_api_add_node_next_reply_t_handler_json
1328 (vl_api_add_node_next_reply_t * mp)
1330 vat_main_t *vam = &vat_main;
1331 vat_json_node_t node;
1333 vat_json_init_object (&node);
1334 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1335 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1337 vat_json_print (vam->ofp, &node);
1338 vat_json_free (&node);
1340 vam->retval = ntohl (mp->retval);
1341 vam->result_ready = 1;
1344 static void vl_api_show_version_reply_t_handler
1345 (vl_api_show_version_reply_t * mp)
1347 vat_main_t *vam = &vat_main;
1348 i32 retval = ntohl (mp->retval);
1352 errmsg (" program: %s", mp->program);
1353 errmsg (" version: %s", mp->version);
1354 errmsg (" build date: %s", mp->build_date);
1355 errmsg ("build directory: %s", mp->build_directory);
1357 vam->retval = retval;
1358 vam->result_ready = 1;
1361 static void vl_api_show_version_reply_t_handler_json
1362 (vl_api_show_version_reply_t * mp)
1364 vat_main_t *vam = &vat_main;
1365 vat_json_node_t node;
1367 vat_json_init_object (&node);
1368 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1369 vat_json_object_add_string_copy (&node, "program", mp->program);
1370 vat_json_object_add_string_copy (&node, "version", mp->version);
1371 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1372 vat_json_object_add_string_copy (&node, "build_directory",
1373 mp->build_directory);
1375 vat_json_print (vam->ofp, &node);
1376 vat_json_free (&node);
1378 vam->retval = ntohl (mp->retval);
1379 vam->result_ready = 1;
1382 static void vl_api_show_threads_reply_t_handler
1383 (vl_api_show_threads_reply_t * mp)
1385 vat_main_t *vam = &vat_main;
1386 i32 retval = ntohl (mp->retval);
1390 count = ntohl (mp->count);
1392 for (i = 0; i < count; i++)
1394 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1395 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1396 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1397 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1398 ntohl (mp->thread_data[i].cpu_socket));
1400 vam->retval = retval;
1401 vam->result_ready = 1;
1404 static void vl_api_show_threads_reply_t_handler_json
1405 (vl_api_show_threads_reply_t * mp)
1407 vat_main_t *vam = &vat_main;
1408 vat_json_node_t node;
1409 vl_api_thread_data_t *td;
1410 i32 retval = ntohl (mp->retval);
1414 count = ntohl (mp->count);
1416 vat_json_init_object (&node);
1417 vat_json_object_add_int (&node, "retval", retval);
1418 vat_json_object_add_uint (&node, "count", count);
1420 for (i = 0; i < count; i++)
1422 td = &mp->thread_data[i];
1423 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1424 vat_json_object_add_string_copy (&node, "name", td->name);
1425 vat_json_object_add_string_copy (&node, "type", td->type);
1426 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1427 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1428 vat_json_object_add_int (&node, "core", ntohl (td->id));
1429 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1432 vat_json_print (vam->ofp, &node);
1433 vat_json_free (&node);
1435 vam->retval = retval;
1436 vam->result_ready = 1;
1440 api_show_threads (vat_main_t * vam)
1442 vl_api_show_threads_t *mp;
1446 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1447 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1449 M (SHOW_THREADS, mp);
1457 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1459 u32 n_macs = ntohl (mp->n_macs);
1460 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1461 ntohl (mp->pid), mp->client_index, n_macs);
1463 for (i = 0; i < n_macs; i++)
1465 vl_api_mac_entry_t *mac = &mp->mac[i];
1466 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1467 i + 1, ntohl (mac->sw_if_index),
1468 format_ethernet_address, mac->mac_addr, mac->action);
1475 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1477 /* JSON output not supported */
1480 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1481 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1484 * Special-case: build the bridge domain table, maintain
1485 * the next bd id vbl.
1487 static void vl_api_bridge_domain_details_t_handler
1488 (vl_api_bridge_domain_details_t * mp)
1490 vat_main_t *vam = &vat_main;
1491 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1494 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1495 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1497 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1498 ntohl (mp->bd_id), mp->learn, mp->forward,
1499 mp->flood, ntohl (mp->bvi_sw_if_index),
1500 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1504 vl_api_bridge_domain_sw_if_t *sw_ifs;
1505 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1508 sw_ifs = mp->sw_if_details;
1509 for (i = 0; i < n_sw_ifs; i++)
1515 sw_if_index = ntohl (sw_ifs->sw_if_index);
1518 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1520 if ((u32) p->value[0] == sw_if_index)
1522 sw_if_name = (u8 *)(p->key);
1527 print (vam->ofp, "%7d %3d %s", sw_if_index,
1528 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1529 "sw_if_index not found!");
1536 static void vl_api_bridge_domain_details_t_handler_json
1537 (vl_api_bridge_domain_details_t * mp)
1539 vat_main_t *vam = &vat_main;
1540 vat_json_node_t *node, *array = NULL;
1541 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1543 if (VAT_JSON_ARRAY != vam->json_tree.type)
1545 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1546 vat_json_init_array (&vam->json_tree);
1548 node = vat_json_array_add (&vam->json_tree);
1550 vat_json_init_object (node);
1551 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1552 vat_json_object_add_uint (node, "flood", mp->flood);
1553 vat_json_object_add_uint (node, "forward", mp->forward);
1554 vat_json_object_add_uint (node, "learn", mp->learn);
1555 vat_json_object_add_uint (node, "bvi_sw_if_index",
1556 ntohl (mp->bvi_sw_if_index));
1557 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1558 array = vat_json_object_add (node, "sw_if");
1559 vat_json_init_array (array);
1565 vl_api_bridge_domain_sw_if_t *sw_ifs;
1568 sw_ifs = mp->sw_if_details;
1569 for (i = 0; i < n_sw_ifs; i++)
1571 node = vat_json_array_add (array);
1572 vat_json_init_object (node);
1573 vat_json_object_add_uint (node, "sw_if_index",
1574 ntohl (sw_ifs->sw_if_index));
1575 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1581 static void vl_api_control_ping_reply_t_handler
1582 (vl_api_control_ping_reply_t * mp)
1584 vat_main_t *vam = &vat_main;
1585 i32 retval = ntohl (mp->retval);
1586 if (vam->async_mode)
1588 vam->async_errors += (retval < 0);
1592 vam->retval = retval;
1593 vam->result_ready = 1;
1595 if (vam->socket_client_main)
1596 vam->socket_client_main->control_pings_outstanding--;
1599 static void vl_api_control_ping_reply_t_handler_json
1600 (vl_api_control_ping_reply_t * mp)
1602 vat_main_t *vam = &vat_main;
1603 i32 retval = ntohl (mp->retval);
1605 if (VAT_JSON_NONE != vam->json_tree.type)
1607 vat_json_print (vam->ofp, &vam->json_tree);
1608 vat_json_free (&vam->json_tree);
1609 vam->json_tree.type = VAT_JSON_NONE;
1614 vat_json_init_array (&vam->json_tree);
1615 vat_json_print (vam->ofp, &vam->json_tree);
1616 vam->json_tree.type = VAT_JSON_NONE;
1619 vam->retval = retval;
1620 vam->result_ready = 1;
1624 vl_api_bridge_domain_set_mac_age_reply_t_handler
1625 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1627 vat_main_t *vam = &vat_main;
1628 i32 retval = ntohl (mp->retval);
1629 if (vam->async_mode)
1631 vam->async_errors += (retval < 0);
1635 vam->retval = retval;
1636 vam->result_ready = 1;
1640 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1641 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1643 vat_main_t *vam = &vat_main;
1644 vat_json_node_t node;
1646 vat_json_init_object (&node);
1647 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1649 vat_json_print (vam->ofp, &node);
1650 vat_json_free (&node);
1652 vam->retval = ntohl (mp->retval);
1653 vam->result_ready = 1;
1657 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1659 vat_main_t *vam = &vat_main;
1660 i32 retval = ntohl (mp->retval);
1661 if (vam->async_mode)
1663 vam->async_errors += (retval < 0);
1667 vam->retval = retval;
1668 vam->result_ready = 1;
1672 static void vl_api_l2_flags_reply_t_handler_json
1673 (vl_api_l2_flags_reply_t * mp)
1675 vat_main_t *vam = &vat_main;
1676 vat_json_node_t node;
1678 vat_json_init_object (&node);
1679 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1680 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1681 ntohl (mp->resulting_feature_bitmap));
1683 vat_json_print (vam->ofp, &node);
1684 vat_json_free (&node);
1686 vam->retval = ntohl (mp->retval);
1687 vam->result_ready = 1;
1690 static void vl_api_bridge_flags_reply_t_handler
1691 (vl_api_bridge_flags_reply_t * mp)
1693 vat_main_t *vam = &vat_main;
1694 i32 retval = ntohl (mp->retval);
1695 if (vam->async_mode)
1697 vam->async_errors += (retval < 0);
1701 vam->retval = retval;
1702 vam->result_ready = 1;
1706 static void vl_api_bridge_flags_reply_t_handler_json
1707 (vl_api_bridge_flags_reply_t * mp)
1709 vat_main_t *vam = &vat_main;
1710 vat_json_node_t node;
1712 vat_json_init_object (&node);
1713 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1714 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1715 ntohl (mp->resulting_feature_bitmap));
1717 vat_json_print (vam->ofp, &node);
1718 vat_json_free (&node);
1720 vam->retval = ntohl (mp->retval);
1721 vam->result_ready = 1;
1725 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1727 vat_main_t *vam = &vat_main;
1728 i32 retval = ntohl (mp->retval);
1729 if (vam->async_mode)
1731 vam->async_errors += (retval < 0);
1735 vam->retval = retval;
1736 vam->sw_if_index = ntohl (mp->sw_if_index);
1737 vam->result_ready = 1;
1742 static void vl_api_tap_create_v2_reply_t_handler_json
1743 (vl_api_tap_create_v2_reply_t * mp)
1745 vat_main_t *vam = &vat_main;
1746 vat_json_node_t node;
1748 vat_json_init_object (&node);
1749 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1750 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1752 vat_json_print (vam->ofp, &node);
1753 vat_json_free (&node);
1755 vam->retval = ntohl (mp->retval);
1756 vam->result_ready = 1;
1761 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1763 vat_main_t *vam = &vat_main;
1764 i32 retval = ntohl (mp->retval);
1765 if (vam->async_mode)
1767 vam->async_errors += (retval < 0);
1771 vam->retval = retval;
1772 vam->result_ready = 1;
1776 static void vl_api_tap_delete_v2_reply_t_handler_json
1777 (vl_api_tap_delete_v2_reply_t * mp)
1779 vat_main_t *vam = &vat_main;
1780 vat_json_node_t node;
1782 vat_json_init_object (&node);
1783 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1785 vat_json_print (vam->ofp, &node);
1786 vat_json_free (&node);
1788 vam->retval = ntohl (mp->retval);
1789 vam->result_ready = 1;
1793 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1796 vat_main_t *vam = &vat_main;
1797 i32 retval = ntohl (mp->retval);
1798 if (vam->async_mode)
1800 vam->async_errors += (retval < 0);
1804 vam->retval = retval;
1805 vam->sw_if_index = ntohl (mp->sw_if_index);
1806 vam->result_ready = 1;
1810 static void vl_api_virtio_pci_create_reply_t_handler_json
1811 (vl_api_virtio_pci_create_reply_t * mp)
1813 vat_main_t *vam = &vat_main;
1814 vat_json_node_t node;
1816 vat_json_init_object (&node);
1817 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1818 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1820 vat_json_print (vam->ofp, &node);
1821 vat_json_free (&node);
1823 vam->retval = ntohl (mp->retval);
1824 vam->result_ready = 1;
1829 vl_api_virtio_pci_create_v2_reply_t_handler
1830 (vl_api_virtio_pci_create_v2_reply_t * mp)
1832 vat_main_t *vam = &vat_main;
1833 i32 retval = ntohl (mp->retval);
1834 if (vam->async_mode)
1836 vam->async_errors += (retval < 0);
1840 vam->retval = retval;
1841 vam->sw_if_index = ntohl (mp->sw_if_index);
1842 vam->result_ready = 1;
1846 static void vl_api_virtio_pci_create_v2_reply_t_handler_json
1847 (vl_api_virtio_pci_create_v2_reply_t * mp)
1849 vat_main_t *vam = &vat_main;
1850 vat_json_node_t node;
1852 vat_json_init_object (&node);
1853 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1854 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1856 vat_json_print (vam->ofp, &node);
1857 vat_json_free (&node);
1859 vam->retval = ntohl (mp->retval);
1860 vam->result_ready = 1;
1864 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1867 vat_main_t *vam = &vat_main;
1868 i32 retval = ntohl (mp->retval);
1869 if (vam->async_mode)
1871 vam->async_errors += (retval < 0);
1875 vam->retval = retval;
1876 vam->result_ready = 1;
1880 static void vl_api_virtio_pci_delete_reply_t_handler_json
1881 (vl_api_virtio_pci_delete_reply_t * mp)
1883 vat_main_t *vam = &vat_main;
1884 vat_json_node_t node;
1886 vat_json_init_object (&node);
1887 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1889 vat_json_print (vam->ofp, &node);
1890 vat_json_free (&node);
1892 vam->retval = ntohl (mp->retval);
1893 vam->result_ready = 1;
1897 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1899 vat_main_t *vam = &vat_main;
1900 i32 retval = ntohl (mp->retval);
1902 if (vam->async_mode)
1904 vam->async_errors += (retval < 0);
1908 vam->retval = retval;
1909 vam->sw_if_index = ntohl (mp->sw_if_index);
1910 vam->result_ready = 1;
1914 static void vl_api_bond_create_reply_t_handler_json
1915 (vl_api_bond_create_reply_t * mp)
1917 vat_main_t *vam = &vat_main;
1918 vat_json_node_t node;
1920 vat_json_init_object (&node);
1921 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1922 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1924 vat_json_print (vam->ofp, &node);
1925 vat_json_free (&node);
1927 vam->retval = ntohl (mp->retval);
1928 vam->result_ready = 1;
1932 vl_api_bond_create2_reply_t_handler (vl_api_bond_create2_reply_t * mp)
1934 vat_main_t *vam = &vat_main;
1935 i32 retval = ntohl (mp->retval);
1937 if (vam->async_mode)
1939 vam->async_errors += (retval < 0);
1943 vam->retval = retval;
1944 vam->sw_if_index = ntohl (mp->sw_if_index);
1945 vam->result_ready = 1;
1949 static void vl_api_bond_create2_reply_t_handler_json
1950 (vl_api_bond_create2_reply_t * mp)
1952 vat_main_t *vam = &vat_main;
1953 vat_json_node_t node;
1955 vat_json_init_object (&node);
1956 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1957 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1959 vat_json_print (vam->ofp, &node);
1960 vat_json_free (&node);
1962 vam->retval = ntohl (mp->retval);
1963 vam->result_ready = 1;
1967 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1969 vat_main_t *vam = &vat_main;
1970 i32 retval = ntohl (mp->retval);
1972 if (vam->async_mode)
1974 vam->async_errors += (retval < 0);
1978 vam->retval = retval;
1979 vam->result_ready = 1;
1983 static void vl_api_bond_delete_reply_t_handler_json
1984 (vl_api_bond_delete_reply_t * mp)
1986 vat_main_t *vam = &vat_main;
1987 vat_json_node_t node;
1989 vat_json_init_object (&node);
1990 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1992 vat_json_print (vam->ofp, &node);
1993 vat_json_free (&node);
1995 vam->retval = ntohl (mp->retval);
1996 vam->result_ready = 1;
2000 vl_api_bond_add_member_reply_t_handler (vl_api_bond_add_member_reply_t * mp)
2002 vat_main_t *vam = &vat_main;
2003 i32 retval = ntohl (mp->retval);
2005 if (vam->async_mode)
2007 vam->async_errors += (retval < 0);
2011 vam->retval = retval;
2012 vam->result_ready = 1;
2016 static void vl_api_bond_add_member_reply_t_handler_json
2017 (vl_api_bond_add_member_reply_t * mp)
2019 vat_main_t *vam = &vat_main;
2020 vat_json_node_t node;
2022 vat_json_init_object (&node);
2023 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2025 vat_json_print (vam->ofp, &node);
2026 vat_json_free (&node);
2028 vam->retval = ntohl (mp->retval);
2029 vam->result_ready = 1;
2033 vl_api_bond_detach_member_reply_t_handler (vl_api_bond_detach_member_reply_t *
2036 vat_main_t *vam = &vat_main;
2037 i32 retval = ntohl (mp->retval);
2039 if (vam->async_mode)
2041 vam->async_errors += (retval < 0);
2045 vam->retval = retval;
2046 vam->result_ready = 1;
2050 static void vl_api_bond_detach_member_reply_t_handler_json
2051 (vl_api_bond_detach_member_reply_t * mp)
2053 vat_main_t *vam = &vat_main;
2054 vat_json_node_t node;
2056 vat_json_init_object (&node);
2057 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2059 vat_json_print (vam->ofp, &node);
2060 vat_json_free (&node);
2062 vam->retval = ntohl (mp->retval);
2063 vam->result_ready = 1;
2067 api_sw_interface_set_bond_weight (vat_main_t * vam)
2069 unformat_input_t *i = vam->input;
2070 vl_api_sw_interface_set_bond_weight_t *mp;
2071 u32 sw_if_index = ~0;
2073 u8 weight_enter = 0;
2076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2078 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2080 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2082 else if (unformat (i, "weight %u", &weight))
2088 if (sw_if_index == ~0)
2090 errmsg ("missing interface name or sw_if_index");
2093 if (weight_enter == 0)
2095 errmsg ("missing valid weight");
2099 /* Construct the API message */
2100 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2101 mp->sw_if_index = ntohl (sw_if_index);
2102 mp->weight = ntohl (weight);
2109 static void vl_api_sw_bond_interface_details_t_handler
2110 (vl_api_sw_bond_interface_details_t * mp)
2112 vat_main_t *vam = &vat_main;
2115 "%-16s %-12d %-12U %-13U %-14u %-14u",
2116 mp->interface_name, ntohl (mp->sw_if_index),
2117 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2118 ntohl (mp->lb), ntohl (mp->active_members), ntohl (mp->members));
2121 static void vl_api_sw_bond_interface_details_t_handler_json
2122 (vl_api_sw_bond_interface_details_t * mp)
2124 vat_main_t *vam = &vat_main;
2125 vat_json_node_t *node = NULL;
2127 if (VAT_JSON_ARRAY != vam->json_tree.type)
2129 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2130 vat_json_init_array (&vam->json_tree);
2132 node = vat_json_array_add (&vam->json_tree);
2134 vat_json_init_object (node);
2135 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2136 vat_json_object_add_string_copy (node, "interface_name",
2137 mp->interface_name);
2138 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2139 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2140 vat_json_object_add_uint (node, "active_members",
2141 ntohl (mp->active_members));
2142 vat_json_object_add_uint (node, "members", ntohl (mp->members));
2146 api_sw_bond_interface_dump (vat_main_t * vam)
2148 unformat_input_t *i = vam->input;
2149 vl_api_sw_bond_interface_dump_t *mp;
2150 vl_api_control_ping_t *mp_ping;
2152 u32 sw_if_index = ~0;
2154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2156 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2158 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2165 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2166 "interface name", "sw_if_index", "mode", "load balance",
2167 "active members", "members");
2169 /* Get list of bond interfaces */
2170 M (SW_BOND_INTERFACE_DUMP, mp);
2171 mp->sw_if_index = ntohl (sw_if_index);
2174 /* Use a control ping for synchronization */
2175 MPING (CONTROL_PING, mp_ping);
2182 static void vl_api_sw_member_interface_details_t_handler
2183 (vl_api_sw_member_interface_details_t * mp)
2185 vat_main_t *vam = &vat_main;
2188 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2189 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2190 ntohl (mp->weight), mp->is_local_numa);
2193 static void vl_api_sw_member_interface_details_t_handler_json
2194 (vl_api_sw_member_interface_details_t * mp)
2196 vat_main_t *vam = &vat_main;
2197 vat_json_node_t *node = NULL;
2199 if (VAT_JSON_ARRAY != vam->json_tree.type)
2201 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2202 vat_json_init_array (&vam->json_tree);
2204 node = vat_json_array_add (&vam->json_tree);
2206 vat_json_init_object (node);
2207 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2208 vat_json_object_add_string_copy (node, "interface_name",
2209 mp->interface_name);
2210 vat_json_object_add_uint (node, "passive", mp->is_passive);
2211 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2212 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2213 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2217 api_sw_member_interface_dump (vat_main_t * vam)
2219 unformat_input_t *i = vam->input;
2220 vl_api_sw_member_interface_dump_t *mp;
2221 vl_api_control_ping_t *mp_ping;
2222 u32 sw_if_index = ~0;
2223 u8 sw_if_index_set = 0;
2226 /* Parse args required to build the message */
2227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2229 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2230 sw_if_index_set = 1;
2231 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2232 sw_if_index_set = 1;
2237 if (sw_if_index_set == 0)
2239 errmsg ("missing vpp interface name. ");
2244 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2245 "member interface name", "sw_if_index", "passive", "long_timeout",
2246 "weight", "local numa");
2248 /* Get list of bond interfaces */
2249 M (SW_MEMBER_INTERFACE_DUMP, mp);
2250 mp->sw_if_index = ntohl (sw_if_index);
2253 /* Use a control ping for synchronization */
2254 MPING (CONTROL_PING, mp_ping);
2261 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2262 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2264 vat_main_t *vam = &vat_main;
2265 i32 retval = ntohl (mp->retval);
2266 if (vam->async_mode)
2268 vam->async_errors += (retval < 0);
2272 vam->retval = retval;
2273 vam->sw_if_index = ntohl (mp->sw_if_index);
2274 vam->result_ready = 1;
2276 vam->regenerate_interface_table = 1;
2279 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2280 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2282 vat_main_t *vam = &vat_main;
2283 vat_json_node_t node;
2285 vat_json_init_object (&node);
2286 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2287 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2288 ntohl (mp->sw_if_index));
2290 vat_json_print (vam->ofp, &node);
2291 vat_json_free (&node);
2293 vam->retval = ntohl (mp->retval);
2294 vam->result_ready = 1;
2297 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2298 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2300 vat_main_t *vam = &vat_main;
2301 i32 retval = ntohl (mp->retval);
2302 if (vam->async_mode)
2304 vam->async_errors += (retval < 0);
2308 vam->retval = retval;
2309 vam->sw_if_index = ntohl (mp->sw_if_index);
2310 vam->result_ready = 1;
2312 vam->regenerate_interface_table = 1;
2315 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2316 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2318 vat_main_t *vam = &vat_main;
2319 vat_json_node_t node;
2321 vat_json_init_object (&node);
2322 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2323 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2325 vat_json_print (vam->ofp, &node);
2326 vat_json_free (&node);
2328 vam->retval = ntohl (mp->retval);
2329 vam->result_ready = 1;
2332 static void vl_api_vxlan_offload_rx_reply_t_handler
2333 (vl_api_vxlan_offload_rx_reply_t * mp)
2335 vat_main_t *vam = &vat_main;
2336 i32 retval = ntohl (mp->retval);
2337 if (vam->async_mode)
2339 vam->async_errors += (retval < 0);
2343 vam->retval = retval;
2344 vam->result_ready = 1;
2348 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2349 (vl_api_vxlan_offload_rx_reply_t * mp)
2351 vat_main_t *vam = &vat_main;
2352 vat_json_node_t node;
2354 vat_json_init_object (&node);
2355 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2357 vat_json_print (vam->ofp, &node);
2358 vat_json_free (&node);
2360 vam->retval = ntohl (mp->retval);
2361 vam->result_ready = 1;
2364 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2365 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2367 vat_main_t *vam = &vat_main;
2368 i32 retval = ntohl (mp->retval);
2369 if (vam->async_mode)
2371 vam->async_errors += (retval < 0);
2375 vam->retval = retval;
2376 vam->sw_if_index = ntohl (mp->sw_if_index);
2377 vam->result_ready = 1;
2379 vam->regenerate_interface_table = 1;
2382 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2383 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 vat_json_node_t node;
2388 vat_json_init_object (&node);
2389 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2390 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2392 vat_json_print (vam->ofp, &node);
2393 vat_json_free (&node);
2395 vam->retval = ntohl (mp->retval);
2396 vam->result_ready = 1;
2399 static void vl_api_gre_tunnel_add_del_reply_t_handler
2400 (vl_api_gre_tunnel_add_del_reply_t * mp)
2402 vat_main_t *vam = &vat_main;
2403 i32 retval = ntohl (mp->retval);
2404 if (vam->async_mode)
2406 vam->async_errors += (retval < 0);
2410 vam->retval = retval;
2411 vam->sw_if_index = ntohl (mp->sw_if_index);
2412 vam->result_ready = 1;
2416 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2417 (vl_api_gre_tunnel_add_del_reply_t * mp)
2419 vat_main_t *vam = &vat_main;
2420 vat_json_node_t node;
2422 vat_json_init_object (&node);
2423 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2424 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2426 vat_json_print (vam->ofp, &node);
2427 vat_json_free (&node);
2429 vam->retval = ntohl (mp->retval);
2430 vam->result_ready = 1;
2433 static void vl_api_create_vhost_user_if_reply_t_handler
2434 (vl_api_create_vhost_user_if_reply_t * mp)
2436 vat_main_t *vam = &vat_main;
2437 i32 retval = ntohl (mp->retval);
2438 if (vam->async_mode)
2440 vam->async_errors += (retval < 0);
2444 vam->retval = retval;
2445 vam->sw_if_index = ntohl (mp->sw_if_index);
2446 vam->result_ready = 1;
2448 vam->regenerate_interface_table = 1;
2451 static void vl_api_create_vhost_user_if_reply_t_handler_json
2452 (vl_api_create_vhost_user_if_reply_t * mp)
2454 vat_main_t *vam = &vat_main;
2455 vat_json_node_t node;
2457 vat_json_init_object (&node);
2458 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2459 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2461 vat_json_print (vam->ofp, &node);
2462 vat_json_free (&node);
2464 vam->retval = ntohl (mp->retval);
2465 vam->result_ready = 1;
2468 static void vl_api_ip_address_details_t_handler
2469 (vl_api_ip_address_details_t * mp)
2471 vat_main_t *vam = &vat_main;
2472 static ip_address_details_t empty_ip_address_details = { {0} };
2473 ip_address_details_t *address = NULL;
2474 ip_details_t *current_ip_details = NULL;
2475 ip_details_t *details = NULL;
2477 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2479 if (!details || vam->current_sw_if_index >= vec_len (details)
2480 || !details[vam->current_sw_if_index].present)
2482 errmsg ("ip address details arrived but not stored");
2483 errmsg ("ip_dump should be called first");
2487 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2489 #define addresses (current_ip_details->addr)
2491 vec_validate_init_empty (addresses, vec_len (addresses),
2492 empty_ip_address_details);
2494 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2496 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2497 address->prefix_length = mp->prefix.len;
2501 static void vl_api_ip_address_details_t_handler_json
2502 (vl_api_ip_address_details_t * mp)
2504 vat_main_t *vam = &vat_main;
2505 vat_json_node_t *node = NULL;
2507 if (VAT_JSON_ARRAY != vam->json_tree.type)
2509 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2510 vat_json_init_array (&vam->json_tree);
2512 node = vat_json_array_add (&vam->json_tree);
2514 vat_json_init_object (node);
2515 vat_json_object_add_prefix (node, &mp->prefix);
2519 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2521 vat_main_t *vam = &vat_main;
2522 static ip_details_t empty_ip_details = { 0 };
2523 ip_details_t *ip = NULL;
2524 u32 sw_if_index = ~0;
2526 sw_if_index = ntohl (mp->sw_if_index);
2528 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2529 sw_if_index, empty_ip_details);
2531 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2538 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2540 vat_main_t *vam = &vat_main;
2542 if (VAT_JSON_ARRAY != vam->json_tree.type)
2544 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2545 vat_json_init_array (&vam->json_tree);
2547 vat_json_array_add_uint (&vam->json_tree,
2548 clib_net_to_host_u32 (mp->sw_if_index));
2551 static void vl_api_get_first_msg_id_reply_t_handler
2552 (vl_api_get_first_msg_id_reply_t * mp)
2554 vat_main_t *vam = &vat_main;
2555 i32 retval = ntohl (mp->retval);
2557 if (vam->async_mode)
2559 vam->async_errors += (retval < 0);
2563 vam->retval = retval;
2564 vam->result_ready = 1;
2568 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2572 static void vl_api_get_first_msg_id_reply_t_handler_json
2573 (vl_api_get_first_msg_id_reply_t * mp)
2575 vat_main_t *vam = &vat_main;
2576 vat_json_node_t node;
2578 vat_json_init_object (&node);
2579 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2580 vat_json_object_add_uint (&node, "first_msg_id",
2581 (uint) ntohs (mp->first_msg_id));
2583 vat_json_print (vam->ofp, &node);
2584 vat_json_free (&node);
2586 vam->retval = ntohl (mp->retval);
2587 vam->result_ready = 1;
2590 static void vl_api_get_node_graph_reply_t_handler
2591 (vl_api_get_node_graph_reply_t * mp)
2593 vat_main_t *vam = &vat_main;
2594 i32 retval = ntohl (mp->retval);
2595 u8 *pvt_copy, *reply;
2600 if (vam->async_mode)
2602 vam->async_errors += (retval < 0);
2606 vam->retval = retval;
2607 vam->result_ready = 1;
2610 /* "Should never happen..." */
2614 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2615 pvt_copy = vec_dup (reply);
2617 /* Toss the shared-memory original... */
2618 oldheap = vl_msg_push_heap ();
2622 vl_msg_pop_heap (oldheap);
2624 if (vam->graph_nodes)
2626 hash_free (vam->graph_node_index_by_name);
2628 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2630 node = vam->graph_nodes[0][i];
2631 vec_free (node->name);
2632 vec_free (node->next_nodes);
2635 vec_free (vam->graph_nodes[0]);
2636 vec_free (vam->graph_nodes);
2639 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2640 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2641 vec_free (pvt_copy);
2643 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2645 node = vam->graph_nodes[0][i];
2646 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2650 static void vl_api_get_node_graph_reply_t_handler_json
2651 (vl_api_get_node_graph_reply_t * mp)
2653 vat_main_t *vam = &vat_main;
2655 vat_json_node_t node;
2658 /* $$$$ make this real? */
2659 vat_json_init_object (&node);
2660 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2661 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2663 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2665 /* Toss the shared-memory original... */
2666 oldheap = vl_msg_push_heap ();
2670 vl_msg_pop_heap (oldheap);
2672 vat_json_print (vam->ofp, &node);
2673 vat_json_free (&node);
2675 vam->retval = ntohl (mp->retval);
2676 vam->result_ready = 1;
2680 format_policer_type (u8 * s, va_list * va)
2682 u32 i = va_arg (*va, u32);
2684 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2685 s = format (s, "1r2c");
2686 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2687 s = format (s, "1r3c");
2688 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2689 s = format (s, "2r3c-2698");
2690 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2691 s = format (s, "2r3c-4115");
2692 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2693 s = format (s, "2r3c-mef5cf1");
2695 s = format (s, "ILLEGAL");
2700 format_policer_rate_type (u8 * s, va_list * va)
2702 u32 i = va_arg (*va, u32);
2704 if (i == SSE2_QOS_RATE_KBPS)
2705 s = format (s, "kbps");
2706 else if (i == SSE2_QOS_RATE_PPS)
2707 s = format (s, "pps");
2709 s = format (s, "ILLEGAL");
2714 format_policer_round_type (u8 * s, va_list * va)
2716 u32 i = va_arg (*va, u32);
2718 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2719 s = format (s, "closest");
2720 else if (i == SSE2_QOS_ROUND_TO_UP)
2721 s = format (s, "up");
2722 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2723 s = format (s, "down");
2725 s = format (s, "ILLEGAL");
2730 format_policer_action_type (u8 * s, va_list * va)
2732 u32 i = va_arg (*va, u32);
2734 if (i == SSE2_QOS_ACTION_DROP)
2735 s = format (s, "drop");
2736 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2737 s = format (s, "transmit");
2738 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2739 s = format (s, "mark-and-transmit");
2741 s = format (s, "ILLEGAL");
2746 format_dscp (u8 * s, va_list * va)
2748 u32 i = va_arg (*va, u32);
2753 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2757 return format (s, "ILLEGAL");
2759 s = format (s, "%s", t);
2764 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2766 vat_main_t *vam = &vat_main;
2767 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2769 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2770 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
2772 conform_dscp_str = format (0, "");
2774 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2775 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
2777 exceed_dscp_str = format (0, "");
2779 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2780 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
2782 violate_dscp_str = format (0, "");
2784 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2785 "rate type %U, round type %U, %s rate, %s color-aware, "
2786 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2787 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2788 "conform action %U%s, exceed action %U%s, violate action %U%s",
2790 format_policer_type, mp->type,
2793 clib_net_to_host_u64 (mp->cb),
2794 clib_net_to_host_u64 (mp->eb),
2795 format_policer_rate_type, mp->rate_type,
2796 format_policer_round_type, mp->round_type,
2797 mp->single_rate ? "single" : "dual",
2798 mp->color_aware ? "is" : "not",
2799 ntohl (mp->cir_tokens_per_period),
2800 ntohl (mp->pir_tokens_per_period),
2802 ntohl (mp->current_limit),
2803 ntohl (mp->current_bucket),
2804 ntohl (mp->extended_limit),
2805 ntohl (mp->extended_bucket),
2806 clib_net_to_host_u64 (mp->last_update_time),
2807 format_policer_action_type, mp->conform_action.type,
2809 format_policer_action_type, mp->exceed_action.type,
2811 format_policer_action_type, mp->violate_action.type,
2814 vec_free (conform_dscp_str);
2815 vec_free (exceed_dscp_str);
2816 vec_free (violate_dscp_str);
2819 static void vl_api_policer_details_t_handler_json
2820 (vl_api_policer_details_t * mp)
2822 vat_main_t *vam = &vat_main;
2823 vat_json_node_t *node;
2824 u8 *rate_type_str, *round_type_str, *type_str;
2825 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2827 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2829 format (0, "%U", format_policer_round_type, mp->round_type);
2830 type_str = format (0, "%U", format_policer_type, mp->type);
2831 conform_action_str = format (0, "%U", format_policer_action_type,
2832 mp->conform_action.type);
2833 exceed_action_str = format (0, "%U", format_policer_action_type,
2834 mp->exceed_action.type);
2835 violate_action_str = format (0, "%U", format_policer_action_type,
2836 mp->violate_action.type);
2838 if (VAT_JSON_ARRAY != vam->json_tree.type)
2840 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2841 vat_json_init_array (&vam->json_tree);
2843 node = vat_json_array_add (&vam->json_tree);
2845 vat_json_init_object (node);
2846 vat_json_object_add_string_copy (node, "name", mp->name);
2847 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2848 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2849 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
2850 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
2851 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2852 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2853 vat_json_object_add_string_copy (node, "type", type_str);
2854 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2855 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2856 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2857 vat_json_object_add_uint (node, "cir_tokens_per_period",
2858 ntohl (mp->cir_tokens_per_period));
2859 vat_json_object_add_uint (node, "eir_tokens_per_period",
2860 ntohl (mp->pir_tokens_per_period));
2861 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2862 vat_json_object_add_uint (node, "current_bucket",
2863 ntohl (mp->current_bucket));
2864 vat_json_object_add_uint (node, "extended_limit",
2865 ntohl (mp->extended_limit));
2866 vat_json_object_add_uint (node, "extended_bucket",
2867 ntohl (mp->extended_bucket));
2868 vat_json_object_add_uint (node, "last_update_time",
2869 ntohl (mp->last_update_time));
2870 vat_json_object_add_string_copy (node, "conform_action",
2871 conform_action_str);
2872 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2874 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
2875 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2876 vec_free (dscp_str);
2878 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2879 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2881 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
2882 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2883 vec_free (dscp_str);
2885 vat_json_object_add_string_copy (node, "violate_action",
2886 violate_action_str);
2887 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
2889 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
2890 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2891 vec_free (dscp_str);
2894 vec_free (rate_type_str);
2895 vec_free (round_type_str);
2896 vec_free (type_str);
2897 vec_free (conform_action_str);
2898 vec_free (exceed_action_str);
2899 vec_free (violate_action_str);
2903 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2906 vat_main_t *vam = &vat_main;
2907 int i, count = ntohl (mp->count);
2910 print (vam->ofp, "classify table ids (%d) : ", count);
2911 for (i = 0; i < count; i++)
2913 print (vam->ofp, "%d", ntohl (mp->ids[i]));
2914 print (vam->ofp, (i < count - 1) ? "," : "");
2916 vam->retval = ntohl (mp->retval);
2917 vam->result_ready = 1;
2921 vl_api_classify_table_ids_reply_t_handler_json
2922 (vl_api_classify_table_ids_reply_t * mp)
2924 vat_main_t *vam = &vat_main;
2925 int i, count = ntohl (mp->count);
2929 vat_json_node_t node;
2931 vat_json_init_object (&node);
2932 for (i = 0; i < count; i++)
2934 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
2936 vat_json_print (vam->ofp, &node);
2937 vat_json_free (&node);
2939 vam->retval = ntohl (mp->retval);
2940 vam->result_ready = 1;
2944 vl_api_classify_table_by_interface_reply_t_handler
2945 (vl_api_classify_table_by_interface_reply_t * mp)
2947 vat_main_t *vam = &vat_main;
2950 table_id = ntohl (mp->l2_table_id);
2952 print (vam->ofp, "l2 table id : %d", table_id);
2954 print (vam->ofp, "l2 table id : No input ACL tables configured");
2955 table_id = ntohl (mp->ip4_table_id);
2957 print (vam->ofp, "ip4 table id : %d", table_id);
2959 print (vam->ofp, "ip4 table id : No input ACL tables configured");
2960 table_id = ntohl (mp->ip6_table_id);
2962 print (vam->ofp, "ip6 table id : %d", table_id);
2964 print (vam->ofp, "ip6 table id : No input ACL tables configured");
2965 vam->retval = ntohl (mp->retval);
2966 vam->result_ready = 1;
2970 vl_api_classify_table_by_interface_reply_t_handler_json
2971 (vl_api_classify_table_by_interface_reply_t * mp)
2973 vat_main_t *vam = &vat_main;
2974 vat_json_node_t node;
2976 vat_json_init_object (&node);
2978 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
2979 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
2980 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
2982 vat_json_print (vam->ofp, &node);
2983 vat_json_free (&node);
2985 vam->retval = ntohl (mp->retval);
2986 vam->result_ready = 1;
2989 static void vl_api_policer_add_del_reply_t_handler
2990 (vl_api_policer_add_del_reply_t * mp)
2992 vat_main_t *vam = &vat_main;
2993 i32 retval = ntohl (mp->retval);
2994 if (vam->async_mode)
2996 vam->async_errors += (retval < 0);
3000 vam->retval = retval;
3001 vam->result_ready = 1;
3002 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3004 * Note: this is just barely thread-safe, depends on
3005 * the main thread spinning waiting for an answer...
3007 errmsg ("policer index %d", ntohl (mp->policer_index));
3011 static void vl_api_policer_add_del_reply_t_handler_json
3012 (vl_api_policer_add_del_reply_t * mp)
3014 vat_main_t *vam = &vat_main;
3015 vat_json_node_t node;
3017 vat_json_init_object (&node);
3018 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3019 vat_json_object_add_uint (&node, "policer_index",
3020 ntohl (mp->policer_index));
3022 vat_json_print (vam->ofp, &node);
3023 vat_json_free (&node);
3025 vam->retval = ntohl (mp->retval);
3026 vam->result_ready = 1;
3029 /* Format hex dump. */
3031 format_hex_bytes (u8 * s, va_list * va)
3033 u8 *bytes = va_arg (*va, u8 *);
3034 int n_bytes = va_arg (*va, int);
3037 /* Print short or long form depending on byte count. */
3038 uword short_form = n_bytes <= 32;
3039 u32 indent = format_get_indent (s);
3044 for (i = 0; i < n_bytes; i++)
3046 if (!short_form && (i % 32) == 0)
3047 s = format (s, "%08x: ", i);
3048 s = format (s, "%02x", bytes[i]);
3049 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3050 s = format (s, "\n%U", format_white_space, indent);
3057 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3060 vat_main_t *vam = &vat_main;
3061 i32 retval = ntohl (mp->retval);
3064 print (vam->ofp, "classify table info :");
3065 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3066 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3067 ntohl (mp->miss_next_index));
3068 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3069 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3070 ntohl (mp->match_n_vectors));
3071 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3072 ntohl (mp->mask_length));
3074 vam->retval = retval;
3075 vam->result_ready = 1;
3079 vl_api_classify_table_info_reply_t_handler_json
3080 (vl_api_classify_table_info_reply_t * mp)
3082 vat_main_t *vam = &vat_main;
3083 vat_json_node_t node;
3085 i32 retval = ntohl (mp->retval);
3088 vat_json_init_object (&node);
3090 vat_json_object_add_int (&node, "sessions",
3091 ntohl (mp->active_sessions));
3092 vat_json_object_add_int (&node, "nexttbl",
3093 ntohl (mp->next_table_index));
3094 vat_json_object_add_int (&node, "nextnode",
3095 ntohl (mp->miss_next_index));
3096 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3097 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3098 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3099 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3100 ntohl (mp->mask_length), 0);
3101 vat_json_object_add_string_copy (&node, "mask", s);
3103 vat_json_print (vam->ofp, &node);
3104 vat_json_free (&node);
3106 vam->retval = ntohl (mp->retval);
3107 vam->result_ready = 1;
3111 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3114 vat_main_t *vam = &vat_main;
3116 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3117 ntohl (mp->hit_next_index), ntohl (mp->advance),
3118 ntohl (mp->opaque_index));
3119 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3120 ntohl (mp->match_length));
3124 vl_api_classify_session_details_t_handler_json
3125 (vl_api_classify_session_details_t * mp)
3127 vat_main_t *vam = &vat_main;
3128 vat_json_node_t *node = NULL;
3130 if (VAT_JSON_ARRAY != vam->json_tree.type)
3132 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3133 vat_json_init_array (&vam->json_tree);
3135 node = vat_json_array_add (&vam->json_tree);
3137 vat_json_init_object (node);
3138 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3139 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3140 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3142 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3144 vat_json_object_add_string_copy (node, "match", s);
3147 static void vl_api_pg_create_interface_reply_t_handler
3148 (vl_api_pg_create_interface_reply_t * mp)
3150 vat_main_t *vam = &vat_main;
3152 vam->retval = ntohl (mp->retval);
3153 vam->result_ready = 1;
3156 static void vl_api_pg_create_interface_reply_t_handler_json
3157 (vl_api_pg_create_interface_reply_t * mp)
3159 vat_main_t *vam = &vat_main;
3160 vat_json_node_t node;
3162 i32 retval = ntohl (mp->retval);
3165 vat_json_init_object (&node);
3167 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3169 vat_json_print (vam->ofp, &node);
3170 vat_json_free (&node);
3172 vam->retval = ntohl (mp->retval);
3173 vam->result_ready = 1;
3176 static void vl_api_policer_classify_details_t_handler
3177 (vl_api_policer_classify_details_t * mp)
3179 vat_main_t *vam = &vat_main;
3181 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3182 ntohl (mp->table_index));
3185 static void vl_api_policer_classify_details_t_handler_json
3186 (vl_api_policer_classify_details_t * mp)
3188 vat_main_t *vam = &vat_main;
3189 vat_json_node_t *node;
3191 if (VAT_JSON_ARRAY != vam->json_tree.type)
3193 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3194 vat_json_init_array (&vam->json_tree);
3196 node = vat_json_array_add (&vam->json_tree);
3198 vat_json_init_object (node);
3199 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3200 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3203 static void vl_api_flow_classify_details_t_handler
3204 (vl_api_flow_classify_details_t * mp)
3206 vat_main_t *vam = &vat_main;
3208 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3209 ntohl (mp->table_index));
3212 static void vl_api_flow_classify_details_t_handler_json
3213 (vl_api_flow_classify_details_t * mp)
3215 vat_main_t *vam = &vat_main;
3216 vat_json_node_t *node;
3218 if (VAT_JSON_ARRAY != vam->json_tree.type)
3220 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3221 vat_json_init_array (&vam->json_tree);
3223 node = vat_json_array_add (&vam->json_tree);
3225 vat_json_init_object (node);
3226 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3227 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3231 * Generate boilerplate reply handlers, which
3232 * dig the return value out of the xxx_reply_t API message,
3233 * stick it into vam->retval, and set vam->result_ready
3235 * Could also do this by pointing N message decode slots at
3236 * a single function, but that could break in subtle ways.
3239 #define foreach_standard_reply_retval_handler \
3240 _(sw_interface_set_flags_reply) \
3241 _(sw_interface_add_del_address_reply) \
3242 _(sw_interface_set_rx_mode_reply) \
3243 _(sw_interface_set_rx_placement_reply) \
3244 _(sw_interface_set_table_reply) \
3245 _(sw_interface_set_mpls_enable_reply) \
3246 _(sw_interface_set_vpath_reply) \
3247 _(sw_interface_set_vxlan_bypass_reply) \
3248 _(sw_interface_set_vxlan_gpe_bypass_reply) \
3249 _(sw_interface_set_l2_bridge_reply) \
3250 _(sw_interface_set_bond_weight_reply) \
3251 _(bridge_domain_add_del_reply) \
3252 _(sw_interface_set_l2_xconnect_reply) \
3253 _(l2fib_add_del_reply) \
3254 _(l2fib_flush_int_reply) \
3255 _(l2fib_flush_bd_reply) \
3256 _(ip_route_add_del_reply) \
3257 _(ip_table_add_del_reply) \
3258 _(ip_table_replace_begin_reply) \
3259 _(ip_table_flush_reply) \
3260 _(ip_table_replace_end_reply) \
3261 _(ip_mroute_add_del_reply) \
3262 _(mpls_route_add_del_reply) \
3263 _(mpls_table_add_del_reply) \
3264 _(mpls_ip_bind_unbind_reply) \
3265 _(bier_route_add_del_reply) \
3266 _(bier_table_add_del_reply) \
3267 _(sw_interface_set_unnumbered_reply) \
3268 _(set_ip_flow_hash_reply) \
3269 _(sw_interface_ip6_enable_disable_reply) \
3270 _(l2_patch_add_del_reply) \
3271 _(sr_mpls_policy_add_reply) \
3272 _(sr_mpls_policy_mod_reply) \
3273 _(sr_mpls_policy_del_reply) \
3274 _(sr_policy_add_reply) \
3275 _(sr_policy_mod_reply) \
3276 _(sr_policy_del_reply) \
3277 _(sr_localsid_add_del_reply) \
3278 _(sr_steering_add_del_reply) \
3279 _(classify_add_del_session_reply) \
3280 _(classify_set_interface_ip_table_reply) \
3281 _(classify_set_interface_l2_tables_reply) \
3282 _(l2_fib_clear_table_reply) \
3283 _(l2_interface_efp_filter_reply) \
3284 _(l2_interface_vlan_tag_rewrite_reply) \
3285 _(modify_vhost_user_if_reply) \
3286 _(delete_vhost_user_if_reply) \
3287 _(want_l2_macs_events_reply) \
3288 _(input_acl_set_interface_reply) \
3289 _(ipsec_spd_add_del_reply) \
3290 _(ipsec_interface_add_del_spd_reply) \
3291 _(ipsec_spd_entry_add_del_reply) \
3292 _(ipsec_sad_entry_add_del_reply) \
3293 _(ipsec_tunnel_if_add_del_reply) \
3294 _(ipsec_tunnel_if_set_sa_reply) \
3295 _(delete_loopback_reply) \
3296 _(bd_ip_mac_add_del_reply) \
3297 _(bd_ip_mac_flush_reply) \
3298 _(want_interface_events_reply) \
3299 _(cop_interface_enable_disable_reply) \
3300 _(cop_whitelist_enable_disable_reply) \
3301 _(sw_interface_clear_stats_reply) \
3302 _(ioam_enable_reply) \
3303 _(ioam_disable_reply) \
3304 _(af_packet_delete_reply) \
3305 _(policer_classify_set_interface_reply) \
3306 _(set_ipfix_exporter_reply) \
3307 _(set_ipfix_classify_stream_reply) \
3308 _(ipfix_classify_table_add_del_reply) \
3309 _(flow_classify_set_interface_reply) \
3310 _(sw_interface_span_enable_disable_reply) \
3311 _(pg_capture_reply) \
3312 _(pg_enable_disable_reply) \
3313 _(pg_interface_enable_disable_coalesce_reply) \
3314 _(ip_source_and_port_range_check_add_del_reply) \
3315 _(ip_source_and_port_range_check_interface_add_del_reply)\
3316 _(delete_subif_reply) \
3317 _(l2_interface_pbb_tag_rewrite_reply) \
3319 _(feature_enable_disable_reply) \
3320 _(feature_gso_enable_disable_reply) \
3321 _(sw_interface_tag_add_del_reply) \
3322 _(sw_interface_add_del_mac_address_reply) \
3323 _(hw_interface_set_mtu_reply) \
3324 _(p2p_ethernet_add_reply) \
3325 _(p2p_ethernet_del_reply) \
3326 _(tcp_configure_src_addresses_reply) \
3327 _(session_rule_add_del_reply) \
3328 _(ip_container_proxy_add_del_reply) \
3329 _(output_acl_set_interface_reply) \
3330 _(qos_record_enable_disable_reply) \
3334 static void vl_api_##n##_t_handler \
3335 (vl_api_##n##_t * mp) \
3337 vat_main_t * vam = &vat_main; \
3338 i32 retval = ntohl(mp->retval); \
3339 if (vam->async_mode) { \
3340 vam->async_errors += (retval < 0); \
3342 vam->retval = retval; \
3343 vam->result_ready = 1; \
3346 foreach_standard_reply_retval_handler;
3350 static void vl_api_##n##_t_handler_json \
3351 (vl_api_##n##_t * mp) \
3353 vat_main_t * vam = &vat_main; \
3354 vat_json_node_t node; \
3355 vat_json_init_object(&node); \
3356 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3357 vat_json_print(vam->ofp, &node); \
3358 vam->retval = ntohl(mp->retval); \
3359 vam->result_ready = 1; \
3361 foreach_standard_reply_retval_handler;
3365 * Table of message reply handlers, must include boilerplate handlers
3369 #define foreach_vpe_api_reply_msg \
3370 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3371 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
3372 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3373 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3374 _(CONTROL_PING_REPLY, control_ping_reply) \
3375 _(CLI_REPLY, cli_reply) \
3376 _(CLI_INBAND_REPLY, cli_inband_reply) \
3377 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3378 sw_interface_add_del_address_reply) \
3379 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
3380 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
3381 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
3382 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3383 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3384 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3385 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
3386 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
3387 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3388 sw_interface_set_l2_xconnect_reply) \
3389 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3390 sw_interface_set_l2_bridge_reply) \
3391 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3392 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3393 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
3394 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3395 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
3396 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
3397 _(L2_FLAGS_REPLY, l2_flags_reply) \
3398 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3399 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
3400 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
3401 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
3402 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
3403 _(VIRTIO_PCI_CREATE_V2_REPLY, virtio_pci_create_v2_reply) \
3404 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
3405 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
3406 _(BOND_CREATE_REPLY, bond_create_reply) \
3407 _(BOND_CREATE2_REPLY, bond_create2_reply) \
3408 _(BOND_DELETE_REPLY, bond_delete_reply) \
3409 _(BOND_ADD_MEMBER_REPLY, bond_add_member_reply) \
3410 _(BOND_DETACH_MEMBER_REPLY, bond_detach_member_reply) \
3411 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
3412 _(SW_BOND_INTERFACE_DETAILS, sw_bond_interface_details) \
3413 _(SW_MEMBER_INTERFACE_DETAILS, sw_member_interface_details) \
3414 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
3415 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
3416 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
3417 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
3418 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
3419 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
3420 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
3421 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
3422 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
3423 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
3424 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
3425 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
3426 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3427 sw_interface_set_unnumbered_reply) \
3428 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3429 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3430 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3431 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3432 sw_interface_ip6_enable_disable_reply) \
3433 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3434 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
3435 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
3436 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
3437 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
3438 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
3439 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
3440 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
3441 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
3442 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3443 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3444 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3445 classify_set_interface_ip_table_reply) \
3446 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3447 classify_set_interface_l2_tables_reply) \
3448 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3449 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3450 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3451 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
3452 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3453 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
3454 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3455 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3456 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3457 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3458 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3459 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3460 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3461 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3462 _(SHOW_VERSION_REPLY, show_version_reply) \
3463 _(SHOW_THREADS_REPLY, show_threads_reply) \
3464 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
3465 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3466 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3467 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3468 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
3469 _(L2_MACS_EVENT, l2_macs_event) \
3470 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3471 _(IP_ADDRESS_DETAILS, ip_address_details) \
3472 _(IP_DETAILS, ip_details) \
3473 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3474 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3475 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
3476 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
3477 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
3478 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
3479 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
3480 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3481 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3482 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
3483 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
3484 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3485 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3486 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3487 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3488 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3489 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3490 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3491 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3492 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3493 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3494 _(AF_PACKET_DETAILS, af_packet_details) \
3495 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3496 _(POLICER_DETAILS, policer_details) \
3497 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3498 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3499 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
3500 _(MPLS_TABLE_DETAILS, mpls_table_details) \
3501 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
3502 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3503 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3504 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3505 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3506 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3507 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3508 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3509 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3510 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3511 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3512 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
3513 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
3514 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
3515 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
3516 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3517 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3518 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3519 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3520 _(PG_INTERFACE_ENABLE_DISABLE_COALESCE_REPLY, pg_interface_enable_disable_coalesce_reply) \
3521 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3522 ip_source_and_port_range_check_add_del_reply) \
3523 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3524 ip_source_and_port_range_check_interface_add_del_reply) \
3525 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3526 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3527 _(SET_PUNT_REPLY, set_punt_reply) \
3528 _(IP_TABLE_DETAILS, ip_table_details) \
3529 _(IP_ROUTE_DETAILS, ip_route_details) \
3530 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
3531 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
3532 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
3533 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
3534 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
3535 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
3536 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
3537 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
3538 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
3539 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
3540 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
3541 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
3542 _(SESSION_RULES_DETAILS, session_rules_details) \
3543 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
3544 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
3545 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply) \
3546 _(FLOW_ADD_REPLY, flow_add_reply) \
3548 #define foreach_standalone_reply_msg \
3549 _(SW_INTERFACE_EVENT, sw_interface_event)
3557 #define STR_VTR_OP_CASE(op) \
3558 case L2_VTR_ ## op: \
3562 str_vtr_op (u32 vtr_op)
3566 STR_VTR_OP_CASE (DISABLED);
3567 STR_VTR_OP_CASE (PUSH_1);
3568 STR_VTR_OP_CASE (PUSH_2);
3569 STR_VTR_OP_CASE (POP_1);
3570 STR_VTR_OP_CASE (POP_2);
3571 STR_VTR_OP_CASE (TRANSLATE_1_1);
3572 STR_VTR_OP_CASE (TRANSLATE_1_2);
3573 STR_VTR_OP_CASE (TRANSLATE_2_1);
3574 STR_VTR_OP_CASE (TRANSLATE_2_2);
3581 dump_sub_interface_table (vat_main_t * vam)
3583 const sw_interface_subif_t *sub = NULL;
3585 if (vam->json_output)
3588 ("JSON output supported only for VPE API calls and dump_stats_table");
3593 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
3594 "Interface", "sw_if_index",
3595 "sub id", "dot1ad", "tags", "outer id",
3596 "inner id", "exact", "default", "outer any", "inner any");
3598 vec_foreach (sub, vam->sw_if_subif_table)
3601 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
3602 sub->interface_name,
3604 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3605 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3606 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3607 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3608 if (sub->vtr_op != L2_VTR_DISABLED)
3611 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3612 "tag1: %d tag2: %d ]",
3613 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3614 sub->vtr_tag1, sub->vtr_tag2);
3622 name_sort_cmp (void *a1, void *a2)
3624 name_sort_t *n1 = a1;
3625 name_sort_t *n2 = a2;
3627 return strcmp ((char *) n1->name, (char *) n2->name);
3631 dump_interface_table (vat_main_t * vam)
3634 name_sort_t *nses = 0, *ns;
3636 if (vam->json_output)
3639 ("JSON output supported only for VPE API calls and dump_stats_table");
3644 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3646 vec_add2 (nses, ns, 1);
3647 ns->name = (u8 *)(p->key);
3648 ns->value = (u32) p->value[0];
3652 vec_sort_with_function (nses, name_sort_cmp);
3654 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
3655 vec_foreach (ns, nses)
3657 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
3664 dump_ip_table (vat_main_t * vam, int is_ipv6)
3666 const ip_details_t *det = NULL;
3667 const ip_address_details_t *address = NULL;
3670 print (vam->ofp, "%-12s", "sw_if_index");
3672 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3679 print (vam->ofp, "%-12d", i);
3680 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
3685 vec_foreach (address, det->addr)
3689 is_ipv6 ? format_ip6_address : format_ip4_address,
3690 address->ip, address->prefix_length);
3698 dump_ipv4_table (vat_main_t * vam)
3700 if (vam->json_output)
3703 ("JSON output supported only for VPE API calls and dump_stats_table");
3707 return dump_ip_table (vam, 0);
3711 dump_ipv6_table (vat_main_t * vam)
3713 if (vam->json_output)
3716 ("JSON output supported only for VPE API calls and dump_stats_table");
3720 return dump_ip_table (vam, 1);
3724 * Pass CLI buffers directly in the CLI_INBAND API message,
3725 * instead of an additional shared memory area.
3728 exec_inband (vat_main_t * vam)
3730 vl_api_cli_inband_t *mp;
3731 unformat_input_t *i = vam->input;
3734 if (vec_len (i->buffer) == 0)
3737 if (vam->exec_mode == 0 && unformat (i, "mode"))
3742 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
3749 * In order for the CLI command to work, it
3750 * must be a vector ending in \n, not a C-string ending
3753 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
3754 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
3758 /* json responses may or may not include a useful reply... */
3759 if (vec_len (vam->cmd_reply))
3760 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
3765 exec (vat_main_t * vam)
3767 return exec_inband (vam);
3771 api_create_loopback (vat_main_t * vam)
3773 unformat_input_t *i = vam->input;
3774 vl_api_create_loopback_t *mp;
3775 vl_api_create_loopback_instance_t *mp_lbi;
3778 u8 is_specified = 0;
3779 u32 user_instance = 0;
3782 clib_memset (mac_address, 0, sizeof (mac_address));
3784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3786 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
3788 if (unformat (i, "instance %d", &user_instance))
3796 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
3797 mp_lbi->is_specified = is_specified;
3799 mp_lbi->user_instance = htonl (user_instance);
3801 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
3806 /* Construct the API message */
3807 M (CREATE_LOOPBACK, mp);
3809 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
3818 api_delete_loopback (vat_main_t * vam)
3820 unformat_input_t *i = vam->input;
3821 vl_api_delete_loopback_t *mp;
3822 u32 sw_if_index = ~0;
3825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3827 if (unformat (i, "sw_if_index %d", &sw_if_index))
3833 if (sw_if_index == ~0)
3835 errmsg ("missing sw_if_index");
3839 /* Construct the API message */
3840 M (DELETE_LOOPBACK, mp);
3841 mp->sw_if_index = ntohl (sw_if_index);
3849 api_want_interface_events (vat_main_t * vam)
3851 unformat_input_t *i = vam->input;
3852 vl_api_want_interface_events_t *mp;
3856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3858 if (unformat (i, "enable"))
3860 else if (unformat (i, "disable"))
3868 errmsg ("missing enable|disable");
3872 M (WANT_INTERFACE_EVENTS, mp);
3873 mp->enable_disable = enable;
3875 vam->interface_event_display = enable;
3883 /* Note: non-static, called once to set up the initial intfc table */
3885 api_sw_interface_dump (vat_main_t * vam)
3887 vl_api_sw_interface_dump_t *mp;
3888 vl_api_control_ping_t *mp_ping;
3890 name_sort_t *nses = 0, *ns;
3891 sw_interface_subif_t *sub = NULL;
3894 /* Toss the old name table */
3896 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3898 vec_add2 (nses, ns, 1);
3899 ns->name = (u8 *)(p->key);
3900 ns->value = (u32) p->value[0];
3904 hash_free (vam->sw_if_index_by_interface_name);
3906 vec_foreach (ns, nses) vec_free (ns->name);
3910 vec_foreach (sub, vam->sw_if_subif_table)
3912 vec_free (sub->interface_name);
3914 vec_free (vam->sw_if_subif_table);
3916 /* recreate the interface name hash table */
3917 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
3920 * Ask for all interface names. Otherwise, the epic catalog of
3921 * name filters becomes ridiculously long, and vat ends up needing
3922 * to be taught about new interface types.
3924 M (SW_INTERFACE_DUMP, mp);
3927 /* Use a control ping for synchronization */
3928 MPING (CONTROL_PING, mp_ping);
3936 api_sw_interface_set_flags (vat_main_t * vam)
3938 unformat_input_t *i = vam->input;
3939 vl_api_sw_interface_set_flags_t *mp;
3941 u8 sw_if_index_set = 0;
3945 /* Parse args required to build the message */
3946 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3948 if (unformat (i, "admin-up"))
3950 else if (unformat (i, "admin-down"))
3953 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3954 sw_if_index_set = 1;
3955 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3956 sw_if_index_set = 1;
3961 if (sw_if_index_set == 0)
3963 errmsg ("missing interface name or sw_if_index");
3967 /* Construct the API message */
3968 M (SW_INTERFACE_SET_FLAGS, mp);
3969 mp->sw_if_index = ntohl (sw_if_index);
3970 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
3975 /* Wait for a reply, return the good/bad news... */
3981 api_sw_interface_set_rx_mode (vat_main_t * vam)
3983 unformat_input_t *i = vam->input;
3984 vl_api_sw_interface_set_rx_mode_t *mp;
3986 u8 sw_if_index_set = 0;
3988 u8 queue_id_valid = 0;
3990 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
3992 /* Parse args required to build the message */
3993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3995 if (unformat (i, "queue %d", &queue_id))
3997 else if (unformat (i, "polling"))
3998 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
3999 else if (unformat (i, "interrupt"))
4000 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
4001 else if (unformat (i, "adaptive"))
4002 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
4004 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4005 sw_if_index_set = 1;
4006 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4007 sw_if_index_set = 1;
4012 if (sw_if_index_set == 0)
4014 errmsg ("missing interface name or sw_if_index");
4017 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
4019 errmsg ("missing rx-mode");
4023 /* Construct the API message */
4024 M (SW_INTERFACE_SET_RX_MODE, mp);
4025 mp->sw_if_index = ntohl (sw_if_index);
4026 mp->mode = (vl_api_rx_mode_t) mode;
4027 mp->queue_id_valid = queue_id_valid;
4028 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
4033 /* Wait for a reply, return the good/bad news... */
4039 api_sw_interface_set_rx_placement (vat_main_t * vam)
4041 unformat_input_t *i = vam->input;
4042 vl_api_sw_interface_set_rx_placement_t *mp;
4044 u8 sw_if_index_set = 0;
4047 u32 queue_id, thread_index;
4049 /* Parse args required to build the message */
4050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4052 if (unformat (i, "queue %d", &queue_id))
4054 else if (unformat (i, "main"))
4056 else if (unformat (i, "worker %d", &thread_index))
4059 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4060 sw_if_index_set = 1;
4061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4062 sw_if_index_set = 1;
4067 if (sw_if_index_set == 0)
4069 errmsg ("missing interface name or sw_if_index");
4075 /* Construct the API message */
4076 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
4077 mp->sw_if_index = ntohl (sw_if_index);
4078 mp->worker_id = ntohl (thread_index);
4079 mp->queue_id = ntohl (queue_id);
4080 mp->is_main = is_main;
4084 /* Wait for a reply, return the good/bad news... */
4089 static void vl_api_sw_interface_rx_placement_details_t_handler
4090 (vl_api_sw_interface_rx_placement_details_t * mp)
4092 vat_main_t *vam = &vat_main;
4093 u32 worker_id = ntohl (mp->worker_id);
4096 "\n%-11d %-11s %-6d %-5d %-9s",
4097 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
4098 worker_id, ntohl (mp->queue_id),
4100 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
4103 static void vl_api_sw_interface_rx_placement_details_t_handler_json
4104 (vl_api_sw_interface_rx_placement_details_t * mp)
4106 vat_main_t *vam = &vat_main;
4107 vat_json_node_t *node = NULL;
4109 if (VAT_JSON_ARRAY != vam->json_tree.type)
4111 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4112 vat_json_init_array (&vam->json_tree);
4114 node = vat_json_array_add (&vam->json_tree);
4116 vat_json_init_object (node);
4117 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4118 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
4119 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
4120 vat_json_object_add_uint (node, "mode", mp->mode);
4124 api_sw_interface_rx_placement_dump (vat_main_t * vam)
4126 unformat_input_t *i = vam->input;
4127 vl_api_sw_interface_rx_placement_dump_t *mp;
4128 vl_api_control_ping_t *mp_ping;
4131 u8 sw_if_index_set = 0;
4133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4135 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4137 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4144 "\n%-11s %-11s %-6s %-5s %-4s",
4145 "sw_if_index", "main/worker", "thread", "queue", "mode");
4147 /* Dump Interface rx placement */
4148 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
4150 if (sw_if_index_set)
4151 mp->sw_if_index = htonl (sw_if_index);
4153 mp->sw_if_index = ~0;
4157 /* Use a control ping for synchronization */
4158 MPING (CONTROL_PING, mp_ping);
4166 api_sw_interface_clear_stats (vat_main_t * vam)
4168 unformat_input_t *i = vam->input;
4169 vl_api_sw_interface_clear_stats_t *mp;
4171 u8 sw_if_index_set = 0;
4174 /* Parse args required to build the message */
4175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4177 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4178 sw_if_index_set = 1;
4179 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4180 sw_if_index_set = 1;
4185 /* Construct the API message */
4186 M (SW_INTERFACE_CLEAR_STATS, mp);
4188 if (sw_if_index_set == 1)
4189 mp->sw_if_index = ntohl (sw_if_index);
4191 mp->sw_if_index = ~0;
4196 /* Wait for a reply, return the good/bad news... */
4202 api_sw_interface_add_del_address (vat_main_t * vam)
4204 unformat_input_t *i = vam->input;
4205 vl_api_sw_interface_add_del_address_t *mp;
4207 u8 sw_if_index_set = 0;
4208 u8 is_add = 1, del_all = 0;
4209 u32 address_length = 0;
4210 u8 v4_address_set = 0;
4211 u8 v6_address_set = 0;
4212 ip4_address_t v4address;
4213 ip6_address_t v6address;
4216 /* Parse args required to build the message */
4217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4219 if (unformat (i, "del-all"))
4221 else if (unformat (i, "del"))
4224 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4225 sw_if_index_set = 1;
4226 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4227 sw_if_index_set = 1;
4228 else if (unformat (i, "%U/%d",
4229 unformat_ip4_address, &v4address, &address_length))
4231 else if (unformat (i, "%U/%d",
4232 unformat_ip6_address, &v6address, &address_length))
4238 if (sw_if_index_set == 0)
4240 errmsg ("missing interface name or sw_if_index");
4243 if (v4_address_set && v6_address_set)
4245 errmsg ("both v4 and v6 addresses set");
4248 if (!v4_address_set && !v6_address_set && !del_all)
4250 errmsg ("no addresses set");
4254 /* Construct the API message */
4255 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
4257 mp->sw_if_index = ntohl (sw_if_index);
4258 mp->is_add = is_add;
4259 mp->del_all = del_all;
4262 mp->prefix.address.af = ADDRESS_IP6;
4263 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
4267 mp->prefix.address.af = ADDRESS_IP4;
4268 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
4270 mp->prefix.len = address_length;
4275 /* Wait for a reply, return good/bad news */
4281 api_sw_interface_set_mpls_enable (vat_main_t * vam)
4283 unformat_input_t *i = vam->input;
4284 vl_api_sw_interface_set_mpls_enable_t *mp;
4286 u8 sw_if_index_set = 0;
4290 /* Parse args required to build the message */
4291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4293 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4294 sw_if_index_set = 1;
4295 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4296 sw_if_index_set = 1;
4297 else if (unformat (i, "disable"))
4299 else if (unformat (i, "dis"))
4305 if (sw_if_index_set == 0)
4307 errmsg ("missing interface name or sw_if_index");
4311 /* Construct the API message */
4312 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
4314 mp->sw_if_index = ntohl (sw_if_index);
4315 mp->enable = enable;
4320 /* Wait for a reply... */
4326 api_sw_interface_set_table (vat_main_t * vam)
4328 unformat_input_t *i = vam->input;
4329 vl_api_sw_interface_set_table_t *mp;
4330 u32 sw_if_index, vrf_id = 0;
4331 u8 sw_if_index_set = 0;
4335 /* Parse args required to build the message */
4336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4338 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4339 sw_if_index_set = 1;
4340 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4341 sw_if_index_set = 1;
4342 else if (unformat (i, "vrf %d", &vrf_id))
4344 else if (unformat (i, "ipv6"))
4350 if (sw_if_index_set == 0)
4352 errmsg ("missing interface name or sw_if_index");
4356 /* Construct the API message */
4357 M (SW_INTERFACE_SET_TABLE, mp);
4359 mp->sw_if_index = ntohl (sw_if_index);
4360 mp->is_ipv6 = is_ipv6;
4361 mp->vrf_id = ntohl (vrf_id);
4366 /* Wait for a reply... */
4371 static void vl_api_sw_interface_get_table_reply_t_handler
4372 (vl_api_sw_interface_get_table_reply_t * mp)
4374 vat_main_t *vam = &vat_main;
4376 print (vam->ofp, "%d", ntohl (mp->vrf_id));
4378 vam->retval = ntohl (mp->retval);
4379 vam->result_ready = 1;
4383 static void vl_api_sw_interface_get_table_reply_t_handler_json
4384 (vl_api_sw_interface_get_table_reply_t * mp)
4386 vat_main_t *vam = &vat_main;
4387 vat_json_node_t node;
4389 vat_json_init_object (&node);
4390 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4391 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
4393 vat_json_print (vam->ofp, &node);
4394 vat_json_free (&node);
4396 vam->retval = ntohl (mp->retval);
4397 vam->result_ready = 1;
4401 api_sw_interface_get_table (vat_main_t * vam)
4403 unformat_input_t *i = vam->input;
4404 vl_api_sw_interface_get_table_t *mp;
4406 u8 sw_if_index_set = 0;
4410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4412 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4413 sw_if_index_set = 1;
4414 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4415 sw_if_index_set = 1;
4416 else if (unformat (i, "ipv6"))
4422 if (sw_if_index_set == 0)
4424 errmsg ("missing interface name or sw_if_index");
4428 M (SW_INTERFACE_GET_TABLE, mp);
4429 mp->sw_if_index = htonl (sw_if_index);
4430 mp->is_ipv6 = is_ipv6;
4438 api_sw_interface_set_vpath (vat_main_t * vam)
4440 unformat_input_t *i = vam->input;
4441 vl_api_sw_interface_set_vpath_t *mp;
4442 u32 sw_if_index = 0;
4443 u8 sw_if_index_set = 0;
4447 /* Parse args required to build the message */
4448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4450 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4451 sw_if_index_set = 1;
4452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4453 sw_if_index_set = 1;
4454 else if (unformat (i, "enable"))
4456 else if (unformat (i, "disable"))
4462 if (sw_if_index_set == 0)
4464 errmsg ("missing interface name or sw_if_index");
4468 /* Construct the API message */
4469 M (SW_INTERFACE_SET_VPATH, mp);
4471 mp->sw_if_index = ntohl (sw_if_index);
4472 mp->enable = is_enable;
4477 /* Wait for a reply... */
4483 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
4485 unformat_input_t *i = vam->input;
4486 vl_api_sw_interface_set_vxlan_bypass_t *mp;
4487 u32 sw_if_index = 0;
4488 u8 sw_if_index_set = 0;
4493 /* Parse args required to build the message */
4494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4496 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4497 sw_if_index_set = 1;
4498 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4499 sw_if_index_set = 1;
4500 else if (unformat (i, "enable"))
4502 else if (unformat (i, "disable"))
4504 else if (unformat (i, "ip4"))
4506 else if (unformat (i, "ip6"))
4512 if (sw_if_index_set == 0)
4514 errmsg ("missing interface name or sw_if_index");
4518 /* Construct the API message */
4519 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
4521 mp->sw_if_index = ntohl (sw_if_index);
4522 mp->enable = is_enable;
4523 mp->is_ipv6 = is_ipv6;
4528 /* Wait for a reply... */
4534 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4536 unformat_input_t *i = vam->input;
4537 vl_api_sw_interface_set_l2_xconnect_t *mp;
4539 u8 rx_sw_if_index_set = 0;
4541 u8 tx_sw_if_index_set = 0;
4545 /* Parse args required to build the message */
4546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4548 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4549 rx_sw_if_index_set = 1;
4550 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4551 tx_sw_if_index_set = 1;
4552 else if (unformat (i, "rx"))
4554 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4556 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4558 rx_sw_if_index_set = 1;
4563 else if (unformat (i, "tx"))
4565 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4567 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4569 tx_sw_if_index_set = 1;
4574 else if (unformat (i, "enable"))
4576 else if (unformat (i, "disable"))
4582 if (rx_sw_if_index_set == 0)
4584 errmsg ("missing rx interface name or rx_sw_if_index");
4588 if (enable && (tx_sw_if_index_set == 0))
4590 errmsg ("missing tx interface name or tx_sw_if_index");
4594 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
4596 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4597 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4598 mp->enable = enable;
4606 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4608 unformat_input_t *i = vam->input;
4609 vl_api_sw_interface_set_l2_bridge_t *mp;
4610 vl_api_l2_port_type_t port_type;
4612 u8 rx_sw_if_index_set = 0;
4619 port_type = L2_API_PORT_TYPE_NORMAL;
4621 /* Parse args required to build the message */
4622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4624 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4625 rx_sw_if_index_set = 1;
4626 else if (unformat (i, "bd_id %d", &bd_id))
4630 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
4631 rx_sw_if_index_set = 1;
4632 else if (unformat (i, "shg %d", &shg))
4634 else if (unformat (i, "bvi"))
4635 port_type = L2_API_PORT_TYPE_BVI;
4636 else if (unformat (i, "uu-fwd"))
4637 port_type = L2_API_PORT_TYPE_UU_FWD;
4638 else if (unformat (i, "enable"))
4640 else if (unformat (i, "disable"))
4646 if (rx_sw_if_index_set == 0)
4648 errmsg ("missing rx interface name or sw_if_index");
4652 if (enable && (bd_id_set == 0))
4654 errmsg ("missing bridge domain");
4658 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
4660 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4661 mp->bd_id = ntohl (bd_id);
4663 mp->port_type = ntohl (port_type);
4664 mp->enable = enable;
4672 api_bridge_domain_dump (vat_main_t * vam)
4674 unformat_input_t *i = vam->input;
4675 vl_api_bridge_domain_dump_t *mp;
4676 vl_api_control_ping_t *mp_ping;
4680 /* Parse args required to build the message */
4681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4683 if (unformat (i, "bd_id %d", &bd_id))
4689 M (BRIDGE_DOMAIN_DUMP, mp);
4690 mp->bd_id = ntohl (bd_id);
4693 /* Use a control ping for synchronization */
4694 MPING (CONTROL_PING, mp_ping);
4702 api_bridge_domain_add_del (vat_main_t * vam)
4704 unformat_input_t *i = vam->input;
4705 vl_api_bridge_domain_add_del_t *mp;
4708 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4713 /* Parse args required to build the message */
4714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4716 if (unformat (i, "bd_id %d", &bd_id))
4718 else if (unformat (i, "flood %d", &flood))
4720 else if (unformat (i, "uu-flood %d", &uu_flood))
4722 else if (unformat (i, "forward %d", &forward))
4724 else if (unformat (i, "learn %d", &learn))
4726 else if (unformat (i, "arp-term %d", &arp_term))
4728 else if (unformat (i, "mac-age %d", &mac_age))
4730 else if (unformat (i, "bd-tag %s", &bd_tag))
4732 else if (unformat (i, "del"))
4735 flood = uu_flood = forward = learn = 0;
4743 errmsg ("missing bridge domain");
4750 errmsg ("mac age must be less than 256 ");
4755 if ((bd_tag) && (vec_len (bd_tag) > 63))
4757 errmsg ("bd-tag cannot be longer than 63");
4762 M (BRIDGE_DOMAIN_ADD_DEL, mp);
4764 mp->bd_id = ntohl (bd_id);
4766 mp->uu_flood = uu_flood;
4767 mp->forward = forward;
4769 mp->arp_term = arp_term;
4770 mp->is_add = is_add;
4771 mp->mac_age = (u8) mac_age;
4774 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
4775 mp->bd_tag[vec_len (bd_tag)] = 0;
4786 api_l2fib_flush_bd (vat_main_t * vam)
4788 unformat_input_t *i = vam->input;
4789 vl_api_l2fib_flush_bd_t *mp;
4793 /* Parse args required to build the message */
4794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4796 if (unformat (i, "bd_id %d", &bd_id));
4803 errmsg ("missing bridge domain");
4807 M (L2FIB_FLUSH_BD, mp);
4809 mp->bd_id = htonl (bd_id);
4817 api_l2fib_flush_int (vat_main_t * vam)
4819 unformat_input_t *i = vam->input;
4820 vl_api_l2fib_flush_int_t *mp;
4821 u32 sw_if_index = ~0;
4824 /* Parse args required to build the message */
4825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4827 if (unformat (i, "sw_if_index %d", &sw_if_index));
4829 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
4834 if (sw_if_index == ~0)
4836 errmsg ("missing interface name or sw_if_index");
4840 M (L2FIB_FLUSH_INT, mp);
4842 mp->sw_if_index = ntohl (sw_if_index);
4850 api_l2fib_add_del (vat_main_t * vam)
4852 unformat_input_t *i = vam->input;
4853 vl_api_l2fib_add_del_t *mp;
4859 u32 sw_if_index = 0;
4860 u8 sw_if_index_set = 0;
4869 /* Parse args required to build the message */
4870 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4872 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
4874 else if (unformat (i, "bd_id %d", &bd_id))
4876 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4877 sw_if_index_set = 1;
4878 else if (unformat (i, "sw_if"))
4880 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4883 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4884 sw_if_index_set = 1;
4889 else if (unformat (i, "static"))
4891 else if (unformat (i, "filter"))
4896 else if (unformat (i, "bvi"))
4901 else if (unformat (i, "del"))
4903 else if (unformat (i, "count %d", &count))
4911 errmsg ("missing mac address");
4917 errmsg ("missing bridge domain");
4921 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
4923 errmsg ("missing interface name or sw_if_index");
4929 /* Turn on async mode */
4930 vam->async_mode = 1;
4931 vam->async_errors = 0;
4932 before = vat_time_now (vam);
4935 for (j = 0; j < count; j++)
4937 M (L2FIB_ADD_DEL, mp);
4939 clib_memcpy (mp->mac, mac, 6);
4940 mp->bd_id = ntohl (bd_id);
4941 mp->is_add = is_add;
4942 mp->sw_if_index = ntohl (sw_if_index);
4946 mp->static_mac = static_mac;
4947 mp->filter_mac = filter_mac;
4948 mp->bvi_mac = bvi_mac;
4950 increment_mac_address (mac);
4957 vl_api_control_ping_t *mp_ping;
4960 /* Shut off async mode */
4961 vam->async_mode = 0;
4963 MPING (CONTROL_PING, mp_ping);
4966 timeout = vat_time_now (vam) + 1.0;
4967 while (vat_time_now (vam) < timeout)
4968 if (vam->result_ready == 1)
4973 if (vam->retval == -99)
4976 if (vam->async_errors > 0)
4978 errmsg ("%d asynchronous errors", vam->async_errors);
4981 vam->async_errors = 0;
4982 after = vat_time_now (vam);
4984 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4985 count, after - before, count / (after - before));
4991 /* Wait for a reply... */
4995 /* Return the good/bad news */
4996 return (vam->retval);
5000 api_bridge_domain_set_mac_age (vat_main_t * vam)
5002 unformat_input_t *i = vam->input;
5003 vl_api_bridge_domain_set_mac_age_t *mp;
5008 /* Parse args required to build the message */
5009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5011 if (unformat (i, "bd_id %d", &bd_id));
5012 else if (unformat (i, "mac-age %d", &mac_age));
5019 errmsg ("missing bridge domain");
5025 errmsg ("mac age must be less than 256 ");
5029 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
5031 mp->bd_id = htonl (bd_id);
5032 mp->mac_age = (u8) mac_age;
5040 api_l2_flags (vat_main_t * vam)
5042 unformat_input_t *i = vam->input;
5043 vl_api_l2_flags_t *mp;
5046 u8 sw_if_index_set = 0;
5050 /* Parse args required to build the message */
5051 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5053 if (unformat (i, "sw_if_index %d", &sw_if_index))
5054 sw_if_index_set = 1;
5055 else if (unformat (i, "sw_if"))
5057 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5060 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5061 sw_if_index_set = 1;
5066 else if (unformat (i, "learn"))
5068 else if (unformat (i, "forward"))
5070 else if (unformat (i, "flood"))
5072 else if (unformat (i, "uu-flood"))
5073 flags |= L2_UU_FLOOD;
5074 else if (unformat (i, "arp-term"))
5075 flags |= L2_ARP_TERM;
5076 else if (unformat (i, "off"))
5078 else if (unformat (i, "disable"))
5084 if (sw_if_index_set == 0)
5086 errmsg ("missing interface name or sw_if_index");
5092 mp->sw_if_index = ntohl (sw_if_index);
5093 mp->feature_bitmap = ntohl (flags);
5094 mp->is_set = is_set;
5102 api_bridge_flags (vat_main_t * vam)
5104 unformat_input_t *i = vam->input;
5105 vl_api_bridge_flags_t *mp;
5109 bd_flags_t flags = 0;
5112 /* Parse args required to build the message */
5113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5115 if (unformat (i, "bd_id %d", &bd_id))
5117 else if (unformat (i, "learn"))
5118 flags |= BRIDGE_API_FLAG_LEARN;
5119 else if (unformat (i, "forward"))
5120 flags |= BRIDGE_API_FLAG_FWD;
5121 else if (unformat (i, "flood"))
5122 flags |= BRIDGE_API_FLAG_FLOOD;
5123 else if (unformat (i, "uu-flood"))
5124 flags |= BRIDGE_API_FLAG_UU_FLOOD;
5125 else if (unformat (i, "arp-term"))
5126 flags |= BRIDGE_API_FLAG_ARP_TERM;
5127 else if (unformat (i, "off"))
5129 else if (unformat (i, "disable"))
5137 errmsg ("missing bridge domain");
5141 M (BRIDGE_FLAGS, mp);
5143 mp->bd_id = ntohl (bd_id);
5144 mp->flags = ntohl (flags);
5145 mp->is_set = is_set;
5153 api_bd_ip_mac_add_del (vat_main_t * vam)
5155 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
5156 vl_api_mac_address_t mac = { 0 };
5157 unformat_input_t *i = vam->input;
5158 vl_api_bd_ip_mac_add_del_t *mp;
5167 /* Parse args required to build the message */
5168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5170 if (unformat (i, "bd_id %d", &bd_id))
5174 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
5178 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
5182 else if (unformat (i, "del"))
5190 errmsg ("missing bridge domain");
5193 else if (ip_set == 0)
5195 errmsg ("missing IP address");
5198 else if (mac_set == 0)
5200 errmsg ("missing MAC address");
5204 M (BD_IP_MAC_ADD_DEL, mp);
5206 mp->entry.bd_id = ntohl (bd_id);
5207 mp->is_add = is_add;
5209 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
5210 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
5218 api_bd_ip_mac_flush (vat_main_t * vam)
5220 unformat_input_t *i = vam->input;
5221 vl_api_bd_ip_mac_flush_t *mp;
5226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5228 if (unformat (i, "bd_id %d", &bd_id))
5238 errmsg ("missing bridge domain");
5242 M (BD_IP_MAC_FLUSH, mp);
5244 mp->bd_id = ntohl (bd_id);
5251 static void vl_api_bd_ip_mac_details_t_handler
5252 (vl_api_bd_ip_mac_details_t * mp)
5254 vat_main_t *vam = &vat_main;
5258 ntohl (mp->entry.bd_id),
5259 format_vl_api_mac_address, mp->entry.mac,
5260 format_vl_api_address, &mp->entry.ip);
5263 static void vl_api_bd_ip_mac_details_t_handler_json
5264 (vl_api_bd_ip_mac_details_t * mp)
5266 vat_main_t *vam = &vat_main;
5267 vat_json_node_t *node = NULL;
5269 if (VAT_JSON_ARRAY != vam->json_tree.type)
5271 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5272 vat_json_init_array (&vam->json_tree);
5274 node = vat_json_array_add (&vam->json_tree);
5276 vat_json_init_object (node);
5277 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
5278 vat_json_object_add_string_copy (node, "mac_address",
5279 format (0, "%U", format_vl_api_mac_address,
5283 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
5284 vat_json_object_add_string_copy (node, "ip_address", ip);
5289 api_bd_ip_mac_dump (vat_main_t * vam)
5291 unformat_input_t *i = vam->input;
5292 vl_api_bd_ip_mac_dump_t *mp;
5293 vl_api_control_ping_t *mp_ping;
5298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5300 if (unformat (i, "bd_id %d", &bd_id))
5309 "\n%-5s %-7s %-20s %-30s",
5310 "bd_id", "is_ipv6", "mac_address", "ip_address");
5312 /* Dump Bridge Domain Ip to Mac entries */
5313 M (BD_IP_MAC_DUMP, mp);
5316 mp->bd_id = htonl (bd_id);
5322 /* Use a control ping for synchronization */
5323 MPING (CONTROL_PING, mp_ping);
5331 api_tap_create_v2 (vat_main_t * vam)
5333 unformat_input_t *i = vam->input;
5334 vl_api_tap_create_v2_t *mp;
5338 u32 num_rx_queues = 0;
5339 u8 *host_if_name = 0;
5340 u8 host_if_name_set = 0;
5343 u8 host_mac_addr[6];
5344 u8 host_mac_addr_set = 0;
5345 u8 *host_bridge = 0;
5346 u8 host_bridge_set = 0;
5347 u8 host_ip4_prefix_set = 0;
5348 u8 host_ip6_prefix_set = 0;
5349 ip4_address_t host_ip4_addr;
5350 ip4_address_t host_ip4_gw;
5351 u8 host_ip4_gw_set = 0;
5352 u32 host_ip4_prefix_len = 0;
5353 ip6_address_t host_ip6_addr;
5354 ip6_address_t host_ip6_gw;
5355 u8 host_ip6_gw_set = 0;
5356 u32 host_ip6_prefix_len = 0;
5357 u32 host_mtu_size = 0;
5358 u8 host_mtu_set = 0;
5361 u32 rx_ring_sz = 0, tx_ring_sz = 0;
5363 clib_memset (mac_address, 0, sizeof (mac_address));
5365 /* Parse args required to build the message */
5366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5368 if (unformat (i, "id %u", &id))
5372 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
5374 else if (unformat (i, "host-if-name %s", &host_if_name))
5375 host_if_name_set = 1;
5376 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
5378 else if (unformat (i, "host-ns %s", &host_ns))
5380 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
5382 host_mac_addr_set = 1;
5383 else if (unformat (i, "host-bridge %s", &host_bridge))
5384 host_bridge_set = 1;
5385 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
5386 &host_ip4_addr, &host_ip4_prefix_len))
5387 host_ip4_prefix_set = 1;
5388 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
5389 &host_ip6_addr, &host_ip6_prefix_len))
5390 host_ip6_prefix_set = 1;
5391 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
5393 host_ip4_gw_set = 1;
5394 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
5396 host_ip6_gw_set = 1;
5397 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
5399 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
5401 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
5403 else if (unformat (i, "no-gso"))
5404 tap_flags &= ~TAP_API_FLAG_GSO;
5405 else if (unformat (i, "gso"))
5406 tap_flags |= TAP_API_FLAG_GSO;
5407 else if (unformat (i, "csum-offload"))
5408 tap_flags |= TAP_API_FLAG_CSUM_OFFLOAD;
5409 else if (unformat (i, "persist"))
5410 tap_flags |= TAP_API_FLAG_PERSIST;
5411 else if (unformat (i, "attach"))
5412 tap_flags |= TAP_API_FLAG_ATTACH;
5413 else if (unformat (i, "tun"))
5414 tap_flags |= TAP_API_FLAG_TUN;
5415 else if (unformat (i, "gro-coalesce"))
5416 tap_flags |= TAP_API_FLAG_GRO_COALESCE;
5417 else if (unformat (i, "packed"))
5418 tap_flags |= TAP_API_FLAG_PACKED;
5419 else if (unformat (i, "in-order"))
5420 tap_flags |= TAP_API_FLAG_IN_ORDER;
5425 if (vec_len (host_if_name) > 63)
5427 errmsg ("tap name too long. ");
5430 if (vec_len (host_ns) > 63)
5432 errmsg ("host name space too long. ");
5435 if (vec_len (host_bridge) > 63)
5437 errmsg ("host bridge name too long. ");
5440 if (host_ip4_prefix_len > 32)
5442 errmsg ("host ip4 prefix length not valid. ");
5445 if (host_ip6_prefix_len > 128)
5447 errmsg ("host ip6 prefix length not valid. ");
5450 if (!is_pow2 (rx_ring_sz))
5452 errmsg ("rx ring size must be power of 2. ");
5455 if (rx_ring_sz > 32768)
5457 errmsg ("rx ring size must be 32768 or lower. ");
5460 if (!is_pow2 (tx_ring_sz))
5462 errmsg ("tx ring size must be power of 2. ");
5465 if (tx_ring_sz > 32768)
5467 errmsg ("tx ring size must be 32768 or lower. ");
5470 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
5472 errmsg ("host MTU size must be in between 64 and 65355. ");
5476 /* Construct the API message */
5477 M (TAP_CREATE_V2, mp);
5479 mp->id = ntohl (id);
5480 mp->use_random_mac = random_mac;
5481 mp->num_rx_queues = (u8) num_rx_queues;
5482 mp->tx_ring_sz = ntohs (tx_ring_sz);
5483 mp->rx_ring_sz = ntohs (rx_ring_sz);
5484 mp->host_mtu_set = host_mtu_set;
5485 mp->host_mtu_size = ntohl (host_mtu_size);
5486 mp->host_mac_addr_set = host_mac_addr_set;
5487 mp->host_ip4_prefix_set = host_ip4_prefix_set;
5488 mp->host_ip6_prefix_set = host_ip6_prefix_set;
5489 mp->host_ip4_gw_set = host_ip4_gw_set;
5490 mp->host_ip6_gw_set = host_ip6_gw_set;
5491 mp->tap_flags = ntohl (tap_flags);
5492 mp->host_namespace_set = host_ns_set;
5493 mp->host_if_name_set = host_if_name_set;
5494 mp->host_bridge_set = host_bridge_set;
5496 if (random_mac == 0)
5497 clib_memcpy (mp->mac_address, mac_address, 6);
5498 if (host_mac_addr_set)
5499 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
5500 if (host_if_name_set)
5501 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
5503 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
5504 if (host_bridge_set)
5505 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
5506 if (host_ip4_prefix_set)
5508 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
5509 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
5511 if (host_ip6_prefix_set)
5513 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
5514 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
5516 if (host_ip4_gw_set)
5517 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
5518 if (host_ip6_gw_set)
5519 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
5522 vec_free (host_if_name);
5523 vec_free (host_bridge);
5528 /* Wait for a reply... */
5534 api_tap_delete_v2 (vat_main_t * vam)
5536 unformat_input_t *i = vam->input;
5537 vl_api_tap_delete_v2_t *mp;
5538 u32 sw_if_index = ~0;
5539 u8 sw_if_index_set = 0;
5542 /* Parse args required to build the message */
5543 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5545 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5546 sw_if_index_set = 1;
5547 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5548 sw_if_index_set = 1;
5553 if (sw_if_index_set == 0)
5555 errmsg ("missing vpp interface name. ");
5559 /* Construct the API message */
5560 M (TAP_DELETE_V2, mp);
5562 mp->sw_if_index = ntohl (sw_if_index);
5567 /* Wait for a reply... */
5573 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
5575 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
5578 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
5581 addr->domain = x[0];
5584 addr->function = x[3];
5590 api_virtio_pci_create_v2 (vat_main_t * vam)
5592 unformat_input_t *i = vam->input;
5593 vl_api_virtio_pci_create_v2_t *mp;
5597 u64 features = (u64) ~ (0ULL);
5598 u32 virtio_flags = 0;
5601 clib_memset (mac_address, 0, sizeof (mac_address));
5603 /* Parse args required to build the message */
5604 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5606 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
5610 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
5612 else if (unformat (i, "features 0x%llx", &features))
5614 else if (unformat (i, "gso-enabled"))
5615 virtio_flags |= VIRTIO_API_FLAG_GSO;
5616 else if (unformat (i, "csum-offload-enabled"))
5617 virtio_flags |= VIRTIO_API_FLAG_CSUM_OFFLOAD;
5618 else if (unformat (i, "gro-coalesce"))
5619 virtio_flags |= VIRTIO_API_FLAG_GRO_COALESCE;
5620 else if (unformat (i, "packed"))
5621 virtio_flags |= VIRTIO_API_FLAG_PACKED;
5622 else if (unformat (i, "in-order"))
5623 virtio_flags |= VIRTIO_API_FLAG_IN_ORDER;
5630 errmsg ("pci address must be non zero. ");
5634 /* Construct the API message */
5635 M (VIRTIO_PCI_CREATE_V2, mp);
5637 mp->use_random_mac = random_mac;
5639 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
5640 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
5641 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
5642 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
5644 mp->features = clib_host_to_net_u64 (features);
5645 mp->virtio_flags = clib_host_to_net_u32 (virtio_flags);
5647 if (random_mac == 0)
5648 clib_memcpy (mp->mac_address, mac_address, 6);
5653 /* Wait for a reply... */
5659 api_virtio_pci_delete (vat_main_t * vam)
5661 unformat_input_t *i = vam->input;
5662 vl_api_virtio_pci_delete_t *mp;
5663 u32 sw_if_index = ~0;
5664 u8 sw_if_index_set = 0;
5667 /* Parse args required to build the message */
5668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5670 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5671 sw_if_index_set = 1;
5672 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5673 sw_if_index_set = 1;
5678 if (sw_if_index_set == 0)
5680 errmsg ("missing vpp interface name. ");
5684 /* Construct the API message */
5685 M (VIRTIO_PCI_DELETE, mp);
5687 mp->sw_if_index = htonl (sw_if_index);
5692 /* Wait for a reply... */
5698 api_bond_create (vat_main_t * vam)
5700 unformat_input_t *i = vam->input;
5701 vl_api_bond_create_t *mp;
5711 clib_memset (mac_address, 0, sizeof (mac_address));
5714 /* Parse args required to build the message */
5715 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5717 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
5719 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
5720 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
5722 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
5725 else if (unformat (i, "numa-only"))
5727 else if (unformat (i, "id %u", &id))
5733 if (mode_is_set == 0)
5735 errmsg ("Missing bond mode. ");
5739 /* Construct the API message */
5740 M (BOND_CREATE, mp);
5742 mp->use_custom_mac = custom_mac;
5744 mp->mode = htonl (mode);
5745 mp->lb = htonl (lb);
5746 mp->id = htonl (id);
5747 mp->numa_only = numa_only;
5750 clib_memcpy (mp->mac_address, mac_address, 6);
5755 /* Wait for a reply... */
5761 api_bond_create2 (vat_main_t * vam)
5763 unformat_input_t *i = vam->input;
5764 vl_api_bond_create2_t *mp;
5775 clib_memset (mac_address, 0, sizeof (mac_address));
5778 /* Parse args required to build the message */
5779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5781 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
5783 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
5784 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
5786 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
5789 else if (unformat (i, "numa-only"))
5791 else if (unformat (i, "gso"))
5793 else if (unformat (i, "id %u", &id))
5799 if (mode_is_set == 0)
5801 errmsg ("Missing bond mode. ");
5805 /* Construct the API message */
5806 M (BOND_CREATE2, mp);
5808 mp->use_custom_mac = custom_mac;
5810 mp->mode = htonl (mode);
5811 mp->lb = htonl (lb);
5812 mp->id = htonl (id);
5813 mp->numa_only = numa_only;
5814 mp->enable_gso = gso;
5817 clib_memcpy (mp->mac_address, mac_address, 6);
5822 /* Wait for a reply... */
5828 api_bond_delete (vat_main_t * vam)
5830 unformat_input_t *i = vam->input;
5831 vl_api_bond_delete_t *mp;
5832 u32 sw_if_index = ~0;
5833 u8 sw_if_index_set = 0;
5836 /* Parse args required to build the message */
5837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5839 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5840 sw_if_index_set = 1;
5841 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5842 sw_if_index_set = 1;
5847 if (sw_if_index_set == 0)
5849 errmsg ("missing vpp interface name. ");
5853 /* Construct the API message */
5854 M (BOND_DELETE, mp);
5856 mp->sw_if_index = ntohl (sw_if_index);
5861 /* Wait for a reply... */
5867 api_bond_add_member (vat_main_t * vam)
5869 unformat_input_t *i = vam->input;
5870 vl_api_bond_add_member_t *mp;
5871 u32 bond_sw_if_index;
5875 u32 bond_sw_if_index_is_set = 0;
5877 u8 sw_if_index_is_set = 0;
5879 /* Parse args required to build the message */
5880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5882 if (unformat (i, "sw_if_index %d", &sw_if_index))
5883 sw_if_index_is_set = 1;
5884 else if (unformat (i, "bond %u", &bond_sw_if_index))
5885 bond_sw_if_index_is_set = 1;
5886 else if (unformat (i, "passive %d", &is_passive))
5888 else if (unformat (i, "long-timeout %d", &is_long_timeout))
5894 if (bond_sw_if_index_is_set == 0)
5896 errmsg ("Missing bond sw_if_index. ");
5899 if (sw_if_index_is_set == 0)
5901 errmsg ("Missing member sw_if_index. ");
5905 /* Construct the API message */
5906 M (BOND_ADD_MEMBER, mp);
5908 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
5909 mp->sw_if_index = ntohl (sw_if_index);
5910 mp->is_long_timeout = is_long_timeout;
5911 mp->is_passive = is_passive;
5916 /* Wait for a reply... */
5922 api_bond_detach_member (vat_main_t * vam)
5924 unformat_input_t *i = vam->input;
5925 vl_api_bond_detach_member_t *mp;
5926 u32 sw_if_index = ~0;
5927 u8 sw_if_index_set = 0;
5930 /* Parse args required to build the message */
5931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5933 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5934 sw_if_index_set = 1;
5935 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5936 sw_if_index_set = 1;
5941 if (sw_if_index_set == 0)
5943 errmsg ("missing vpp interface name. ");
5947 /* Construct the API message */
5948 M (BOND_DETACH_MEMBER, mp);
5950 mp->sw_if_index = ntohl (sw_if_index);
5955 /* Wait for a reply... */
5961 api_ip_table_add_del (vat_main_t * vam)
5963 unformat_input_t *i = vam->input;
5964 vl_api_ip_table_add_del_t *mp;
5970 /* Parse args required to build the message */
5971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5973 if (unformat (i, "ipv6"))
5975 else if (unformat (i, "del"))
5977 else if (unformat (i, "add"))
5979 else if (unformat (i, "table %d", &table_id))
5983 clib_warning ("parse error '%U'", format_unformat_error, i);
5990 errmsg ("missing table-ID");
5994 /* Construct the API message */
5995 M (IP_TABLE_ADD_DEL, mp);
5997 mp->table.table_id = ntohl (table_id);
5998 mp->table.is_ip6 = is_ipv6;
5999 mp->is_add = is_add;
6004 /* Wait for a reply... */
6011 unformat_fib_path (unformat_input_t * input, va_list * args)
6013 vat_main_t *vam = va_arg (*args, vat_main_t *);
6014 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
6015 u32 weight, preference;
6016 mpls_label_t out_label;
6018 clib_memset (path, 0, sizeof (*path));
6020 path->sw_if_index = ~0;
6024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6026 if (unformat (input, "%U %U",
6027 unformat_vl_api_ip4_address,
6028 &path->nh.address.ip4,
6029 api_unformat_sw_if_index, vam, &path->sw_if_index))
6031 path->proto = FIB_API_PATH_NH_PROTO_IP4;
6033 else if (unformat (input, "%U %U",
6034 unformat_vl_api_ip6_address,
6035 &path->nh.address.ip6,
6036 api_unformat_sw_if_index, vam, &path->sw_if_index))
6038 path->proto = FIB_API_PATH_NH_PROTO_IP6;
6040 else if (unformat (input, "weight %u", &weight))
6042 path->weight = weight;
6044 else if (unformat (input, "preference %u", &preference))
6046 path->preference = preference;
6048 else if (unformat (input, "%U next-hop-table %d",
6049 unformat_vl_api_ip4_address,
6050 &path->nh.address.ip4, &path->table_id))
6052 path->proto = FIB_API_PATH_NH_PROTO_IP4;
6054 else if (unformat (input, "%U next-hop-table %d",
6055 unformat_vl_api_ip6_address,
6056 &path->nh.address.ip6, &path->table_id))
6058 path->proto = FIB_API_PATH_NH_PROTO_IP6;
6060 else if (unformat (input, "%U",
6061 unformat_vl_api_ip4_address, &path->nh.address.ip4))
6064 * the recursive next-hops are by default in the default table
6067 path->sw_if_index = ~0;
6068 path->proto = FIB_API_PATH_NH_PROTO_IP4;
6070 else if (unformat (input, "%U",
6071 unformat_vl_api_ip6_address, &path->nh.address.ip6))
6074 * the recursive next-hops are by default in the default table
6077 path->sw_if_index = ~0;
6078 path->proto = FIB_API_PATH_NH_PROTO_IP6;
6080 else if (unformat (input, "resolve-via-host"))
6082 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
6084 else if (unformat (input, "resolve-via-attached"))
6086 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
6088 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
6090 path->type = FIB_API_PATH_TYPE_LOCAL;
6091 path->sw_if_index = ~0;
6092 path->proto = FIB_API_PATH_NH_PROTO_IP4;
6094 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
6096 path->type = FIB_API_PATH_TYPE_LOCAL;
6097 path->sw_if_index = ~0;
6098 path->proto = FIB_API_PATH_NH_PROTO_IP6;
6100 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
6102 else if (unformat (input, "via-label %d", &path->nh.via_label))
6104 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
6105 path->sw_if_index = ~0;
6107 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
6109 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
6110 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
6112 else if (unformat (input, "local"))
6114 path->type = FIB_API_PATH_TYPE_LOCAL;
6116 else if (unformat (input, "out-labels"))
6118 while (unformat (input, "%d", &out_label))
6120 path->label_stack[path->n_labels].label = out_label;
6121 path->label_stack[path->n_labels].is_uniform = 0;
6122 path->label_stack[path->n_labels].ttl = 64;
6126 else if (unformat (input, "via"))
6128 /* new path, back up and return */
6129 unformat_put_input (input);
6130 unformat_put_input (input);
6131 unformat_put_input (input);
6132 unformat_put_input (input);
6141 path->proto = ntohl (path->proto);
6142 path->type = ntohl (path->type);
6143 path->flags = ntohl (path->flags);
6144 path->table_id = ntohl (path->table_id);
6145 path->sw_if_index = ntohl (path->sw_if_index);
6151 api_ip_route_add_del (vat_main_t * vam)
6153 unformat_input_t *i = vam->input;
6154 vl_api_ip_route_add_del_t *mp;
6157 u8 is_multipath = 0;
6160 vl_api_prefix_t pfx = { };
6161 vl_api_fib_path_t paths[8];
6165 u32 random_add_del = 0;
6166 u32 *random_vector = 0;
6167 u32 random_seed = 0xdeaddabe;
6169 /* Parse args required to build the message */
6170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6172 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
6174 else if (unformat (i, "del"))
6176 else if (unformat (i, "add"))
6178 else if (unformat (i, "vrf %d", &vrf_id))
6180 else if (unformat (i, "count %d", &count))
6182 else if (unformat (i, "random"))
6184 else if (unformat (i, "multipath"))
6186 else if (unformat (i, "seed %d", &random_seed))
6190 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
6193 if (8 == path_count)
6195 errmsg ("max 8 paths");
6201 clib_warning ("parse error '%U'", format_unformat_error, i);
6208 errmsg ("specify a path; via ...");
6211 if (prefix_set == 0)
6213 errmsg ("missing prefix");
6217 /* Generate a pile of unique, random routes */
6220 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
6221 u32 this_random_address;
6224 random_hash = hash_create (count, sizeof (uword));
6226 hash_set (random_hash, i->as_u32, 1);
6227 for (j = 0; j <= count; j++)
6231 this_random_address = random_u32 (&random_seed);
6232 this_random_address =
6233 clib_host_to_net_u32 (this_random_address);
6235 while (hash_get (random_hash, this_random_address));
6236 vec_add1 (random_vector, this_random_address);
6237 hash_set (random_hash, this_random_address, 1);
6239 hash_free (random_hash);
6240 set_ip4_address (&pfx.address, random_vector[0]);
6245 /* Turn on async mode */
6246 vam->async_mode = 1;
6247 vam->async_errors = 0;
6248 before = vat_time_now (vam);
6251 for (j = 0; j < count; j++)
6253 /* Construct the API message */
6254 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
6256 mp->is_add = is_add;
6257 mp->is_multipath = is_multipath;
6259 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
6260 mp->route.table_id = ntohl (vrf_id);
6261 mp->route.n_paths = path_count;
6263 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
6266 set_ip4_address (&pfx.address, random_vector[j + 1]);
6268 increment_address (&pfx.address);
6271 /* If we receive SIGTERM, stop now... */
6276 /* When testing multiple add/del ops, use a control-ping to sync */
6279 vl_api_control_ping_t *mp_ping;
6283 /* Shut off async mode */
6284 vam->async_mode = 0;
6286 MPING (CONTROL_PING, mp_ping);
6289 timeout = vat_time_now (vam) + 1.0;
6290 while (vat_time_now (vam) < timeout)
6291 if (vam->result_ready == 1)
6296 if (vam->retval == -99)
6299 if (vam->async_errors > 0)
6301 errmsg ("%d asynchronous errors", vam->async_errors);
6304 vam->async_errors = 0;
6305 after = vat_time_now (vam);
6307 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6311 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6312 count, after - before, count / (after - before));
6318 /* Wait for a reply... */
6323 /* Return the good/bad news */
6324 return (vam->retval);
6328 api_ip_mroute_add_del (vat_main_t * vam)
6330 unformat_input_t *i = vam->input;
6331 u8 path_set = 0, prefix_set = 0, is_add = 1;
6332 vl_api_ip_mroute_add_del_t *mp;
6333 mfib_entry_flags_t eflags = 0;
6334 vl_api_mfib_path_t path;
6335 vl_api_mprefix_t pfx = { };
6339 /* Parse args required to build the message */
6340 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6342 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
6345 pfx.grp_address_length = htons (pfx.grp_address_length);
6347 else if (unformat (i, "del"))
6349 else if (unformat (i, "add"))
6351 else if (unformat (i, "vrf %d", &vrf_id))
6353 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
6354 path.itf_flags = htonl (path.itf_flags);
6355 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6357 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
6361 clib_warning ("parse error '%U'", format_unformat_error, i);
6366 if (prefix_set == 0)
6368 errmsg ("missing addresses\n");
6373 errmsg ("missing path\n");
6377 /* Construct the API message */
6378 M (IP_MROUTE_ADD_DEL, mp);
6380 mp->is_add = is_add;
6381 mp->is_multipath = 1;
6383 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
6384 mp->route.table_id = htonl (vrf_id);
6385 mp->route.n_paths = 1;
6386 mp->route.entry_flags = htonl (eflags);
6388 clib_memcpy (&mp->route.paths, &path, sizeof (path));
6392 /* Wait for a reply... */
6398 api_mpls_table_add_del (vat_main_t * vam)
6400 unformat_input_t *i = vam->input;
6401 vl_api_mpls_table_add_del_t *mp;
6406 /* Parse args required to build the message */
6407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6409 if (unformat (i, "table %d", &table_id))
6411 else if (unformat (i, "del"))
6413 else if (unformat (i, "add"))
6417 clib_warning ("parse error '%U'", format_unformat_error, i);
6424 errmsg ("missing table-ID");
6428 /* Construct the API message */
6429 M (MPLS_TABLE_ADD_DEL, mp);
6431 mp->mt_table.mt_table_id = ntohl (table_id);
6432 mp->mt_is_add = is_add;
6437 /* Wait for a reply... */
6444 api_mpls_route_add_del (vat_main_t * vam)
6446 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
6447 mpls_label_t local_label = MPLS_LABEL_INVALID;
6448 unformat_input_t *i = vam->input;
6449 vl_api_mpls_route_add_del_t *mp;
6450 vl_api_fib_path_t paths[8];
6454 /* Parse args required to build the message */
6455 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6457 if (unformat (i, "%d", &local_label))
6459 else if (unformat (i, "eos"))
6461 else if (unformat (i, "non-eos"))
6463 else if (unformat (i, "del"))
6465 else if (unformat (i, "add"))
6467 else if (unformat (i, "multipath"))
6469 else if (unformat (i, "count %d", &count))
6473 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
6476 if (8 == path_count)
6478 errmsg ("max 8 paths");
6484 clib_warning ("parse error '%U'", format_unformat_error, i);
6491 errmsg ("specify a path; via ...");
6495 if (MPLS_LABEL_INVALID == local_label)
6497 errmsg ("missing label");
6503 /* Turn on async mode */
6504 vam->async_mode = 1;
6505 vam->async_errors = 0;
6506 before = vat_time_now (vam);
6509 for (j = 0; j < count; j++)
6511 /* Construct the API message */
6512 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
6514 mp->mr_is_add = is_add;
6515 mp->mr_is_multipath = is_multipath;
6517 mp->mr_route.mr_label = local_label;
6518 mp->mr_route.mr_eos = is_eos;
6519 mp->mr_route.mr_table_id = 0;
6520 mp->mr_route.mr_n_paths = path_count;
6522 clib_memcpy (&mp->mr_route.mr_paths, paths,
6523 sizeof (paths[0]) * path_count);
6529 /* If we receive SIGTERM, stop now... */
6534 /* When testing multiple add/del ops, use a control-ping to sync */
6537 vl_api_control_ping_t *mp_ping;
6541 /* Shut off async mode */
6542 vam->async_mode = 0;
6544 MPING (CONTROL_PING, mp_ping);
6547 timeout = vat_time_now (vam) + 1.0;
6548 while (vat_time_now (vam) < timeout)
6549 if (vam->result_ready == 1)
6554 if (vam->retval == -99)
6557 if (vam->async_errors > 0)
6559 errmsg ("%d asynchronous errors", vam->async_errors);
6562 vam->async_errors = 0;
6563 after = vat_time_now (vam);
6565 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6569 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6570 count, after - before, count / (after - before));
6576 /* Wait for a reply... */
6581 /* Return the good/bad news */
6582 return (vam->retval);
6587 api_mpls_ip_bind_unbind (vat_main_t * vam)
6589 unformat_input_t *i = vam->input;
6590 vl_api_mpls_ip_bind_unbind_t *mp;
6591 u32 ip_table_id = 0;
6593 vl_api_prefix_t pfx;
6595 mpls_label_t local_label = MPLS_LABEL_INVALID;
6598 /* Parse args required to build the message */
6599 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6601 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
6603 else if (unformat (i, "%d", &local_label))
6605 else if (unformat (i, "table-id %d", &ip_table_id))
6607 else if (unformat (i, "unbind"))
6609 else if (unformat (i, "bind"))
6613 clib_warning ("parse error '%U'", format_unformat_error, i);
6620 errmsg ("IP prefix not set");
6624 if (MPLS_LABEL_INVALID == local_label)
6626 errmsg ("missing label");
6630 /* Construct the API message */
6631 M (MPLS_IP_BIND_UNBIND, mp);
6633 mp->mb_is_bind = is_bind;
6634 mp->mb_ip_table_id = ntohl (ip_table_id);
6635 mp->mb_mpls_table_id = 0;
6636 mp->mb_label = ntohl (local_label);
6637 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
6642 /* Wait for a reply... */
6649 api_sr_mpls_policy_add (vat_main_t * vam)
6651 unformat_input_t *i = vam->input;
6652 vl_api_sr_mpls_policy_add_t *mp;
6658 u32 *segments = NULL;
6661 /* Parse args required to build the message */
6662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6664 if (unformat (i, "bsid %d", &bsid))
6666 else if (unformat (i, "weight %d", &weight))
6668 else if (unformat (i, "spray"))
6670 else if (unformat (i, "next %d", &sid))
6673 vec_add1 (segments, htonl (sid));
6677 clib_warning ("parse error '%U'", format_unformat_error, i);
6684 errmsg ("bsid not set");
6688 if (n_segments == 0)
6690 errmsg ("no sid in segment stack");
6694 /* Construct the API message */
6695 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
6697 mp->bsid = htonl (bsid);
6698 mp->weight = htonl (weight);
6699 mp->is_spray = type;
6700 mp->n_segments = n_segments;
6701 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
6702 vec_free (segments);
6707 /* Wait for a reply... */
6713 api_sr_mpls_policy_del (vat_main_t * vam)
6715 unformat_input_t *i = vam->input;
6716 vl_api_sr_mpls_policy_del_t *mp;
6720 /* Parse args required to build the message */
6721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6723 if (unformat (i, "bsid %d", &bsid))
6727 clib_warning ("parse error '%U'", format_unformat_error, i);
6734 errmsg ("bsid not set");
6738 /* Construct the API message */
6739 M (SR_MPLS_POLICY_DEL, mp);
6741 mp->bsid = htonl (bsid);
6746 /* Wait for a reply... */
6752 api_bier_table_add_del (vat_main_t * vam)
6754 unformat_input_t *i = vam->input;
6755 vl_api_bier_table_add_del_t *mp;
6757 u32 set = 0, sub_domain = 0, hdr_len = 3;
6758 mpls_label_t local_label = MPLS_LABEL_INVALID;
6761 /* Parse args required to build the message */
6762 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6764 if (unformat (i, "sub-domain %d", &sub_domain))
6766 else if (unformat (i, "set %d", &set))
6768 else if (unformat (i, "label %d", &local_label))
6770 else if (unformat (i, "hdr-len %d", &hdr_len))
6772 else if (unformat (i, "add"))
6774 else if (unformat (i, "del"))
6778 clib_warning ("parse error '%U'", format_unformat_error, i);
6783 if (MPLS_LABEL_INVALID == local_label)
6785 errmsg ("missing label\n");
6789 /* Construct the API message */
6790 M (BIER_TABLE_ADD_DEL, mp);
6792 mp->bt_is_add = is_add;
6793 mp->bt_label = ntohl (local_label);
6794 mp->bt_tbl_id.bt_set = set;
6795 mp->bt_tbl_id.bt_sub_domain = sub_domain;
6796 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
6801 /* Wait for a reply... */
6808 api_bier_route_add_del (vat_main_t * vam)
6810 unformat_input_t *i = vam->input;
6811 vl_api_bier_route_add_del_t *mp;
6813 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
6814 ip4_address_t v4_next_hop_address;
6815 ip6_address_t v6_next_hop_address;
6816 u8 next_hop_set = 0;
6817 u8 next_hop_proto_is_ip4 = 1;
6818 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6821 /* Parse args required to build the message */
6822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6824 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
6826 next_hop_proto_is_ip4 = 1;
6829 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
6831 next_hop_proto_is_ip4 = 0;
6834 if (unformat (i, "sub-domain %d", &sub_domain))
6836 else if (unformat (i, "set %d", &set))
6838 else if (unformat (i, "hdr-len %d", &hdr_len))
6840 else if (unformat (i, "bp %d", &bp))
6842 else if (unformat (i, "add"))
6844 else if (unformat (i, "del"))
6846 else if (unformat (i, "out-label %d", &next_hop_out_label))
6850 clib_warning ("parse error '%U'", format_unformat_error, i);
6855 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
6857 errmsg ("next hop / label set\n");
6862 errmsg ("bit=position not set\n");
6866 /* Construct the API message */
6867 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
6869 mp->br_is_add = is_add;
6870 mp->br_route.br_tbl_id.bt_set = set;
6871 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
6872 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
6873 mp->br_route.br_bp = ntohs (bp);
6874 mp->br_route.br_n_paths = 1;
6875 mp->br_route.br_paths[0].n_labels = 1;
6876 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
6877 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
6878 FIB_API_PATH_NH_PROTO_IP4 :
6879 FIB_API_PATH_NH_PROTO_IP6);
6881 if (next_hop_proto_is_ip4)
6883 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
6884 &v4_next_hop_address, sizeof (v4_next_hop_address));
6888 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
6889 &v6_next_hop_address, sizeof (v6_next_hop_address));
6895 /* Wait for a reply... */
6902 api_mpls_tunnel_add_del (vat_main_t * vam)
6904 unformat_input_t *i = vam->input;
6905 vl_api_mpls_tunnel_add_del_t *mp;
6907 vl_api_fib_path_t paths[8];
6908 u32 sw_if_index = ~0;
6914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6916 if (unformat (i, "add"))
6920 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
6922 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
6924 else if (unformat (i, "l2-only"))
6928 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
6931 if (8 == path_count)
6933 errmsg ("max 8 paths");
6939 clib_warning ("parse error '%U'", format_unformat_error, i);
6944 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
6946 mp->mt_is_add = is_add;
6947 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
6948 mp->mt_tunnel.mt_l2_only = l2_only;
6949 mp->mt_tunnel.mt_is_multicast = 0;
6950 mp->mt_tunnel.mt_n_paths = path_count;
6952 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
6953 sizeof (paths[0]) * path_count);
6961 api_sw_interface_set_unnumbered (vat_main_t * vam)
6963 unformat_input_t *i = vam->input;
6964 vl_api_sw_interface_set_unnumbered_t *mp;
6966 u32 unnum_sw_index = ~0;
6968 u8 sw_if_index_set = 0;
6971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6973 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6974 sw_if_index_set = 1;
6975 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6976 sw_if_index_set = 1;
6977 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6979 else if (unformat (i, "del"))
6983 clib_warning ("parse error '%U'", format_unformat_error, i);
6988 if (sw_if_index_set == 0)
6990 errmsg ("missing interface name or sw_if_index");
6994 M (SW_INTERFACE_SET_UNNUMBERED, mp);
6996 mp->sw_if_index = ntohl (sw_if_index);
6997 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6998 mp->is_add = is_add;
7007 api_create_vlan_subif (vat_main_t * vam)
7009 unformat_input_t *i = vam->input;
7010 vl_api_create_vlan_subif_t *mp;
7012 u8 sw_if_index_set = 0;
7017 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7019 if (unformat (i, "sw_if_index %d", &sw_if_index))
7020 sw_if_index_set = 1;
7022 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7023 sw_if_index_set = 1;
7024 else if (unformat (i, "vlan %d", &vlan_id))
7028 clib_warning ("parse error '%U'", format_unformat_error, i);
7033 if (sw_if_index_set == 0)
7035 errmsg ("missing interface name or sw_if_index");
7039 if (vlan_id_set == 0)
7041 errmsg ("missing vlan_id");
7044 M (CREATE_VLAN_SUBIF, mp);
7046 mp->sw_if_index = ntohl (sw_if_index);
7047 mp->vlan_id = ntohl (vlan_id);
7054 #define foreach_create_subif_bit \
7061 _(outer_vlan_id_any) \
7062 _(inner_vlan_id_any)
7064 #define foreach_create_subif_flag \
7069 _(4, "exact_match") \
7070 _(5, "default_sub") \
7071 _(6, "outer_vlan_id_any") \
7072 _(7, "inner_vlan_id_any")
7075 api_create_subif (vat_main_t * vam)
7077 unformat_input_t *i = vam->input;
7078 vl_api_create_subif_t *mp;
7080 u8 sw_if_index_set = 0;
7083 u32 __attribute__ ((unused)) no_tags = 0;
7084 u32 __attribute__ ((unused)) one_tag = 0;
7085 u32 __attribute__ ((unused)) two_tags = 0;
7086 u32 __attribute__ ((unused)) dot1ad = 0;
7087 u32 __attribute__ ((unused)) exact_match = 0;
7088 u32 __attribute__ ((unused)) default_sub = 0;
7089 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
7090 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
7092 u16 outer_vlan_id = 0;
7093 u16 inner_vlan_id = 0;
7096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7098 if (unformat (i, "sw_if_index %d", &sw_if_index))
7099 sw_if_index_set = 1;
7101 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7102 sw_if_index_set = 1;
7103 else if (unformat (i, "sub_id %d", &sub_id))
7105 else if (unformat (i, "outer_vlan_id %d", &tmp))
7106 outer_vlan_id = tmp;
7107 else if (unformat (i, "inner_vlan_id %d", &tmp))
7108 inner_vlan_id = tmp;
7110 #define _(a) else if (unformat (i, #a)) a = 1 ;
7111 foreach_create_subif_bit
7115 clib_warning ("parse error '%U'", format_unformat_error, i);
7120 if (sw_if_index_set == 0)
7122 errmsg ("missing interface name or sw_if_index");
7126 if (sub_id_set == 0)
7128 errmsg ("missing sub_id");
7131 M (CREATE_SUBIF, mp);
7133 mp->sw_if_index = ntohl (sw_if_index);
7134 mp->sub_id = ntohl (sub_id);
7136 #define _(a,b) mp->sub_if_flags |= (1 << a);
7137 foreach_create_subif_flag;
7140 mp->outer_vlan_id = ntohs (outer_vlan_id);
7141 mp->inner_vlan_id = ntohs (inner_vlan_id);
7149 api_ip_table_replace_begin (vat_main_t * vam)
7151 unformat_input_t *i = vam->input;
7152 vl_api_ip_table_replace_begin_t *mp;
7157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7159 if (unformat (i, "table %d", &table_id))
7161 else if (unformat (i, "ipv6"))
7165 clib_warning ("parse error '%U'", format_unformat_error, i);
7170 M (IP_TABLE_REPLACE_BEGIN, mp);
7172 mp->table.table_id = ntohl (table_id);
7173 mp->table.is_ip6 = is_ipv6;
7181 api_ip_table_flush (vat_main_t * vam)
7183 unformat_input_t *i = vam->input;
7184 vl_api_ip_table_flush_t *mp;
7189 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7191 if (unformat (i, "table %d", &table_id))
7193 else if (unformat (i, "ipv6"))
7197 clib_warning ("parse error '%U'", format_unformat_error, i);
7202 M (IP_TABLE_FLUSH, mp);
7204 mp->table.table_id = ntohl (table_id);
7205 mp->table.is_ip6 = is_ipv6;
7213 api_ip_table_replace_end (vat_main_t * vam)
7215 unformat_input_t *i = vam->input;
7216 vl_api_ip_table_replace_end_t *mp;
7221 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7223 if (unformat (i, "table %d", &table_id))
7225 else if (unformat (i, "ipv6"))
7229 clib_warning ("parse error '%U'", format_unformat_error, i);
7234 M (IP_TABLE_REPLACE_END, mp);
7236 mp->table.table_id = ntohl (table_id);
7237 mp->table.is_ip6 = is_ipv6;
7245 api_set_ip_flow_hash (vat_main_t * vam)
7247 unformat_input_t *i = vam->input;
7248 vl_api_set_ip_flow_hash_t *mp;
7260 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7262 if (unformat (i, "vrf %d", &vrf_id))
7264 else if (unformat (i, "ipv6"))
7266 else if (unformat (i, "src"))
7268 else if (unformat (i, "dst"))
7270 else if (unformat (i, "sport"))
7272 else if (unformat (i, "dport"))
7274 else if (unformat (i, "proto"))
7276 else if (unformat (i, "reverse"))
7281 clib_warning ("parse error '%U'", format_unformat_error, i);
7286 if (vrf_id_set == 0)
7288 errmsg ("missing vrf id");
7292 M (SET_IP_FLOW_HASH, mp);
7298 mp->reverse = reverse;
7299 mp->vrf_id = ntohl (vrf_id);
7300 mp->is_ipv6 = is_ipv6;
7308 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7310 unformat_input_t *i = vam->input;
7311 vl_api_sw_interface_ip6_enable_disable_t *mp;
7313 u8 sw_if_index_set = 0;
7317 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7319 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7320 sw_if_index_set = 1;
7321 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7322 sw_if_index_set = 1;
7323 else if (unformat (i, "enable"))
7325 else if (unformat (i, "disable"))
7329 clib_warning ("parse error '%U'", format_unformat_error, i);
7334 if (sw_if_index_set == 0)
7336 errmsg ("missing interface name or sw_if_index");
7340 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
7342 mp->sw_if_index = ntohl (sw_if_index);
7343 mp->enable = enable;
7352 api_l2_patch_add_del (vat_main_t * vam)
7354 unformat_input_t *i = vam->input;
7355 vl_api_l2_patch_add_del_t *mp;
7357 u8 rx_sw_if_index_set = 0;
7359 u8 tx_sw_if_index_set = 0;
7363 /* Parse args required to build the message */
7364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7366 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7367 rx_sw_if_index_set = 1;
7368 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7369 tx_sw_if_index_set = 1;
7370 else if (unformat (i, "rx"))
7372 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7374 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7376 rx_sw_if_index_set = 1;
7381 else if (unformat (i, "tx"))
7383 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7385 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7387 tx_sw_if_index_set = 1;
7392 else if (unformat (i, "del"))
7398 if (rx_sw_if_index_set == 0)
7400 errmsg ("missing rx interface name or rx_sw_if_index");
7404 if (tx_sw_if_index_set == 0)
7406 errmsg ("missing tx interface name or tx_sw_if_index");
7410 M (L2_PATCH_ADD_DEL, mp);
7412 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7413 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7414 mp->is_add = is_add;
7422 u8 localsid_addr[16];
7431 api_sr_localsid_add_del (vat_main_t * vam)
7433 unformat_input_t *i = vam->input;
7434 vl_api_sr_localsid_add_del_t *mp;
7437 ip6_address_t localsid;
7441 u32 fib_table = ~(u32) 0;
7442 ip46_address_t nh_addr;
7443 clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
7445 bool nexthop_set = 0;
7449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7451 if (unformat (i, "del"))
7453 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
7454 else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
7456 else if (unformat (i, "behavior %u", &behavior));
7457 else if (unformat (i, "sw_if_index %u", &sw_if_index));
7458 else if (unformat (i, "fib-table %u", &fib_table));
7459 else if (unformat (i, "end.psp %u", &behavior));
7464 M (SR_LOCALSID_ADD_DEL, mp);
7466 clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
7470 clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
7472 mp->behavior = behavior;
7473 mp->sw_if_index = ntohl (sw_if_index);
7474 mp->fib_table = ntohl (fib_table);
7475 mp->end_psp = end_psp;
7476 mp->is_del = is_del;
7484 api_ioam_enable (vat_main_t * vam)
7486 unformat_input_t *input = vam->input;
7487 vl_api_ioam_enable_t *mp;
7489 int has_trace_option = 0;
7490 int has_pot_option = 0;
7491 int has_seqno_option = 0;
7492 int has_analyse_option = 0;
7495 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7497 if (unformat (input, "trace"))
7498 has_trace_option = 1;
7499 else if (unformat (input, "pot"))
7501 else if (unformat (input, "seqno"))
7502 has_seqno_option = 1;
7503 else if (unformat (input, "analyse"))
7504 has_analyse_option = 1;
7508 M (IOAM_ENABLE, mp);
7509 mp->id = htons (id);
7510 mp->seqno = has_seqno_option;
7511 mp->analyse = has_analyse_option;
7512 mp->pot_enable = has_pot_option;
7513 mp->trace_enable = has_trace_option;
7522 api_ioam_disable (vat_main_t * vam)
7524 vl_api_ioam_disable_t *mp;
7527 M (IOAM_DISABLE, mp);
7533 #define foreach_tcp_proto_field \
7537 #define foreach_udp_proto_field \
7541 #define foreach_ip4_proto_field \
7553 u16 src_port, dst_port;
7556 #if VPP_API_TEST_BUILTIN == 0
7558 unformat_tcp_mask (unformat_input_t * input, va_list * args)
7560 u8 **maskp = va_arg (*args, u8 **);
7562 u8 found_something = 0;
7565 #define _(a) u8 a=0;
7566 foreach_tcp_proto_field;
7569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7572 #define _(a) else if (unformat (input, #a)) a=1;
7573 foreach_tcp_proto_field
7579 #define _(a) found_something += a;
7580 foreach_tcp_proto_field;
7583 if (found_something == 0)
7586 vec_validate (mask, sizeof (*tcp) - 1);
7588 tcp = (tcp_header_t *) mask;
7590 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
7591 foreach_tcp_proto_field;
7599 unformat_udp_mask (unformat_input_t * input, va_list * args)
7601 u8 **maskp = va_arg (*args, u8 **);
7603 u8 found_something = 0;
7606 #define _(a) u8 a=0;
7607 foreach_udp_proto_field;
7610 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7613 #define _(a) else if (unformat (input, #a)) a=1;
7614 foreach_udp_proto_field
7620 #define _(a) found_something += a;
7621 foreach_udp_proto_field;
7624 if (found_something == 0)
7627 vec_validate (mask, sizeof (*udp) - 1);
7629 udp = (udp_header_t *) mask;
7631 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
7632 foreach_udp_proto_field;
7640 unformat_l4_mask (unformat_input_t * input, va_list * args)
7642 u8 **maskp = va_arg (*args, u8 **);
7643 u16 src_port = 0, dst_port = 0;
7644 tcpudp_header_t *tcpudp;
7646 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7648 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
7650 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
7652 else if (unformat (input, "src_port"))
7654 else if (unformat (input, "dst_port"))
7660 if (!src_port && !dst_port)
7664 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
7666 tcpudp = (tcpudp_header_t *) mask;
7667 tcpudp->src_port = src_port;
7668 tcpudp->dst_port = dst_port;
7676 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7678 u8 **maskp = va_arg (*args, u8 **);
7680 u8 found_something = 0;
7683 #define _(a) u8 a=0;
7684 foreach_ip4_proto_field;
7690 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7692 if (unformat (input, "version"))
7694 else if (unformat (input, "hdr_length"))
7696 else if (unformat (input, "src"))
7698 else if (unformat (input, "dst"))
7700 else if (unformat (input, "proto"))
7703 #define _(a) else if (unformat (input, #a)) a=1;
7704 foreach_ip4_proto_field
7710 #define _(a) found_something += a;
7711 foreach_ip4_proto_field;
7714 if (found_something == 0)
7717 vec_validate (mask, sizeof (*ip) - 1);
7719 ip = (ip4_header_t *) mask;
7721 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
7722 foreach_ip4_proto_field;
7725 ip->ip_version_and_header_length = 0;
7728 ip->ip_version_and_header_length |= 0xF0;
7731 ip->ip_version_and_header_length |= 0x0F;
7737 #define foreach_ip6_proto_field \
7745 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7747 u8 **maskp = va_arg (*args, u8 **);
7749 u8 found_something = 0;
7751 u32 ip_version_traffic_class_and_flow_label;
7753 #define _(a) u8 a=0;
7754 foreach_ip6_proto_field;
7757 u8 traffic_class = 0;
7760 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7762 if (unformat (input, "version"))
7764 else if (unformat (input, "traffic-class"))
7766 else if (unformat (input, "flow-label"))
7768 else if (unformat (input, "src"))
7770 else if (unformat (input, "dst"))
7772 else if (unformat (input, "proto"))
7775 #define _(a) else if (unformat (input, #a)) a=1;
7776 foreach_ip6_proto_field
7782 #define _(a) found_something += a;
7783 foreach_ip6_proto_field;
7786 if (found_something == 0)
7789 vec_validate (mask, sizeof (*ip) - 1);
7791 ip = (ip6_header_t *) mask;
7793 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
7794 foreach_ip6_proto_field;
7797 ip_version_traffic_class_and_flow_label = 0;
7800 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7803 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7806 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7808 ip->ip_version_traffic_class_and_flow_label =
7809 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7816 unformat_l3_mask (unformat_input_t * input, va_list * args)
7818 u8 **maskp = va_arg (*args, u8 **);
7820 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7822 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7824 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7833 unformat_l2_mask (unformat_input_t * input, va_list * args)
7835 u8 **maskp = va_arg (*args, u8 **);
7850 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7852 if (unformat (input, "src"))
7854 else if (unformat (input, "dst"))
7856 else if (unformat (input, "proto"))
7858 else if (unformat (input, "tag1"))
7860 else if (unformat (input, "tag2"))
7862 else if (unformat (input, "ignore-tag1"))
7864 else if (unformat (input, "ignore-tag2"))
7866 else if (unformat (input, "cos1"))
7868 else if (unformat (input, "cos2"))
7870 else if (unformat (input, "dot1q"))
7872 else if (unformat (input, "dot1ad"))
7877 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7878 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7881 if (tag1 || ignore_tag1 || cos1 || dot1q)
7883 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7886 vec_validate (mask, len - 1);
7889 clib_memset (mask, 0xff, 6);
7892 clib_memset (mask + 6, 0xff, 6);
7896 /* inner vlan tag */
7905 mask[21] = mask[20] = 0xff;
7926 mask[16] = mask[17] = 0xff;
7936 mask[12] = mask[13] = 0xff;
7943 unformat_classify_mask (unformat_input_t * input, va_list * args)
7945 u8 **maskp = va_arg (*args, u8 **);
7946 u32 *skipp = va_arg (*args, u32 *);
7947 u32 *matchp = va_arg (*args, u32 *);
7955 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7957 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7959 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7961 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7963 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
7977 if (mask || l2 || l3 || l4)
7981 /* "With a free Ethernet header in every package" */
7983 vec_validate (l2, 13);
7987 vec_append (mask, l3);
7992 vec_append (mask, l4);
7997 /* Scan forward looking for the first significant mask octet */
7998 for (i = 0; i < vec_len (mask); i++)
8002 /* compute (skip, match) params */
8003 *skipp = i / sizeof (u32x4);
8004 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8006 /* Pad mask to an even multiple of the vector size */
8007 while (vec_len (mask) % sizeof (u32x4))
8010 match = vec_len (mask) / sizeof (u32x4);
8012 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8014 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8015 if (*tmp || *(tmp + 1))
8020 clib_warning ("BUG: match 0");
8022 _vec_len (mask) = match * sizeof (u32x4);
8032 #endif /* VPP_API_TEST_BUILTIN */
8034 #define foreach_l2_next \
8036 _(ethernet, ETHERNET_INPUT) \
8041 unformat_l2_next_index (unformat_input_t * input, va_list * args)
8043 u32 *miss_next_indexp = va_arg (*args, u32 *);
8048 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8052 if (unformat (input, "%d", &tmp))
8061 *miss_next_indexp = next_index;
8065 #define foreach_ip_next \
8071 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
8073 u32 *miss_next_indexp = va_arg (*args, u32 *);
8078 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8082 if (unformat (input, "%d", &tmp))
8091 *miss_next_indexp = next_index;
8095 #define foreach_acl_next \
8099 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
8101 u32 *miss_next_indexp = va_arg (*args, u32 *);
8106 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8110 if (unformat (input, "permit"))
8115 else if (unformat (input, "%d", &tmp))
8124 *miss_next_indexp = next_index;
8129 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8131 u32 *r = va_arg (*args, u32 *);
8133 if (unformat (input, "conform-color"))
8134 *r = POLICE_CONFORM;
8135 else if (unformat (input, "exceed-color"))
8144 api_classify_add_del_table (vat_main_t * vam)
8146 unformat_input_t *i = vam->input;
8147 vl_api_classify_add_del_table_t *mp;
8154 u32 table_index = ~0;
8155 u32 next_table_index = ~0;
8156 u32 miss_next_index = ~0;
8157 u32 memory_size = 32 << 20;
8159 u32 current_data_flag = 0;
8160 int current_data_offset = 0;
8163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8165 if (unformat (i, "del"))
8167 else if (unformat (i, "del-chain"))
8172 else if (unformat (i, "buckets %d", &nbuckets))
8174 else if (unformat (i, "memory_size %d", &memory_size))
8176 else if (unformat (i, "skip %d", &skip))
8178 else if (unformat (i, "match %d", &match))
8180 else if (unformat (i, "table %d", &table_index))
8182 else if (unformat (i, "mask %U", unformat_classify_mask,
8183 &mask, &skip, &match))
8185 else if (unformat (i, "next-table %d", &next_table_index))
8187 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
8190 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8193 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
8196 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
8198 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
8204 if (is_add && mask == 0)
8206 errmsg ("Mask required");
8210 if (is_add && skip == ~0)
8212 errmsg ("skip count required");
8216 if (is_add && match == ~0)
8218 errmsg ("match count required");
8222 if (!is_add && table_index == ~0)
8224 errmsg ("table index required for delete");
8228 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
8230 mp->is_add = is_add;
8231 mp->del_chain = del_chain;
8232 mp->table_index = ntohl (table_index);
8233 mp->nbuckets = ntohl (nbuckets);
8234 mp->memory_size = ntohl (memory_size);
8235 mp->skip_n_vectors = ntohl (skip);
8236 mp->match_n_vectors = ntohl (match);
8237 mp->next_table_index = ntohl (next_table_index);
8238 mp->miss_next_index = ntohl (miss_next_index);
8239 mp->current_data_flag = ntohl (current_data_flag);
8240 mp->current_data_offset = ntohl (current_data_offset);
8241 mp->mask_len = ntohl (vec_len (mask));
8242 clib_memcpy (mp->mask, mask, vec_len (mask));
8251 #if VPP_API_TEST_BUILTIN == 0
8253 unformat_l4_match (unformat_input_t * input, va_list * args)
8255 u8 **matchp = va_arg (*args, u8 **);
8257 u8 *proto_header = 0;
8263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8265 if (unformat (input, "src_port %d", &src_port))
8267 else if (unformat (input, "dst_port %d", &dst_port))
8273 h.src_port = clib_host_to_net_u16 (src_port);
8274 h.dst_port = clib_host_to_net_u16 (dst_port);
8275 vec_validate (proto_header, sizeof (h) - 1);
8276 memcpy (proto_header, &h, sizeof (h));
8278 *matchp = proto_header;
8284 unformat_ip4_match (unformat_input_t * input, va_list * args)
8286 u8 **matchp = va_arg (*args, u8 **);
8293 int src = 0, dst = 0;
8294 ip4_address_t src_val, dst_val;
8301 int fragment_id = 0;
8302 u32 fragment_id_val;
8308 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8310 if (unformat (input, "version %d", &version_val))
8312 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8314 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8316 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8318 else if (unformat (input, "proto %d", &proto_val))
8320 else if (unformat (input, "tos %d", &tos_val))
8322 else if (unformat (input, "length %d", &length_val))
8324 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8326 else if (unformat (input, "ttl %d", &ttl_val))
8328 else if (unformat (input, "checksum %d", &checksum_val))
8334 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8335 + ttl + checksum == 0)
8339 * Aligned because we use the real comparison functions
8341 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8343 ip = (ip4_header_t *) match;
8345 /* These are realistically matched in practice */
8347 ip->src_address.as_u32 = src_val.as_u32;
8350 ip->dst_address.as_u32 = dst_val.as_u32;
8353 ip->protocol = proto_val;
8356 /* These are not, but they're included for completeness */
8358 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8361 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8367 ip->length = clib_host_to_net_u16 (length_val);
8373 ip->checksum = clib_host_to_net_u16 (checksum_val);
8380 unformat_ip6_match (unformat_input_t * input, va_list * args)
8382 u8 **matchp = va_arg (*args, u8 **);
8387 u8 traffic_class = 0;
8388 u32 traffic_class_val = 0;
8391 int src = 0, dst = 0;
8392 ip6_address_t src_val, dst_val;
8395 int payload_length = 0;
8396 u32 payload_length_val;
8399 u32 ip_version_traffic_class_and_flow_label;
8401 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8403 if (unformat (input, "version %d", &version_val))
8405 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8407 else if (unformat (input, "flow_label %d", &flow_label_val))
8409 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8411 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8413 else if (unformat (input, "proto %d", &proto_val))
8415 else if (unformat (input, "payload_length %d", &payload_length_val))
8417 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8423 if (version + traffic_class + flow_label + src + dst + proto +
8424 payload_length + hop_limit == 0)
8428 * Aligned because we use the real comparison functions
8430 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8432 ip = (ip6_header_t *) match;
8435 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8438 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8441 ip->protocol = proto_val;
8443 ip_version_traffic_class_and_flow_label = 0;
8446 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8449 ip_version_traffic_class_and_flow_label |=
8450 (traffic_class_val & 0xFF) << 20;
8453 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8455 ip->ip_version_traffic_class_and_flow_label =
8456 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8459 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8462 ip->hop_limit = hop_limit_val;
8469 unformat_l3_match (unformat_input_t * input, va_list * args)
8471 u8 **matchp = va_arg (*args, u8 **);
8473 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8475 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8477 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8486 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8488 u8 *tagp = va_arg (*args, u8 *);
8491 if (unformat (input, "%d", &tag))
8493 tagp[0] = (tag >> 8) & 0x0F;
8494 tagp[1] = tag & 0xFF;
8502 unformat_l2_match (unformat_input_t * input, va_list * args)
8504 u8 **matchp = va_arg (*args, u8 **);
8524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8526 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8529 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8531 else if (unformat (input, "proto %U",
8532 unformat_ethernet_type_host_byte_order, &proto_val))
8534 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8536 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8538 else if (unformat (input, "ignore-tag1"))
8540 else if (unformat (input, "ignore-tag2"))
8542 else if (unformat (input, "cos1 %d", &cos1_val))
8544 else if (unformat (input, "cos2 %d", &cos2_val))
8549 if ((src + dst + proto + tag1 + tag2 +
8550 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8553 if (tag1 || ignore_tag1 || cos1)
8555 if (tag2 || ignore_tag2 || cos2)
8558 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8561 clib_memcpy (match, dst_val, 6);
8564 clib_memcpy (match + 6, src_val, 6);
8568 /* inner vlan tag */
8569 match[19] = tag2_val[1];
8570 match[18] = tag2_val[0];
8572 match[18] |= (cos2_val & 0x7) << 5;
8575 match[21] = proto_val & 0xff;
8576 match[20] = proto_val >> 8;
8580 match[15] = tag1_val[1];
8581 match[14] = tag1_val[0];
8584 match[14] |= (cos1_val & 0x7) << 5;
8590 match[15] = tag1_val[1];
8591 match[14] = tag1_val[0];
8594 match[17] = proto_val & 0xff;
8595 match[16] = proto_val >> 8;
8598 match[14] |= (cos1_val & 0x7) << 5;
8604 match[18] |= (cos2_val & 0x7) << 5;
8606 match[14] |= (cos1_val & 0x7) << 5;
8609 match[13] = proto_val & 0xff;
8610 match[12] = proto_val >> 8;
8618 unformat_qos_source (unformat_input_t * input, va_list * args)
8620 int *qs = va_arg (*args, int *);
8622 if (unformat (input, "ip"))
8623 *qs = QOS_SOURCE_IP;
8624 else if (unformat (input, "mpls"))
8625 *qs = QOS_SOURCE_MPLS;
8626 else if (unformat (input, "ext"))
8627 *qs = QOS_SOURCE_EXT;
8628 else if (unformat (input, "vlan"))
8629 *qs = QOS_SOURCE_VLAN;
8638 api_unformat_classify_match (unformat_input_t * input, va_list * args)
8640 u8 **matchp = va_arg (*args, u8 **);
8641 u32 skip_n_vectors = va_arg (*args, u32);
8642 u32 match_n_vectors = va_arg (*args, u32);
8649 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8651 if (unformat (input, "hex %U", unformat_hex_string, &match))
8653 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8655 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8657 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
8671 if (match || l2 || l3 || l4)
8675 /* "Win a free Ethernet header in every packet" */
8677 vec_validate_aligned (l2, 13, sizeof (u32x4));
8681 vec_append_aligned (match, l3, sizeof (u32x4));
8686 vec_append_aligned (match, l4, sizeof (u32x4));
8691 /* Make sure the vector is big enough even if key is all 0's */
8692 vec_validate_aligned
8693 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8696 /* Set size, include skipped vectors */
8697 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8708 api_classify_add_del_session (vat_main_t * vam)
8710 unformat_input_t *i = vam->input;
8711 vl_api_classify_add_del_session_t *mp;
8713 u32 table_index = ~0;
8714 u32 hit_next_index = ~0;
8715 u32 opaque_index = ~0;
8718 u32 skip_n_vectors = 0;
8719 u32 match_n_vectors = 0;
8725 * Warning: you have to supply skip_n and match_n
8726 * because the API client cant simply look at the classify
8730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8732 if (unformat (i, "del"))
8734 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
8737 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8740 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
8743 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8745 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8747 else if (unformat (i, "opaque-index %d", &opaque_index))
8749 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8751 else if (unformat (i, "match_n %d", &match_n_vectors))
8753 else if (unformat (i, "match %U", api_unformat_classify_match,
8754 &match, skip_n_vectors, match_n_vectors))
8756 else if (unformat (i, "advance %d", &advance))
8758 else if (unformat (i, "table-index %d", &table_index))
8760 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
8762 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
8764 else if (unformat (i, "action %d", &action))
8766 else if (unformat (i, "metadata %d", &metadata))
8772 if (table_index == ~0)
8774 errmsg ("Table index required");
8778 if (is_add && match == 0)
8780 errmsg ("Match value required");
8784 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
8786 mp->is_add = is_add;
8787 mp->table_index = ntohl (table_index);
8788 mp->hit_next_index = ntohl (hit_next_index);
8789 mp->opaque_index = ntohl (opaque_index);
8790 mp->advance = ntohl (advance);
8791 mp->action = action;
8792 mp->metadata = ntohl (metadata);
8793 mp->match_len = ntohl (vec_len (match));
8794 clib_memcpy (mp->match, match, vec_len (match));
8803 api_classify_set_interface_ip_table (vat_main_t * vam)
8805 unformat_input_t *i = vam->input;
8806 vl_api_classify_set_interface_ip_table_t *mp;
8808 int sw_if_index_set;
8809 u32 table_index = ~0;
8813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8815 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8816 sw_if_index_set = 1;
8817 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8818 sw_if_index_set = 1;
8819 else if (unformat (i, "table %d", &table_index))
8823 clib_warning ("parse error '%U'", format_unformat_error, i);
8828 if (sw_if_index_set == 0)
8830 errmsg ("missing interface name or sw_if_index");
8835 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
8837 mp->sw_if_index = ntohl (sw_if_index);
8838 mp->table_index = ntohl (table_index);
8839 mp->is_ipv6 = is_ipv6;
8847 api_classify_set_interface_l2_tables (vat_main_t * vam)
8849 unformat_input_t *i = vam->input;
8850 vl_api_classify_set_interface_l2_tables_t *mp;
8852 int sw_if_index_set;
8853 u32 ip4_table_index = ~0;
8854 u32 ip6_table_index = ~0;
8855 u32 other_table_index = ~0;
8859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8861 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8862 sw_if_index_set = 1;
8863 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8864 sw_if_index_set = 1;
8865 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8867 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8869 else if (unformat (i, "other-table %d", &other_table_index))
8871 else if (unformat (i, "is-input %d", &is_input))
8875 clib_warning ("parse error '%U'", format_unformat_error, i);
8880 if (sw_if_index_set == 0)
8882 errmsg ("missing interface name or sw_if_index");
8887 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
8889 mp->sw_if_index = ntohl (sw_if_index);
8890 mp->ip4_table_index = ntohl (ip4_table_index);
8891 mp->ip6_table_index = ntohl (ip6_table_index);
8892 mp->other_table_index = ntohl (other_table_index);
8893 mp->is_input = (u8) is_input;
8901 api_set_ipfix_exporter (vat_main_t * vam)
8903 unformat_input_t *i = vam->input;
8904 vl_api_set_ipfix_exporter_t *mp;
8905 ip4_address_t collector_address;
8906 u8 collector_address_set = 0;
8907 u32 collector_port = ~0;
8908 ip4_address_t src_address;
8909 u8 src_address_set = 0;
8912 u32 template_interval = ~0;
8913 u8 udp_checksum = 0;
8916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8918 if (unformat (i, "collector_address %U", unformat_ip4_address,
8919 &collector_address))
8920 collector_address_set = 1;
8921 else if (unformat (i, "collector_port %d", &collector_port))
8923 else if (unformat (i, "src_address %U", unformat_ip4_address,
8925 src_address_set = 1;
8926 else if (unformat (i, "vrf_id %d", &vrf_id))
8928 else if (unformat (i, "path_mtu %d", &path_mtu))
8930 else if (unformat (i, "template_interval %d", &template_interval))
8932 else if (unformat (i, "udp_checksum"))
8938 if (collector_address_set == 0)
8940 errmsg ("collector_address required");
8944 if (src_address_set == 0)
8946 errmsg ("src_address required");
8950 M (SET_IPFIX_EXPORTER, mp);
8952 memcpy (mp->collector_address.un.ip4, collector_address.data,
8953 sizeof (collector_address.data));
8954 mp->collector_port = htons ((u16) collector_port);
8955 memcpy (mp->src_address.un.ip4, src_address.data,
8956 sizeof (src_address.data));
8957 mp->vrf_id = htonl (vrf_id);
8958 mp->path_mtu = htonl (path_mtu);
8959 mp->template_interval = htonl (template_interval);
8960 mp->udp_checksum = udp_checksum;
8968 api_set_ipfix_classify_stream (vat_main_t * vam)
8970 unformat_input_t *i = vam->input;
8971 vl_api_set_ipfix_classify_stream_t *mp;
8973 u32 src_port = UDP_DST_PORT_ipfix;
8976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8978 if (unformat (i, "domain %d", &domain_id))
8980 else if (unformat (i, "src_port %d", &src_port))
8984 errmsg ("unknown input `%U'", format_unformat_error, i);
8989 M (SET_IPFIX_CLASSIFY_STREAM, mp);
8991 mp->domain_id = htonl (domain_id);
8992 mp->src_port = htons ((u16) src_port);
9000 api_ipfix_classify_table_add_del (vat_main_t * vam)
9002 unformat_input_t *i = vam->input;
9003 vl_api_ipfix_classify_table_add_del_t *mp;
9005 u32 classify_table_index = ~0;
9007 u8 transport_protocol = 255;
9010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9012 if (unformat (i, "add"))
9014 else if (unformat (i, "del"))
9016 else if (unformat (i, "table %d", &classify_table_index))
9018 else if (unformat (i, "ip4"))
9020 else if (unformat (i, "ip6"))
9022 else if (unformat (i, "tcp"))
9023 transport_protocol = 6;
9024 else if (unformat (i, "udp"))
9025 transport_protocol = 17;
9028 errmsg ("unknown input `%U'", format_unformat_error, i);
9035 errmsg ("expecting: add|del");
9038 if (classify_table_index == ~0)
9040 errmsg ("classifier table not specified");
9043 if (ip_version == 0)
9045 errmsg ("IP version not specified");
9049 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
9051 mp->is_add = is_add;
9052 mp->table_id = htonl (classify_table_index);
9053 mp->ip_version = ip_version;
9054 mp->transport_protocol = transport_protocol;
9062 api_get_node_index (vat_main_t * vam)
9064 unformat_input_t *i = vam->input;
9065 vl_api_get_node_index_t *mp;
9069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9071 if (unformat (i, "node %s", &name))
9078 errmsg ("node name required");
9081 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9083 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
9087 M (GET_NODE_INDEX, mp);
9088 clib_memcpy (mp->node_name, name, vec_len (name));
9097 api_get_next_index (vat_main_t * vam)
9099 unformat_input_t *i = vam->input;
9100 vl_api_get_next_index_t *mp;
9101 u8 *node_name = 0, *next_node_name = 0;
9104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9106 if (unformat (i, "node-name %s", &node_name))
9108 else if (unformat (i, "next-node-name %s", &next_node_name))
9114 errmsg ("node name required");
9117 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9119 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
9123 if (next_node_name == 0)
9125 errmsg ("next node name required");
9128 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9130 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
9134 M (GET_NEXT_INDEX, mp);
9135 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9136 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9137 vec_free (node_name);
9138 vec_free (next_node_name);
9146 api_add_node_next (vat_main_t * vam)
9148 unformat_input_t *i = vam->input;
9149 vl_api_add_node_next_t *mp;
9154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9156 if (unformat (i, "node %s", &name))
9158 else if (unformat (i, "next %s", &next))
9165 errmsg ("node name required");
9168 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9170 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
9175 errmsg ("next node required");
9178 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9180 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
9184 M (ADD_NODE_NEXT, mp);
9185 clib_memcpy (mp->node_name, name, vec_len (name));
9186 clib_memcpy (mp->next_name, next, vec_len (next));
9195 static void vl_api_sw_interface_tap_v2_details_t_handler
9196 (vl_api_sw_interface_tap_v2_details_t * mp)
9198 vat_main_t *vam = &vat_main;
9201 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
9202 mp->host_ip4_prefix.len);
9204 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
9205 mp->host_ip6_prefix.len);
9208 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
9209 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
9210 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
9211 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
9212 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
9218 static void vl_api_sw_interface_tap_v2_details_t_handler_json
9219 (vl_api_sw_interface_tap_v2_details_t * mp)
9221 vat_main_t *vam = &vat_main;
9222 vat_json_node_t *node = NULL;
9224 if (VAT_JSON_ARRAY != vam->json_tree.type)
9226 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9227 vat_json_init_array (&vam->json_tree);
9229 node = vat_json_array_add (&vam->json_tree);
9231 vat_json_init_object (node);
9232 vat_json_object_add_uint (node, "id", ntohl (mp->id));
9233 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9234 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
9235 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9236 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
9237 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
9238 vat_json_object_add_string_copy (node, "host_mac_addr",
9239 format (0, "%U", format_ethernet_address,
9240 &mp->host_mac_addr));
9241 vat_json_object_add_string_copy (node, "host_namespace",
9242 mp->host_namespace);
9243 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
9244 vat_json_object_add_string_copy (node, "host_ip4_addr",
9245 format (0, "%U/%d", format_ip4_address,
9246 mp->host_ip4_prefix.address,
9247 mp->host_ip4_prefix.len));
9248 vat_json_object_add_string_copy (node, "host_ip6_prefix",
9249 format (0, "%U/%d", format_ip6_address,
9250 mp->host_ip6_prefix.address,
9251 mp->host_ip6_prefix.len));
9256 api_sw_interface_tap_v2_dump (vat_main_t * vam)
9258 vl_api_sw_interface_tap_v2_dump_t *mp;
9259 vl_api_control_ping_t *mp_ping;
9263 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
9264 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
9265 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
9268 /* Get list of tap interfaces */
9269 M (SW_INTERFACE_TAP_V2_DUMP, mp);
9272 /* Use a control ping for synchronization */
9273 MPING (CONTROL_PING, mp_ping);
9280 static void vl_api_sw_interface_virtio_pci_details_t_handler
9281 (vl_api_sw_interface_virtio_pci_details_t * mp)
9283 vat_main_t *vam = &vat_main;
9298 addr.domain = ntohs (mp->pci_addr.domain);
9299 addr.bus = mp->pci_addr.bus;
9300 addr.slot = mp->pci_addr.slot;
9301 addr.function = mp->pci_addr.function;
9303 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
9304 addr.slot, addr.function);
9307 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
9308 pci_addr, ntohl (mp->sw_if_index),
9309 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
9310 format_ethernet_address, mp->mac_addr,
9311 clib_net_to_host_u64 (mp->features));
9312 vec_free (pci_addr);
9315 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
9316 (vl_api_sw_interface_virtio_pci_details_t * mp)
9318 vat_main_t *vam = &vat_main;
9319 vat_json_node_t *node = NULL;
9320 vlib_pci_addr_t pci_addr;
9322 if (VAT_JSON_ARRAY != vam->json_tree.type)
9324 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9325 vat_json_init_array (&vam->json_tree);
9327 node = vat_json_array_add (&vam->json_tree);
9329 pci_addr.domain = ntohs (mp->pci_addr.domain);
9330 pci_addr.bus = mp->pci_addr.bus;
9331 pci_addr.slot = mp->pci_addr.slot;
9332 pci_addr.function = mp->pci_addr.function;
9334 vat_json_init_object (node);
9335 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
9336 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9337 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
9338 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
9339 vat_json_object_add_uint (node, "features",
9340 clib_net_to_host_u64 (mp->features));
9341 vat_json_object_add_string_copy (node, "mac_addr",
9342 format (0, "%U", format_ethernet_address,
9347 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
9349 vl_api_sw_interface_virtio_pci_dump_t *mp;
9350 vl_api_control_ping_t *mp_ping;
9354 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
9355 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
9356 "mac_addr", "features");
9358 /* Get list of tap interfaces */
9359 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
9362 /* Use a control ping for synchronization */
9363 MPING (CONTROL_PING, mp_ping);
9371 api_vxlan_offload_rx (vat_main_t * vam)
9373 unformat_input_t *line_input = vam->input;
9374 vl_api_vxlan_offload_rx_t *mp;
9375 u32 hw_if_index = ~0, rx_if_index = ~0;
9379 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9381 if (unformat (line_input, "del"))
9383 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
9386 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
9388 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
9391 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
9395 errmsg ("parse error '%U'", format_unformat_error, line_input);
9400 if (hw_if_index == ~0)
9402 errmsg ("no hw interface");
9406 if (rx_if_index == ~0)
9408 errmsg ("no rx tunnel");
9412 M (VXLAN_OFFLOAD_RX, mp);
9414 mp->hw_if_index = ntohl (hw_if_index);
9415 mp->sw_if_index = ntohl (rx_if_index);
9416 mp->enable = is_add;
9423 static uword unformat_vxlan_decap_next
9424 (unformat_input_t * input, va_list * args)
9426 u32 *result = va_arg (*args, u32 *);
9429 if (unformat (input, "l2"))
9430 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9431 else if (unformat (input, "%d", &tmp))
9439 api_vxlan_add_del_tunnel (vat_main_t * vam)
9441 unformat_input_t *line_input = vam->input;
9442 vl_api_vxlan_add_del_tunnel_t *mp;
9443 ip46_address_t src, dst;
9445 u8 ipv4_set = 0, ipv6_set = 0;
9450 u32 mcast_sw_if_index = ~0;
9451 u32 encap_vrf_id = 0;
9452 u32 decap_next_index = ~0;
9456 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
9457 clib_memset (&src, 0, sizeof src);
9458 clib_memset (&dst, 0, sizeof dst);
9460 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9462 if (unformat (line_input, "del"))
9464 else if (unformat (line_input, "instance %d", &instance))
9467 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
9473 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
9479 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
9485 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
9490 else if (unformat (line_input, "group %U %U",
9491 unformat_ip4_address, &dst.ip4,
9492 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
9494 grp_set = dst_set = 1;
9497 else if (unformat (line_input, "group %U",
9498 unformat_ip4_address, &dst.ip4))
9500 grp_set = dst_set = 1;
9503 else if (unformat (line_input, "group %U %U",
9504 unformat_ip6_address, &dst.ip6,
9505 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
9507 grp_set = dst_set = 1;
9510 else if (unformat (line_input, "group %U",
9511 unformat_ip6_address, &dst.ip6))
9513 grp_set = dst_set = 1;
9517 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
9519 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9521 else if (unformat (line_input, "decap-next %U",
9522 unformat_vxlan_decap_next, &decap_next_index))
9524 else if (unformat (line_input, "vni %d", &vni))
9528 errmsg ("parse error '%U'", format_unformat_error, line_input);
9535 errmsg ("tunnel src address not specified");
9540 errmsg ("tunnel dst address not specified");
9544 if (grp_set && !ip46_address_is_multicast (&dst))
9546 errmsg ("tunnel group address not multicast");
9549 if (grp_set && mcast_sw_if_index == ~0)
9551 errmsg ("tunnel nonexistent multicast device");
9554 if (grp_set == 0 && ip46_address_is_multicast (&dst))
9556 errmsg ("tunnel dst address must be unicast");
9561 if (ipv4_set && ipv6_set)
9563 errmsg ("both IPv4 and IPv6 addresses specified");
9567 if ((vni == 0) || (vni >> 24))
9569 errmsg ("vni not specified or out of range");
9573 M (VXLAN_ADD_DEL_TUNNEL, mp);
9577 clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
9578 clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
9582 clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
9583 clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
9585 mp->src_address.af = ipv6_set;
9586 mp->dst_address.af = ipv6_set;
9588 mp->instance = htonl (instance);
9589 mp->encap_vrf_id = ntohl (encap_vrf_id);
9590 mp->decap_next_index = ntohl (decap_next_index);
9591 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
9592 mp->vni = ntohl (vni);
9593 mp->is_add = is_add;
9600 static void vl_api_vxlan_tunnel_details_t_handler
9601 (vl_api_vxlan_tunnel_details_t * mp)
9603 vat_main_t *vam = &vat_main;
9604 ip46_address_t src =
9605 to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
9606 ip46_address_t dst =
9607 to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
9609 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
9610 ntohl (mp->sw_if_index),
9611 ntohl (mp->instance),
9612 format_ip46_address, &src, IP46_TYPE_ANY,
9613 format_ip46_address, &dst, IP46_TYPE_ANY,
9614 ntohl (mp->encap_vrf_id),
9615 ntohl (mp->decap_next_index), ntohl (mp->vni),
9616 ntohl (mp->mcast_sw_if_index));
9619 static void vl_api_vxlan_tunnel_details_t_handler_json
9620 (vl_api_vxlan_tunnel_details_t * mp)
9622 vat_main_t *vam = &vat_main;
9623 vat_json_node_t *node = NULL;
9625 if (VAT_JSON_ARRAY != vam->json_tree.type)
9627 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9628 vat_json_init_array (&vam->json_tree);
9630 node = vat_json_array_add (&vam->json_tree);
9632 vat_json_init_object (node);
9633 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9635 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
9637 if (mp->src_address.af)
9639 struct in6_addr ip6;
9641 clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
9642 vat_json_object_add_ip6 (node, "src_address", ip6);
9643 clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
9644 vat_json_object_add_ip6 (node, "dst_address", ip6);
9650 clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
9651 vat_json_object_add_ip4 (node, "src_address", ip4);
9652 clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
9653 vat_json_object_add_ip4 (node, "dst_address", ip4);
9655 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9656 vat_json_object_add_uint (node, "decap_next_index",
9657 ntohl (mp->decap_next_index));
9658 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9659 vat_json_object_add_uint (node, "mcast_sw_if_index",
9660 ntohl (mp->mcast_sw_if_index));
9664 api_vxlan_tunnel_dump (vat_main_t * vam)
9666 unformat_input_t *i = vam->input;
9667 vl_api_vxlan_tunnel_dump_t *mp;
9668 vl_api_control_ping_t *mp_ping;
9670 u8 sw_if_index_set = 0;
9673 /* Parse args required to build the message */
9674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9676 if (unformat (i, "sw_if_index %d", &sw_if_index))
9677 sw_if_index_set = 1;
9682 if (sw_if_index_set == 0)
9687 if (!vam->json_output)
9689 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
9690 "sw_if_index", "instance", "src_address", "dst_address",
9691 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
9694 /* Get list of vxlan-tunnel interfaces */
9695 M (VXLAN_TUNNEL_DUMP, mp);
9697 mp->sw_if_index = htonl (sw_if_index);
9701 /* Use a control ping for synchronization */
9702 MPING (CONTROL_PING, mp_ping);
9710 api_gre_tunnel_add_del (vat_main_t * vam)
9712 unformat_input_t *line_input = vam->input;
9713 vl_api_address_t src = { }, dst =
9716 vl_api_gre_tunnel_add_del_t *mp;
9717 vl_api_gre_tunnel_type_t t_type;
9721 u32 outer_table_id = 0;
9726 t_type = GRE_API_TUNNEL_TYPE_L3;
9728 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9730 if (unformat (line_input, "del"))
9732 else if (unformat (line_input, "instance %d", &instance))
9734 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
9738 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
9742 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
9744 else if (unformat (line_input, "teb"))
9745 t_type = GRE_API_TUNNEL_TYPE_TEB;
9746 else if (unformat (line_input, "erspan %d", &session_id))
9747 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
9750 errmsg ("parse error '%U'", format_unformat_error, line_input);
9757 errmsg ("tunnel src address not specified");
9762 errmsg ("tunnel dst address not specified");
9766 M (GRE_TUNNEL_ADD_DEL, mp);
9768 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
9769 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
9771 mp->tunnel.instance = htonl (instance);
9772 mp->tunnel.outer_table_id = htonl (outer_table_id);
9773 mp->is_add = is_add;
9774 mp->tunnel.session_id = htons ((u16) session_id);
9775 mp->tunnel.type = htonl (t_type);
9782 static void vl_api_gre_tunnel_details_t_handler
9783 (vl_api_gre_tunnel_details_t * mp)
9785 vat_main_t *vam = &vat_main;
9787 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
9788 ntohl (mp->tunnel.sw_if_index),
9789 ntohl (mp->tunnel.instance),
9790 format_vl_api_address, &mp->tunnel.src,
9791 format_vl_api_address, &mp->tunnel.dst,
9792 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
9793 ntohl (mp->tunnel.session_id));
9796 static void vl_api_gre_tunnel_details_t_handler_json
9797 (vl_api_gre_tunnel_details_t * mp)
9799 vat_main_t *vam = &vat_main;
9800 vat_json_node_t *node = NULL;
9802 if (VAT_JSON_ARRAY != vam->json_tree.type)
9804 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9805 vat_json_init_array (&vam->json_tree);
9807 node = vat_json_array_add (&vam->json_tree);
9809 vat_json_init_object (node);
9810 vat_json_object_add_uint (node, "sw_if_index",
9811 ntohl (mp->tunnel.sw_if_index));
9812 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
9814 vat_json_object_add_address (node, "src", &mp->tunnel.src);
9815 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
9816 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
9817 vat_json_object_add_uint (node, "outer_table_id",
9818 ntohl (mp->tunnel.outer_table_id));
9819 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
9823 api_gre_tunnel_dump (vat_main_t * vam)
9825 unformat_input_t *i = vam->input;
9826 vl_api_gre_tunnel_dump_t *mp;
9827 vl_api_control_ping_t *mp_ping;
9829 u8 sw_if_index_set = 0;
9832 /* Parse args required to build the message */
9833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9835 if (unformat (i, "sw_if_index %d", &sw_if_index))
9836 sw_if_index_set = 1;
9841 if (sw_if_index_set == 0)
9846 if (!vam->json_output)
9848 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
9849 "sw_if_index", "instance", "src_address", "dst_address",
9850 "tunnel_type", "outer_fib_id", "session_id");
9853 /* Get list of gre-tunnel interfaces */
9854 M (GRE_TUNNEL_DUMP, mp);
9856 mp->sw_if_index = htonl (sw_if_index);
9860 /* Use a control ping for synchronization */
9861 MPING (CONTROL_PING, mp_ping);
9869 api_l2_fib_clear_table (vat_main_t * vam)
9871 // unformat_input_t * i = vam->input;
9872 vl_api_l2_fib_clear_table_t *mp;
9875 M (L2_FIB_CLEAR_TABLE, mp);
9883 api_l2_interface_efp_filter (vat_main_t * vam)
9885 unformat_input_t *i = vam->input;
9886 vl_api_l2_interface_efp_filter_t *mp;
9889 u8 sw_if_index_set = 0;
9892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9894 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9895 sw_if_index_set = 1;
9896 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9897 sw_if_index_set = 1;
9898 else if (unformat (i, "enable"))
9900 else if (unformat (i, "disable"))
9904 clib_warning ("parse error '%U'", format_unformat_error, i);
9909 if (sw_if_index_set == 0)
9911 errmsg ("missing sw_if_index");
9915 M (L2_INTERFACE_EFP_FILTER, mp);
9917 mp->sw_if_index = ntohl (sw_if_index);
9918 mp->enable_disable = enable;
9925 #define foreach_vtr_op \
9926 _("disable", L2_VTR_DISABLED) \
9927 _("push-1", L2_VTR_PUSH_1) \
9928 _("push-2", L2_VTR_PUSH_2) \
9929 _("pop-1", L2_VTR_POP_1) \
9930 _("pop-2", L2_VTR_POP_2) \
9931 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9932 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9933 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9934 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9937 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9939 unformat_input_t *i = vam->input;
9940 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9942 u8 sw_if_index_set = 0;
9950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9952 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9953 sw_if_index_set = 1;
9954 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9955 sw_if_index_set = 1;
9956 else if (unformat (i, "vtr_op %d", &vtr_op))
9958 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9961 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9963 else if (unformat (i, "tag1 %d", &tag1))
9965 else if (unformat (i, "tag2 %d", &tag2))
9969 clib_warning ("parse error '%U'", format_unformat_error, i);
9974 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9976 errmsg ("missing vtr operation or sw_if_index");
9980 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
9981 mp->sw_if_index = ntohl (sw_if_index);
9982 mp->vtr_op = ntohl (vtr_op);
9983 mp->push_dot1q = ntohl (push_dot1q);
9984 mp->tag1 = ntohl (tag1);
9985 mp->tag2 = ntohl (tag2);
9993 api_create_vhost_user_if (vat_main_t * vam)
9995 unformat_input_t *i = vam->input;
9996 vl_api_create_vhost_user_if_t *mp;
9999 u8 file_name_set = 0;
10000 u32 custom_dev_instance = ~0;
10002 u8 use_custom_mac = 0;
10003 u8 disable_mrg_rxbuf = 0;
10004 u8 disable_indirect_desc = 0;
10007 u8 enable_packed = 0;
10010 /* Shut up coverity */
10011 clib_memset (hwaddr, 0, sizeof (hwaddr));
10013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10015 if (unformat (i, "socket %s", &file_name))
10019 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10021 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10022 use_custom_mac = 1;
10023 else if (unformat (i, "server"))
10025 else if (unformat (i, "disable_mrg_rxbuf"))
10026 disable_mrg_rxbuf = 1;
10027 else if (unformat (i, "disable_indirect_desc"))
10028 disable_indirect_desc = 1;
10029 else if (unformat (i, "gso"))
10031 else if (unformat (i, "packed"))
10033 else if (unformat (i, "tag %s", &tag))
10039 if (file_name_set == 0)
10041 errmsg ("missing socket file name");
10045 if (vec_len (file_name) > 255)
10047 errmsg ("socket file name too long");
10050 vec_add1 (file_name, 0);
10052 M (CREATE_VHOST_USER_IF, mp);
10054 mp->is_server = is_server;
10055 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
10056 mp->disable_indirect_desc = disable_indirect_desc;
10057 mp->enable_gso = enable_gso;
10058 mp->enable_packed = enable_packed;
10059 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10060 vec_free (file_name);
10061 if (custom_dev_instance != ~0)
10064 mp->custom_dev_instance = ntohl (custom_dev_instance);
10067 mp->use_custom_mac = use_custom_mac;
10068 clib_memcpy (mp->mac_address, hwaddr, 6);
10070 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
10079 api_modify_vhost_user_if (vat_main_t * vam)
10081 unformat_input_t *i = vam->input;
10082 vl_api_modify_vhost_user_if_t *mp;
10085 u8 file_name_set = 0;
10086 u32 custom_dev_instance = ~0;
10087 u8 sw_if_index_set = 0;
10088 u32 sw_if_index = (u32) ~ 0;
10090 u8 enable_packed = 0;
10093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10095 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10096 sw_if_index_set = 1;
10097 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10098 sw_if_index_set = 1;
10099 else if (unformat (i, "socket %s", &file_name))
10103 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10105 else if (unformat (i, "server"))
10107 else if (unformat (i, "gso"))
10109 else if (unformat (i, "packed"))
10115 if (sw_if_index_set == 0)
10117 errmsg ("missing sw_if_index or interface name");
10121 if (file_name_set == 0)
10123 errmsg ("missing socket file name");
10127 if (vec_len (file_name) > 255)
10129 errmsg ("socket file name too long");
10132 vec_add1 (file_name, 0);
10134 M (MODIFY_VHOST_USER_IF, mp);
10136 mp->sw_if_index = ntohl (sw_if_index);
10137 mp->is_server = is_server;
10138 mp->enable_gso = enable_gso;
10139 mp->enable_packed = enable_packed;
10140 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10141 vec_free (file_name);
10142 if (custom_dev_instance != ~0)
10145 mp->custom_dev_instance = ntohl (custom_dev_instance);
10154 api_delete_vhost_user_if (vat_main_t * vam)
10156 unformat_input_t *i = vam->input;
10157 vl_api_delete_vhost_user_if_t *mp;
10158 u32 sw_if_index = ~0;
10159 u8 sw_if_index_set = 0;
10162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10164 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10165 sw_if_index_set = 1;
10166 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10167 sw_if_index_set = 1;
10172 if (sw_if_index_set == 0)
10174 errmsg ("missing sw_if_index or interface name");
10179 M (DELETE_VHOST_USER_IF, mp);
10181 mp->sw_if_index = ntohl (sw_if_index);
10188 static void vl_api_sw_interface_vhost_user_details_t_handler
10189 (vl_api_sw_interface_vhost_user_details_t * mp)
10191 vat_main_t *vam = &vat_main;
10195 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
10196 clib_net_to_host_u32
10197 (mp->features_last_32) <<
10200 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
10201 (char *) mp->interface_name,
10202 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10203 features, mp->is_server,
10204 ntohl (mp->num_regions), (char *) mp->sock_filename);
10205 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
10208 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10209 (vl_api_sw_interface_vhost_user_details_t * mp)
10211 vat_main_t *vam = &vat_main;
10212 vat_json_node_t *node = NULL;
10214 if (VAT_JSON_ARRAY != vam->json_tree.type)
10216 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10217 vat_json_init_array (&vam->json_tree);
10219 node = vat_json_array_add (&vam->json_tree);
10221 vat_json_init_object (node);
10222 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10223 vat_json_object_add_string_copy (node, "interface_name",
10224 mp->interface_name);
10225 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10226 ntohl (mp->virtio_net_hdr_sz));
10227 vat_json_object_add_uint (node, "features_first_32",
10228 clib_net_to_host_u32 (mp->features_first_32));
10229 vat_json_object_add_uint (node, "features_last_32",
10230 clib_net_to_host_u32 (mp->features_last_32));
10231 vat_json_object_add_uint (node, "is_server", mp->is_server);
10232 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10233 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10234 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10238 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10240 unformat_input_t *i = vam->input;
10241 vl_api_sw_interface_vhost_user_dump_t *mp;
10242 vl_api_control_ping_t *mp_ping;
10244 u32 sw_if_index = ~0;
10246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10248 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10250 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10257 "Interface name idx hdr_sz features server regions filename");
10259 /* Get list of vhost-user interfaces */
10260 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
10261 mp->sw_if_index = ntohl (sw_if_index);
10264 /* Use a control ping for synchronization */
10265 MPING (CONTROL_PING, mp_ping);
10273 api_show_version (vat_main_t * vam)
10275 vl_api_show_version_t *mp;
10278 M (SHOW_VERSION, mp);
10287 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10289 unformat_input_t *line_input = vam->input;
10290 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10291 ip46_address_t local, remote;
10296 u32 mcast_sw_if_index = ~0;
10297 u32 encap_vrf_id = 0;
10298 u32 decap_vrf_id = 0;
10304 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10306 if (unformat (line_input, "del"))
10308 else if (unformat (line_input, "local %U",
10309 unformat_ip46_address, &local))
10313 else if (unformat (line_input, "remote %U",
10314 unformat_ip46_address, &remote))
10318 else if (unformat (line_input, "group %U %U",
10319 unformat_ip46_address, &remote,
10320 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10322 grp_set = remote_set = 1;
10324 else if (unformat (line_input, "group %U",
10325 unformat_ip46_address, &remote))
10327 grp_set = remote_set = 1;
10330 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10332 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10334 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10336 else if (unformat (line_input, "vni %d", &vni))
10338 else if (unformat (line_input, "next-ip4"))
10340 else if (unformat (line_input, "next-ip6"))
10342 else if (unformat (line_input, "next-ethernet"))
10344 else if (unformat (line_input, "next-nsh"))
10348 errmsg ("parse error '%U'", format_unformat_error, line_input);
10353 if (local_set == 0)
10355 errmsg ("tunnel local address not specified");
10358 if (remote_set == 0)
10360 errmsg ("tunnel remote address not specified");
10363 if (grp_set && mcast_sw_if_index == ~0)
10365 errmsg ("tunnel nonexistent multicast device");
10368 if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
10370 errmsg ("both IPv4 and IPv6 addresses specified");
10376 errmsg ("vni not specified");
10380 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
10382 ip_address_encode (&local,
10383 ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
10384 IP46_TYPE_IP6, &mp->local);
10385 ip_address_encode (&remote,
10386 ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
10387 IP46_TYPE_IP6, &mp->remote);
10389 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10390 mp->encap_vrf_id = ntohl (encap_vrf_id);
10391 mp->decap_vrf_id = ntohl (decap_vrf_id);
10392 mp->protocol = protocol;
10393 mp->vni = ntohl (vni);
10394 mp->is_add = is_add;
10401 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10402 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10404 vat_main_t *vam = &vat_main;
10405 ip46_address_t local, remote;
10407 ip_address_decode (&mp->local, &local);
10408 ip_address_decode (&mp->remote, &remote);
10410 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
10411 ntohl (mp->sw_if_index),
10412 format_ip46_address, &local, IP46_TYPE_ANY,
10413 format_ip46_address, &remote, IP46_TYPE_ANY,
10414 ntohl (mp->vni), mp->protocol,
10415 ntohl (mp->mcast_sw_if_index),
10416 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10420 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10421 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10423 vat_main_t *vam = &vat_main;
10424 vat_json_node_t *node = NULL;
10425 struct in_addr ip4;
10426 struct in6_addr ip6;
10427 ip46_address_t local, remote;
10429 ip_address_decode (&mp->local, &local);
10430 ip_address_decode (&mp->remote, &remote);
10432 if (VAT_JSON_ARRAY != vam->json_tree.type)
10434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10435 vat_json_init_array (&vam->json_tree);
10437 node = vat_json_array_add (&vam->json_tree);
10439 vat_json_init_object (node);
10440 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10441 if (ip46_address_is_ip4 (&local))
10443 clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
10444 vat_json_object_add_ip4 (node, "local", ip4);
10445 clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
10446 vat_json_object_add_ip4 (node, "remote", ip4);
10450 clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
10451 vat_json_object_add_ip6 (node, "local", ip6);
10452 clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
10453 vat_json_object_add_ip6 (node, "remote", ip6);
10455 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10456 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10457 vat_json_object_add_uint (node, "mcast_sw_if_index",
10458 ntohl (mp->mcast_sw_if_index));
10459 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10460 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10461 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10465 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10467 unformat_input_t *i = vam->input;
10468 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10469 vl_api_control_ping_t *mp_ping;
10471 u8 sw_if_index_set = 0;
10474 /* Parse args required to build the message */
10475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10477 if (unformat (i, "sw_if_index %d", &sw_if_index))
10478 sw_if_index_set = 1;
10483 if (sw_if_index_set == 0)
10488 if (!vam->json_output)
10490 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
10491 "sw_if_index", "local", "remote", "vni",
10492 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
10495 /* Get list of vxlan-tunnel interfaces */
10496 M (VXLAN_GPE_TUNNEL_DUMP, mp);
10498 mp->sw_if_index = htonl (sw_if_index);
10502 /* Use a control ping for synchronization */
10503 MPING (CONTROL_PING, mp_ping);
10510 static void vl_api_l2_fib_table_details_t_handler
10511 (vl_api_l2_fib_table_details_t * mp)
10513 vat_main_t *vam = &vat_main;
10515 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10517 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
10518 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10522 static void vl_api_l2_fib_table_details_t_handler_json
10523 (vl_api_l2_fib_table_details_t * mp)
10525 vat_main_t *vam = &vat_main;
10526 vat_json_node_t *node = NULL;
10528 if (VAT_JSON_ARRAY != vam->json_tree.type)
10530 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10531 vat_json_init_array (&vam->json_tree);
10533 node = vat_json_array_add (&vam->json_tree);
10535 vat_json_init_object (node);
10536 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10537 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
10538 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10539 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10540 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10541 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10545 api_l2_fib_table_dump (vat_main_t * vam)
10547 unformat_input_t *i = vam->input;
10548 vl_api_l2_fib_table_dump_t *mp;
10549 vl_api_control_ping_t *mp_ping;
10554 /* Parse args required to build the message */
10555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10557 if (unformat (i, "bd_id %d", &bd_id))
10563 if (bd_id_set == 0)
10565 errmsg ("missing bridge domain");
10569 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
10571 /* Get list of l2 fib entries */
10572 M (L2_FIB_TABLE_DUMP, mp);
10574 mp->bd_id = ntohl (bd_id);
10577 /* Use a control ping for synchronization */
10578 MPING (CONTROL_PING, mp_ping);
10587 api_interface_name_renumber (vat_main_t * vam)
10589 unformat_input_t *line_input = vam->input;
10590 vl_api_interface_name_renumber_t *mp;
10591 u32 sw_if_index = ~0;
10592 u32 new_show_dev_instance = ~0;
10595 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10597 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
10600 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10602 else if (unformat (line_input, "new_show_dev_instance %d",
10603 &new_show_dev_instance))
10609 if (sw_if_index == ~0)
10611 errmsg ("missing interface name or sw_if_index");
10615 if (new_show_dev_instance == ~0)
10617 errmsg ("missing new_show_dev_instance");
10621 M (INTERFACE_NAME_RENUMBER, mp);
10623 mp->sw_if_index = ntohl (sw_if_index);
10624 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10632 api_want_l2_macs_events (vat_main_t * vam)
10634 unformat_input_t *line_input = vam->input;
10635 vl_api_want_l2_macs_events_t *mp;
10636 u8 enable_disable = 1;
10637 u32 scan_delay = 0;
10638 u32 max_macs_in_event = 0;
10639 u32 learn_limit = 0;
10642 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10644 if (unformat (line_input, "learn-limit %d", &learn_limit))
10646 else if (unformat (line_input, "scan-delay %d", &scan_delay))
10648 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
10650 else if (unformat (line_input, "disable"))
10651 enable_disable = 0;
10656 M (WANT_L2_MACS_EVENTS, mp);
10657 mp->enable_disable = enable_disable;
10658 mp->pid = htonl (getpid ());
10659 mp->learn_limit = htonl (learn_limit);
10660 mp->scan_delay = (u8) scan_delay;
10661 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
10668 api_input_acl_set_interface (vat_main_t * vam)
10670 unformat_input_t *i = vam->input;
10671 vl_api_input_acl_set_interface_t *mp;
10673 int sw_if_index_set;
10674 u32 ip4_table_index = ~0;
10675 u32 ip6_table_index = ~0;
10676 u32 l2_table_index = ~0;
10680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10682 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10683 sw_if_index_set = 1;
10684 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10685 sw_if_index_set = 1;
10686 else if (unformat (i, "del"))
10688 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10690 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10692 else if (unformat (i, "l2-table %d", &l2_table_index))
10696 clib_warning ("parse error '%U'", format_unformat_error, i);
10701 if (sw_if_index_set == 0)
10703 errmsg ("missing interface name or sw_if_index");
10707 M (INPUT_ACL_SET_INTERFACE, mp);
10709 mp->sw_if_index = ntohl (sw_if_index);
10710 mp->ip4_table_index = ntohl (ip4_table_index);
10711 mp->ip6_table_index = ntohl (ip6_table_index);
10712 mp->l2_table_index = ntohl (l2_table_index);
10713 mp->is_add = is_add;
10721 api_output_acl_set_interface (vat_main_t * vam)
10723 unformat_input_t *i = vam->input;
10724 vl_api_output_acl_set_interface_t *mp;
10726 int sw_if_index_set;
10727 u32 ip4_table_index = ~0;
10728 u32 ip6_table_index = ~0;
10729 u32 l2_table_index = ~0;
10733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10735 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10736 sw_if_index_set = 1;
10737 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10738 sw_if_index_set = 1;
10739 else if (unformat (i, "del"))
10741 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10743 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10745 else if (unformat (i, "l2-table %d", &l2_table_index))
10749 clib_warning ("parse error '%U'", format_unformat_error, i);
10754 if (sw_if_index_set == 0)
10756 errmsg ("missing interface name or sw_if_index");
10760 M (OUTPUT_ACL_SET_INTERFACE, mp);
10762 mp->sw_if_index = ntohl (sw_if_index);
10763 mp->ip4_table_index = ntohl (ip4_table_index);
10764 mp->ip6_table_index = ntohl (ip6_table_index);
10765 mp->l2_table_index = ntohl (l2_table_index);
10766 mp->is_add = is_add;
10774 api_ip_address_dump (vat_main_t * vam)
10776 unformat_input_t *i = vam->input;
10777 vl_api_ip_address_dump_t *mp;
10778 vl_api_control_ping_t *mp_ping;
10779 u32 sw_if_index = ~0;
10780 u8 sw_if_index_set = 0;
10785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10787 if (unformat (i, "sw_if_index %d", &sw_if_index))
10788 sw_if_index_set = 1;
10790 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10791 sw_if_index_set = 1;
10792 else if (unformat (i, "ipv4"))
10794 else if (unformat (i, "ipv6"))
10800 if (ipv4_set && ipv6_set)
10802 errmsg ("ipv4 and ipv6 flags cannot be both set");
10806 if ((!ipv4_set) && (!ipv6_set))
10808 errmsg ("no ipv4 nor ipv6 flag set");
10812 if (sw_if_index_set == 0)
10814 errmsg ("missing interface name or sw_if_index");
10818 vam->current_sw_if_index = sw_if_index;
10819 vam->is_ipv6 = ipv6_set;
10821 M (IP_ADDRESS_DUMP, mp);
10822 mp->sw_if_index = ntohl (sw_if_index);
10823 mp->is_ipv6 = ipv6_set;
10826 /* Use a control ping for synchronization */
10827 MPING (CONTROL_PING, mp_ping);
10835 api_ip_dump (vat_main_t * vam)
10837 vl_api_ip_dump_t *mp;
10838 vl_api_control_ping_t *mp_ping;
10839 unformat_input_t *in = vam->input;
10846 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10848 if (unformat (in, "ipv4"))
10850 else if (unformat (in, "ipv6"))
10856 if (ipv4_set && ipv6_set)
10858 errmsg ("ipv4 and ipv6 flags cannot be both set");
10862 if ((!ipv4_set) && (!ipv6_set))
10864 errmsg ("no ipv4 nor ipv6 flag set");
10868 is_ipv6 = ipv6_set;
10869 vam->is_ipv6 = is_ipv6;
10871 /* free old data */
10872 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10874 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10876 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10879 mp->is_ipv6 = ipv6_set;
10882 /* Use a control ping for synchronization */
10883 MPING (CONTROL_PING, mp_ping);
10891 api_ipsec_spd_add_del (vat_main_t * vam)
10893 unformat_input_t *i = vam->input;
10894 vl_api_ipsec_spd_add_del_t *mp;
10899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10901 if (unformat (i, "spd_id %d", &spd_id))
10903 else if (unformat (i, "del"))
10907 clib_warning ("parse error '%U'", format_unformat_error, i);
10913 errmsg ("spd_id must be set");
10917 M (IPSEC_SPD_ADD_DEL, mp);
10919 mp->spd_id = ntohl (spd_id);
10920 mp->is_add = is_add;
10928 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10930 unformat_input_t *i = vam->input;
10931 vl_api_ipsec_interface_add_del_spd_t *mp;
10933 u8 sw_if_index_set = 0;
10934 u32 spd_id = (u32) ~ 0;
10938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10940 if (unformat (i, "del"))
10942 else if (unformat (i, "spd_id %d", &spd_id))
10945 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10946 sw_if_index_set = 1;
10947 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10948 sw_if_index_set = 1;
10951 clib_warning ("parse error '%U'", format_unformat_error, i);
10957 if (spd_id == (u32) ~ 0)
10959 errmsg ("spd_id must be set");
10963 if (sw_if_index_set == 0)
10965 errmsg ("missing interface name or sw_if_index");
10969 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
10971 mp->spd_id = ntohl (spd_id);
10972 mp->sw_if_index = ntohl (sw_if_index);
10973 mp->is_add = is_add;
10981 api_ipsec_spd_entry_add_del (vat_main_t * vam)
10983 unformat_input_t *i = vam->input;
10984 vl_api_ipsec_spd_entry_add_del_t *mp;
10985 u8 is_add = 1, is_outbound = 0;
10986 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10988 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10989 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10990 vl_api_address_t laddr_start = { }, laddr_stop =
10999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11001 if (unformat (i, "del"))
11003 if (unformat (i, "outbound"))
11005 if (unformat (i, "inbound"))
11007 else if (unformat (i, "spd_id %d", &spd_id))
11009 else if (unformat (i, "sa_id %d", &sa_id))
11011 else if (unformat (i, "priority %d", &priority))
11013 else if (unformat (i, "protocol %d", &protocol))
11015 else if (unformat (i, "lport_start %d", &lport_start))
11017 else if (unformat (i, "lport_stop %d", &lport_stop))
11019 else if (unformat (i, "rport_start %d", &rport_start))
11021 else if (unformat (i, "rport_stop %d", &rport_stop))
11023 else if (unformat (i, "laddr_start %U",
11024 unformat_vl_api_address, &laddr_start))
11026 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
11029 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
11032 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
11036 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11038 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11040 clib_warning ("unsupported action: 'resolve'");
11046 clib_warning ("parse error '%U'", format_unformat_error, i);
11052 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
11054 mp->is_add = is_add;
11056 mp->entry.spd_id = ntohl (spd_id);
11057 mp->entry.priority = ntohl (priority);
11058 mp->entry.is_outbound = is_outbound;
11060 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
11061 sizeof (vl_api_address_t));
11062 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
11063 sizeof (vl_api_address_t));
11064 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
11065 sizeof (vl_api_address_t));
11066 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
11067 sizeof (vl_api_address_t));
11069 mp->entry.protocol = (u8) protocol;
11070 mp->entry.local_port_start = ntohs ((u16) lport_start);
11071 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
11072 mp->entry.remote_port_start = ntohs ((u16) rport_start);
11073 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
11074 mp->entry.policy = (u8) policy;
11075 mp->entry.sa_id = ntohl (sa_id);
11083 api_ipsec_sad_entry_add_del (vat_main_t * vam)
11085 unformat_input_t *i = vam->input;
11086 vl_api_ipsec_sad_entry_add_del_t *mp;
11087 u32 sad_id = 0, spi = 0;
11088 u8 *ck = 0, *ik = 0;
11091 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
11092 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
11093 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
11094 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
11095 vl_api_address_t tun_src, tun_dst;
11098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11100 if (unformat (i, "del"))
11102 else if (unformat (i, "sad_id %d", &sad_id))
11104 else if (unformat (i, "spi %d", &spi))
11106 else if (unformat (i, "esp"))
11107 protocol = IPSEC_API_PROTO_ESP;
11109 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
11111 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
11112 if (ADDRESS_IP6 == tun_src.af)
11113 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
11116 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
11118 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
11119 if (ADDRESS_IP6 == tun_src.af)
11120 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
11123 if (unformat (i, "crypto_alg %U",
11124 unformat_ipsec_api_crypto_alg, &crypto_alg))
11126 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11128 else if (unformat (i, "integ_alg %U",
11129 unformat_ipsec_api_integ_alg, &integ_alg))
11131 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11135 clib_warning ("parse error '%U'", format_unformat_error, i);
11141 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
11143 mp->is_add = is_add;
11144 mp->entry.sad_id = ntohl (sad_id);
11145 mp->entry.protocol = protocol;
11146 mp->entry.spi = ntohl (spi);
11147 mp->entry.flags = flags;
11149 mp->entry.crypto_algorithm = crypto_alg;
11150 mp->entry.integrity_algorithm = integ_alg;
11151 mp->entry.crypto_key.length = vec_len (ck);
11152 mp->entry.integrity_key.length = vec_len (ik);
11154 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
11155 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
11157 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
11158 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
11161 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
11163 clib_memcpy (mp->entry.integrity_key.data, ik,
11164 mp->entry.integrity_key.length);
11166 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
11168 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
11169 sizeof (mp->entry.tunnel_src));
11170 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
11171 sizeof (mp->entry.tunnel_dst));
11180 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
11182 unformat_input_t *i = vam->input;
11183 vl_api_ipsec_tunnel_if_add_del_t *mp;
11184 u32 local_spi = 0, remote_spi = 0;
11185 u32 crypto_alg = 0, integ_alg = 0;
11186 u8 *lck = NULL, *rck = NULL;
11187 u8 *lik = NULL, *rik = NULL;
11188 vl_api_address_t local_ip = { 0 };
11189 vl_api_address_t remote_ip = { 0 };
11193 u8 anti_replay = 0;
11199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11201 if (unformat (i, "del"))
11203 else if (unformat (i, "esn"))
11205 else if (unformat (i, "anti-replay"))
11207 else if (unformat (i, "count %d", &count))
11209 else if (unformat (i, "local_spi %d", &local_spi))
11211 else if (unformat (i, "remote_spi %d", &remote_spi))
11214 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
11217 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
11219 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
11222 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
11224 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
11226 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
11230 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
11232 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
11234 errmsg ("unsupported crypto-alg: '%U'\n",
11235 format_ipsec_crypto_alg, crypto_alg);
11241 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
11243 if (integ_alg >= IPSEC_INTEG_N_ALG)
11245 errmsg ("unsupported integ-alg: '%U'\n",
11246 format_ipsec_integ_alg, integ_alg);
11250 else if (unformat (i, "instance %u", &instance))
11254 errmsg ("parse error '%U'\n", format_unformat_error, i);
11261 /* Turn on async mode */
11262 vam->async_mode = 1;
11263 vam->async_errors = 0;
11264 before = vat_time_now (vam);
11267 for (jj = 0; jj < count; jj++)
11269 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
11271 mp->is_add = is_add;
11273 mp->anti_replay = anti_replay;
11276 increment_address (&remote_ip);
11278 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
11279 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
11281 mp->local_spi = htonl (local_spi + jj);
11282 mp->remote_spi = htonl (remote_spi + jj);
11283 mp->crypto_alg = (u8) crypto_alg;
11285 mp->local_crypto_key_len = 0;
11288 mp->local_crypto_key_len = vec_len (lck);
11289 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
11290 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
11291 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
11294 mp->remote_crypto_key_len = 0;
11297 mp->remote_crypto_key_len = vec_len (rck);
11298 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
11299 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
11300 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
11303 mp->integ_alg = (u8) integ_alg;
11305 mp->local_integ_key_len = 0;
11308 mp->local_integ_key_len = vec_len (lik);
11309 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
11310 mp->local_integ_key_len = sizeof (mp->local_integ_key);
11311 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
11314 mp->remote_integ_key_len = 0;
11317 mp->remote_integ_key_len = vec_len (rik);
11318 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
11319 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
11320 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
11325 mp->renumber = renumber;
11326 mp->show_instance = ntohl (instance);
11331 /* When testing multiple add/del ops, use a control-ping to sync */
11334 vl_api_control_ping_t *mp_ping;
11338 /* Shut off async mode */
11339 vam->async_mode = 0;
11341 MPING (CONTROL_PING, mp_ping);
11344 timeout = vat_time_now (vam) + 1.0;
11345 while (vat_time_now (vam) < timeout)
11346 if (vam->result_ready == 1)
11351 if (vam->retval == -99)
11352 errmsg ("timeout");
11354 if (vam->async_errors > 0)
11356 errmsg ("%d asynchronous errors", vam->async_errors);
11359 vam->async_errors = 0;
11360 after = vat_time_now (vam);
11362 /* slim chance, but we might have eaten SIGTERM on the first iteration */
11366 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
11367 count, after - before, count / (after - before));
11371 /* Wait for a reply... */
11380 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
11382 vat_main_t *vam = &vat_main;
11384 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
11385 "crypto_key %U integ_alg %u integ_key %U flags %x "
11386 "tunnel_src_addr %U tunnel_dst_addr %U "
11387 "salt %u seq_outbound %lu last_seq_inbound %lu "
11388 "replay_window %lu stat_index %u\n",
11389 ntohl (mp->entry.sad_id),
11390 ntohl (mp->sw_if_index),
11391 ntohl (mp->entry.spi),
11392 ntohl (mp->entry.protocol),
11393 ntohl (mp->entry.crypto_algorithm),
11394 format_hex_bytes, mp->entry.crypto_key.data,
11395 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
11396 format_hex_bytes, mp->entry.integrity_key.data,
11397 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
11398 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
11399 &mp->entry.tunnel_dst, ntohl (mp->salt),
11400 clib_net_to_host_u64 (mp->seq_outbound),
11401 clib_net_to_host_u64 (mp->last_seq_inbound),
11402 clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
11405 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
11406 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
11408 static void vl_api_ipsec_sa_details_t_handler_json
11409 (vl_api_ipsec_sa_details_t * mp)
11411 vat_main_t *vam = &vat_main;
11412 vat_json_node_t *node = NULL;
11413 vl_api_ipsec_sad_flags_t flags;
11415 if (VAT_JSON_ARRAY != vam->json_tree.type)
11417 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11418 vat_json_init_array (&vam->json_tree);
11420 node = vat_json_array_add (&vam->json_tree);
11422 vat_json_init_object (node);
11423 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
11424 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11425 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
11426 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
11427 vat_json_object_add_uint (node, "crypto_alg",
11428 ntohl (mp->entry.crypto_algorithm));
11429 vat_json_object_add_uint (node, "integ_alg",
11430 ntohl (mp->entry.integrity_algorithm));
11431 flags = ntohl (mp->entry.flags);
11432 vat_json_object_add_uint (node, "use_esn",
11433 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
11434 vat_json_object_add_uint (node, "use_anti_replay",
11435 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
11436 vat_json_object_add_uint (node, "is_tunnel",
11437 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
11438 vat_json_object_add_uint (node, "is_tunnel_ip6",
11439 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
11440 vat_json_object_add_uint (node, "udp_encap",
11441 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
11442 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
11443 mp->entry.crypto_key.length);
11444 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
11445 mp->entry.integrity_key.length);
11446 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
11447 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
11448 vat_json_object_add_uint (node, "replay_window",
11449 clib_net_to_host_u64 (mp->replay_window));
11450 vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
11454 api_ipsec_sa_dump (vat_main_t * vam)
11456 unformat_input_t *i = vam->input;
11457 vl_api_ipsec_sa_dump_t *mp;
11458 vl_api_control_ping_t *mp_ping;
11462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11464 if (unformat (i, "sa_id %d", &sa_id))
11468 clib_warning ("parse error '%U'", format_unformat_error, i);
11473 M (IPSEC_SA_DUMP, mp);
11475 mp->sa_id = ntohl (sa_id);
11479 /* Use a control ping for synchronization */
11480 M (CONTROL_PING, mp_ping);
11488 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
11490 unformat_input_t *i = vam->input;
11491 vl_api_ipsec_tunnel_if_set_sa_t *mp;
11492 u32 sw_if_index = ~0;
11494 u8 is_outbound = (u8) ~ 0;
11497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11499 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11501 else if (unformat (i, "sa_id %d", &sa_id))
11503 else if (unformat (i, "outbound"))
11505 else if (unformat (i, "inbound"))
11509 clib_warning ("parse error '%U'", format_unformat_error, i);
11514 if (sw_if_index == ~0)
11516 errmsg ("interface must be specified");
11522 errmsg ("SA ID must be specified");
11526 M (IPSEC_TUNNEL_IF_SET_SA, mp);
11528 mp->sw_if_index = htonl (sw_if_index);
11529 mp->sa_id = htonl (sa_id);
11530 mp->is_outbound = is_outbound;
11539 api_get_first_msg_id (vat_main_t * vam)
11541 vl_api_get_first_msg_id_t *mp;
11542 unformat_input_t *i = vam->input;
11547 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11549 if (unformat (i, "client %s", &name))
11557 errmsg ("missing client name");
11560 vec_add1 (name, 0);
11562 if (vec_len (name) > 63)
11564 errmsg ("client name too long");
11568 M (GET_FIRST_MSG_ID, mp);
11569 clib_memcpy (mp->name, name, vec_len (name));
11576 api_cop_interface_enable_disable (vat_main_t * vam)
11578 unformat_input_t *line_input = vam->input;
11579 vl_api_cop_interface_enable_disable_t *mp;
11580 u32 sw_if_index = ~0;
11581 u8 enable_disable = 1;
11584 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11586 if (unformat (line_input, "disable"))
11587 enable_disable = 0;
11588 if (unformat (line_input, "enable"))
11589 enable_disable = 1;
11590 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
11591 vam, &sw_if_index))
11593 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11599 if (sw_if_index == ~0)
11601 errmsg ("missing interface name or sw_if_index");
11605 /* Construct the API message */
11606 M (COP_INTERFACE_ENABLE_DISABLE, mp);
11607 mp->sw_if_index = ntohl (sw_if_index);
11608 mp->enable_disable = enable_disable;
11612 /* Wait for the reply */
11618 api_cop_whitelist_enable_disable (vat_main_t * vam)
11620 unformat_input_t *line_input = vam->input;
11621 vl_api_cop_whitelist_enable_disable_t *mp;
11622 u32 sw_if_index = ~0;
11623 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11627 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11629 if (unformat (line_input, "ip4"))
11631 else if (unformat (line_input, "ip6"))
11633 else if (unformat (line_input, "default"))
11635 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
11636 vam, &sw_if_index))
11638 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11640 else if (unformat (line_input, "fib-id %d", &fib_id))
11646 if (sw_if_index == ~0)
11648 errmsg ("missing interface name or sw_if_index");
11652 /* Construct the API message */
11653 M (COP_WHITELIST_ENABLE_DISABLE, mp);
11654 mp->sw_if_index = ntohl (sw_if_index);
11655 mp->fib_id = ntohl (fib_id);
11658 mp->default_cop = default_cop;
11662 /* Wait for the reply */
11668 api_get_node_graph (vat_main_t * vam)
11670 vl_api_get_node_graph_t *mp;
11673 M (GET_NODE_GRAPH, mp);
11677 /* Wait for the reply */
11683 api_af_packet_create (vat_main_t * vam)
11685 unformat_input_t *i = vam->input;
11686 vl_api_af_packet_create_t *mp;
11687 u8 *host_if_name = 0;
11689 u8 random_hw_addr = 1;
11692 clib_memset (hw_addr, 0, sizeof (hw_addr));
11694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11696 if (unformat (i, "name %s", &host_if_name))
11697 vec_add1 (host_if_name, 0);
11698 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
11699 random_hw_addr = 0;
11704 if (!vec_len (host_if_name))
11706 errmsg ("host-interface name must be specified");
11710 if (vec_len (host_if_name) > 64)
11712 errmsg ("host-interface name too long");
11716 M (AF_PACKET_CREATE, mp);
11718 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11719 clib_memcpy (mp->hw_addr, hw_addr, 6);
11720 mp->use_random_hw_addr = random_hw_addr;
11721 vec_free (host_if_name);
11729 fprintf (vam->ofp ? vam->ofp : stderr,
11730 " new sw_if_index = %d\n", vam->sw_if_index);
11737 api_af_packet_delete (vat_main_t * vam)
11739 unformat_input_t *i = vam->input;
11740 vl_api_af_packet_delete_t *mp;
11741 u8 *host_if_name = 0;
11744 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11746 if (unformat (i, "name %s", &host_if_name))
11747 vec_add1 (host_if_name, 0);
11752 if (!vec_len (host_if_name))
11754 errmsg ("host-interface name must be specified");
11758 if (vec_len (host_if_name) > 64)
11760 errmsg ("host-interface name too long");
11764 M (AF_PACKET_DELETE, mp);
11766 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11767 vec_free (host_if_name);
11774 static void vl_api_af_packet_details_t_handler
11775 (vl_api_af_packet_details_t * mp)
11777 vat_main_t *vam = &vat_main;
11779 print (vam->ofp, "%-16s %d",
11780 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
11783 static void vl_api_af_packet_details_t_handler_json
11784 (vl_api_af_packet_details_t * mp)
11786 vat_main_t *vam = &vat_main;
11787 vat_json_node_t *node = NULL;
11789 if (VAT_JSON_ARRAY != vam->json_tree.type)
11791 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11792 vat_json_init_array (&vam->json_tree);
11794 node = vat_json_array_add (&vam->json_tree);
11796 vat_json_init_object (node);
11797 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11798 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
11802 api_af_packet_dump (vat_main_t * vam)
11804 vl_api_af_packet_dump_t *mp;
11805 vl_api_control_ping_t *mp_ping;
11808 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
11809 /* Get list of tap interfaces */
11810 M (AF_PACKET_DUMP, mp);
11813 /* Use a control ping for synchronization */
11814 MPING (CONTROL_PING, mp_ping);
11822 api_policer_add_del (vat_main_t * vam)
11824 unformat_input_t *i = vam->input;
11825 vl_api_policer_add_del_t *mp;
11835 u8 color_aware = 0;
11836 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
11839 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
11840 conform_action.dscp = 0;
11841 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
11842 exceed_action.dscp = 0;
11843 violate_action.action_type = SSE2_QOS_ACTION_DROP;
11844 violate_action.dscp = 0;
11846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11848 if (unformat (i, "del"))
11850 else if (unformat (i, "name %s", &name))
11851 vec_add1 (name, 0);
11852 else if (unformat (i, "cir %u", &cir))
11854 else if (unformat (i, "eir %u", &eir))
11856 else if (unformat (i, "cb %u", &cb))
11858 else if (unformat (i, "eb %u", &eb))
11860 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
11863 else if (unformat (i, "round_type %U", unformat_policer_round_type,
11866 else if (unformat (i, "type %U", unformat_policer_type, &type))
11868 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
11871 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
11874 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
11877 else if (unformat (i, "color-aware"))
11883 if (!vec_len (name))
11885 errmsg ("policer name must be specified");
11889 if (vec_len (name) > 64)
11891 errmsg ("policer name too long");
11895 M (POLICER_ADD_DEL, mp);
11897 clib_memcpy (mp->name, name, vec_len (name));
11899 mp->is_add = is_add;
11900 mp->cir = ntohl (cir);
11901 mp->eir = ntohl (eir);
11902 mp->cb = clib_net_to_host_u64 (cb);
11903 mp->eb = clib_net_to_host_u64 (eb);
11904 mp->rate_type = rate_type;
11905 mp->round_type = round_type;
11907 mp->conform_action.type = conform_action.action_type;
11908 mp->conform_action.dscp = conform_action.dscp;
11909 mp->exceed_action.type = exceed_action.action_type;
11910 mp->exceed_action.dscp = exceed_action.dscp;
11911 mp->violate_action.type = violate_action.action_type;
11912 mp->violate_action.dscp = violate_action.dscp;
11913 mp->color_aware = color_aware;
11921 api_policer_dump (vat_main_t * vam)
11923 unformat_input_t *i = vam->input;
11924 vl_api_policer_dump_t *mp;
11925 vl_api_control_ping_t *mp_ping;
11926 u8 *match_name = 0;
11927 u8 match_name_valid = 0;
11930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11932 if (unformat (i, "name %s", &match_name))
11934 vec_add1 (match_name, 0);
11935 match_name_valid = 1;
11941 M (POLICER_DUMP, mp);
11942 mp->match_name_valid = match_name_valid;
11943 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
11944 vec_free (match_name);
11948 /* Use a control ping for synchronization */
11949 MPING (CONTROL_PING, mp_ping);
11952 /* Wait for a reply... */
11958 api_policer_classify_set_interface (vat_main_t * vam)
11960 unformat_input_t *i = vam->input;
11961 vl_api_policer_classify_set_interface_t *mp;
11963 int sw_if_index_set;
11964 u32 ip4_table_index = ~0;
11965 u32 ip6_table_index = ~0;
11966 u32 l2_table_index = ~0;
11970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11972 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11973 sw_if_index_set = 1;
11974 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11975 sw_if_index_set = 1;
11976 else if (unformat (i, "del"))
11978 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11980 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11982 else if (unformat (i, "l2-table %d", &l2_table_index))
11986 clib_warning ("parse error '%U'", format_unformat_error, i);
11991 if (sw_if_index_set == 0)
11993 errmsg ("missing interface name or sw_if_index");
11997 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
11999 mp->sw_if_index = ntohl (sw_if_index);
12000 mp->ip4_table_index = ntohl (ip4_table_index);
12001 mp->ip6_table_index = ntohl (ip6_table_index);
12002 mp->l2_table_index = ntohl (l2_table_index);
12003 mp->is_add = is_add;
12011 api_policer_classify_dump (vat_main_t * vam)
12013 unformat_input_t *i = vam->input;
12014 vl_api_policer_classify_dump_t *mp;
12015 vl_api_control_ping_t *mp_ping;
12016 u8 type = POLICER_CLASSIFY_N_TABLES;
12019 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
12023 errmsg ("classify table type must be specified");
12027 if (!vam->json_output)
12029 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
12032 M (POLICER_CLASSIFY_DUMP, mp);
12037 /* Use a control ping for synchronization */
12038 MPING (CONTROL_PING, mp_ping);
12041 /* Wait for a reply... */
12047 format_fib_api_path_nh_proto (u8 * s, va_list * args)
12049 vl_api_fib_path_nh_proto_t proto =
12050 va_arg (*args, vl_api_fib_path_nh_proto_t);
12054 case FIB_API_PATH_NH_PROTO_IP4:
12055 s = format (s, "ip4");
12057 case FIB_API_PATH_NH_PROTO_IP6:
12058 s = format (s, "ip6");
12060 case FIB_API_PATH_NH_PROTO_MPLS:
12061 s = format (s, "mpls");
12063 case FIB_API_PATH_NH_PROTO_BIER:
12064 s = format (s, "bier");
12066 case FIB_API_PATH_NH_PROTO_ETHERNET:
12067 s = format (s, "ethernet");
12075 format_vl_api_ip_address_union (u8 * s, va_list * args)
12077 vl_api_address_family_t af = va_arg (*args, int);
12078 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
12083 s = format (s, "%U", format_ip4_address, u->ip4);
12086 s = format (s, "%U", format_ip6_address, u->ip6);
12093 format_vl_api_fib_path_type (u8 * s, va_list * args)
12095 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
12099 case FIB_API_PATH_TYPE_NORMAL:
12100 s = format (s, "normal");
12102 case FIB_API_PATH_TYPE_LOCAL:
12103 s = format (s, "local");
12105 case FIB_API_PATH_TYPE_DROP:
12106 s = format (s, "drop");
12108 case FIB_API_PATH_TYPE_UDP_ENCAP:
12109 s = format (s, "udp-encap");
12111 case FIB_API_PATH_TYPE_BIER_IMP:
12112 s = format (s, "bier-imp");
12114 case FIB_API_PATH_TYPE_ICMP_UNREACH:
12115 s = format (s, "unreach");
12117 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
12118 s = format (s, "prohibit");
12120 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
12121 s = format (s, "src-lookup");
12123 case FIB_API_PATH_TYPE_DVR:
12124 s = format (s, "dvr");
12126 case FIB_API_PATH_TYPE_INTERFACE_RX:
12127 s = format (s, "interface-rx");
12129 case FIB_API_PATH_TYPE_CLASSIFY:
12130 s = format (s, "classify");
12138 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
12141 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
12142 ntohl (fp->weight), ntohl (fp->sw_if_index),
12143 format_vl_api_fib_path_type, fp->type,
12144 format_fib_api_path_nh_proto, fp->proto,
12145 format_vl_api_ip_address_union, &fp->nh.address);
12149 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
12150 vl_api_fib_path_t * fp)
12152 struct in_addr ip4;
12153 struct in6_addr ip6;
12155 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
12156 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
12157 vat_json_object_add_uint (node, "type", fp->type);
12158 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
12159 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
12161 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
12162 vat_json_object_add_ip4 (node, "next_hop", ip4);
12164 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
12166 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
12167 vat_json_object_add_ip6 (node, "next_hop", ip6);
12172 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
12174 vat_main_t *vam = &vat_main;
12175 int count = ntohl (mp->mt_tunnel.mt_n_paths);
12176 vl_api_fib_path_t *fp;
12179 print (vam->ofp, "sw_if_index %d via:",
12180 ntohl (mp->mt_tunnel.mt_sw_if_index));
12181 fp = mp->mt_tunnel.mt_paths;
12182 for (i = 0; i < count; i++)
12184 vl_api_fib_path_print (vam, fp);
12188 print (vam->ofp, "");
12191 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
12192 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
12195 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
12197 vat_main_t *vam = &vat_main;
12198 vat_json_node_t *node = NULL;
12199 int count = ntohl (mp->mt_tunnel.mt_n_paths);
12200 vl_api_fib_path_t *fp;
12203 if (VAT_JSON_ARRAY != vam->json_tree.type)
12205 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12206 vat_json_init_array (&vam->json_tree);
12208 node = vat_json_array_add (&vam->json_tree);
12210 vat_json_init_object (node);
12211 vat_json_object_add_uint (node, "sw_if_index",
12212 ntohl (mp->mt_tunnel.mt_sw_if_index));
12214 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
12216 fp = mp->mt_tunnel.mt_paths;
12217 for (i = 0; i < count; i++)
12219 vl_api_mpls_fib_path_json_print (node, fp);
12225 api_mpls_tunnel_dump (vat_main_t * vam)
12227 vl_api_mpls_tunnel_dump_t *mp;
12228 vl_api_control_ping_t *mp_ping;
12231 M (MPLS_TUNNEL_DUMP, mp);
12235 /* Use a control ping for synchronization */
12236 MPING (CONTROL_PING, mp_ping);
12243 #define vl_api_mpls_table_details_t_endian vl_noop_handler
12244 #define vl_api_mpls_table_details_t_print vl_noop_handler
12248 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
12250 vat_main_t *vam = &vat_main;
12252 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
12255 static void vl_api_mpls_table_details_t_handler_json
12256 (vl_api_mpls_table_details_t * mp)
12258 vat_main_t *vam = &vat_main;
12259 vat_json_node_t *node = NULL;
12261 if (VAT_JSON_ARRAY != vam->json_tree.type)
12263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12264 vat_json_init_array (&vam->json_tree);
12266 node = vat_json_array_add (&vam->json_tree);
12268 vat_json_init_object (node);
12269 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
12273 api_mpls_table_dump (vat_main_t * vam)
12275 vl_api_mpls_table_dump_t *mp;
12276 vl_api_control_ping_t *mp_ping;
12279 M (MPLS_TABLE_DUMP, mp);
12282 /* Use a control ping for synchronization */
12283 MPING (CONTROL_PING, mp_ping);
12290 #define vl_api_mpls_route_details_t_endian vl_noop_handler
12291 #define vl_api_mpls_route_details_t_print vl_noop_handler
12294 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
12296 vat_main_t *vam = &vat_main;
12297 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
12298 vl_api_fib_path_t *fp;
12302 "table-id %d, label %u, ess_bit %u",
12303 ntohl (mp->mr_route.mr_table_id),
12304 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
12305 fp = mp->mr_route.mr_paths;
12306 for (i = 0; i < count; i++)
12308 vl_api_fib_path_print (vam, fp);
12313 static void vl_api_mpls_route_details_t_handler_json
12314 (vl_api_mpls_route_details_t * mp)
12316 vat_main_t *vam = &vat_main;
12317 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
12318 vat_json_node_t *node = NULL;
12319 vl_api_fib_path_t *fp;
12322 if (VAT_JSON_ARRAY != vam->json_tree.type)
12324 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12325 vat_json_init_array (&vam->json_tree);
12327 node = vat_json_array_add (&vam->json_tree);
12329 vat_json_init_object (node);
12330 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
12331 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
12332 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
12333 vat_json_object_add_uint (node, "path_count", count);
12334 fp = mp->mr_route.mr_paths;
12335 for (i = 0; i < count; i++)
12337 vl_api_mpls_fib_path_json_print (node, fp);
12343 api_mpls_route_dump (vat_main_t * vam)
12345 unformat_input_t *input = vam->input;
12346 vl_api_mpls_route_dump_t *mp;
12347 vl_api_control_ping_t *mp_ping;
12351 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12353 if (unformat (input, "table_id %d", &table_id))
12358 if (table_id == ~0)
12360 errmsg ("missing table id");
12364 M (MPLS_ROUTE_DUMP, mp);
12366 mp->table.mt_table_id = ntohl (table_id);
12369 /* Use a control ping for synchronization */
12370 MPING (CONTROL_PING, mp_ping);
12377 #define vl_api_ip_table_details_t_endian vl_noop_handler
12378 #define vl_api_ip_table_details_t_print vl_noop_handler
12381 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
12383 vat_main_t *vam = &vat_main;
12386 "%s; table-id %d, prefix %U/%d",
12387 mp->table.name, ntohl (mp->table.table_id));
12391 static void vl_api_ip_table_details_t_handler_json
12392 (vl_api_ip_table_details_t * mp)
12394 vat_main_t *vam = &vat_main;
12395 vat_json_node_t *node = NULL;
12397 if (VAT_JSON_ARRAY != vam->json_tree.type)
12399 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12400 vat_json_init_array (&vam->json_tree);
12402 node = vat_json_array_add (&vam->json_tree);
12404 vat_json_init_object (node);
12405 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
12409 api_ip_table_dump (vat_main_t * vam)
12411 vl_api_ip_table_dump_t *mp;
12412 vl_api_control_ping_t *mp_ping;
12415 M (IP_TABLE_DUMP, mp);
12418 /* Use a control ping for synchronization */
12419 MPING (CONTROL_PING, mp_ping);
12427 api_ip_mtable_dump (vat_main_t * vam)
12429 vl_api_ip_mtable_dump_t *mp;
12430 vl_api_control_ping_t *mp_ping;
12433 M (IP_MTABLE_DUMP, mp);
12436 /* Use a control ping for synchronization */
12437 MPING (CONTROL_PING, mp_ping);
12445 api_ip_mroute_dump (vat_main_t * vam)
12447 unformat_input_t *input = vam->input;
12448 vl_api_control_ping_t *mp_ping;
12449 vl_api_ip_mroute_dump_t *mp;
12454 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12456 if (unformat (input, "table_id %d", &table_id))
12458 else if (unformat (input, "ip6"))
12460 else if (unformat (input, "ip4"))
12465 if (table_id == ~0)
12467 errmsg ("missing table id");
12471 M (IP_MROUTE_DUMP, mp);
12472 mp->table.table_id = table_id;
12473 mp->table.is_ip6 = is_ip6;
12476 /* Use a control ping for synchronization */
12477 MPING (CONTROL_PING, mp_ping);
12484 #define vl_api_ip_route_details_t_endian vl_noop_handler
12485 #define vl_api_ip_route_details_t_print vl_noop_handler
12488 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
12490 vat_main_t *vam = &vat_main;
12491 u8 count = mp->route.n_paths;
12492 vl_api_fib_path_t *fp;
12496 "table-id %d, prefix %U/%d",
12497 ntohl (mp->route.table_id),
12498 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
12499 for (i = 0; i < count; i++)
12501 fp = &mp->route.paths[i];
12503 vl_api_fib_path_print (vam, fp);
12508 static void vl_api_ip_route_details_t_handler_json
12509 (vl_api_ip_route_details_t * mp)
12511 vat_main_t *vam = &vat_main;
12512 u8 count = mp->route.n_paths;
12513 vat_json_node_t *node = NULL;
12514 struct in_addr ip4;
12515 struct in6_addr ip6;
12516 vl_api_fib_path_t *fp;
12519 if (VAT_JSON_ARRAY != vam->json_tree.type)
12521 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12522 vat_json_init_array (&vam->json_tree);
12524 node = vat_json_array_add (&vam->json_tree);
12526 vat_json_init_object (node);
12527 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
12528 if (ADDRESS_IP6 == mp->route.prefix.address.af)
12530 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
12531 vat_json_object_add_ip6 (node, "prefix", ip6);
12535 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
12536 vat_json_object_add_ip4 (node, "prefix", ip4);
12538 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
12539 vat_json_object_add_uint (node, "path_count", count);
12540 for (i = 0; i < count; i++)
12542 fp = &mp->route.paths[i];
12543 vl_api_mpls_fib_path_json_print (node, fp);
12548 api_ip_route_dump (vat_main_t * vam)
12550 unformat_input_t *input = vam->input;
12551 vl_api_ip_route_dump_t *mp;
12552 vl_api_control_ping_t *mp_ping;
12558 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12560 if (unformat (input, "table_id %d", &table_id))
12562 else if (unformat (input, "ip6"))
12564 else if (unformat (input, "ip4"))
12569 if (table_id == ~0)
12571 errmsg ("missing table id");
12575 M (IP_ROUTE_DUMP, mp);
12577 mp->table.table_id = table_id;
12578 mp->table.is_ip6 = is_ip6;
12582 /* Use a control ping for synchronization */
12583 MPING (CONTROL_PING, mp_ping);
12591 api_classify_table_ids (vat_main_t * vam)
12593 vl_api_classify_table_ids_t *mp;
12596 /* Construct the API message */
12597 M (CLASSIFY_TABLE_IDS, mp);
12606 api_classify_table_by_interface (vat_main_t * vam)
12608 unformat_input_t *input = vam->input;
12609 vl_api_classify_table_by_interface_t *mp;
12611 u32 sw_if_index = ~0;
12613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12615 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12617 else if (unformat (input, "sw_if_index %d", &sw_if_index))
12622 if (sw_if_index == ~0)
12624 errmsg ("missing interface name or sw_if_index");
12628 /* Construct the API message */
12629 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
12631 mp->sw_if_index = ntohl (sw_if_index);
12639 api_classify_table_info (vat_main_t * vam)
12641 unformat_input_t *input = vam->input;
12642 vl_api_classify_table_info_t *mp;
12646 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12648 if (unformat (input, "table_id %d", &table_id))
12653 if (table_id == ~0)
12655 errmsg ("missing table id");
12659 /* Construct the API message */
12660 M (CLASSIFY_TABLE_INFO, mp);
12662 mp->table_id = ntohl (table_id);
12670 api_classify_session_dump (vat_main_t * vam)
12672 unformat_input_t *input = vam->input;
12673 vl_api_classify_session_dump_t *mp;
12674 vl_api_control_ping_t *mp_ping;
12678 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12680 if (unformat (input, "table_id %d", &table_id))
12685 if (table_id == ~0)
12687 errmsg ("missing table id");
12691 /* Construct the API message */
12692 M (CLASSIFY_SESSION_DUMP, mp);
12694 mp->table_id = ntohl (table_id);
12697 /* Use a control ping for synchronization */
12698 MPING (CONTROL_PING, mp_ping);
12706 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
12708 vat_main_t *vam = &vat_main;
12710 print (vam->ofp, "collector_address %U, collector_port %d, "
12711 "src_address %U, vrf_id %d, path_mtu %u, "
12712 "template_interval %u, udp_checksum %d",
12713 format_ip4_address, mp->collector_address,
12714 ntohs (mp->collector_port),
12715 format_ip4_address, mp->src_address,
12716 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
12717 ntohl (mp->template_interval), mp->udp_checksum);
12720 vam->result_ready = 1;
12724 vl_api_ipfix_exporter_details_t_handler_json
12725 (vl_api_ipfix_exporter_details_t * mp)
12727 vat_main_t *vam = &vat_main;
12728 vat_json_node_t node;
12729 struct in_addr collector_address;
12730 struct in_addr src_address;
12732 vat_json_init_object (&node);
12733 clib_memcpy (&collector_address, &mp->collector_address,
12734 sizeof (collector_address));
12735 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
12736 vat_json_object_add_uint (&node, "collector_port",
12737 ntohs (mp->collector_port));
12738 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
12739 vat_json_object_add_ip4 (&node, "src_address", src_address);
12740 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
12741 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
12742 vat_json_object_add_uint (&node, "template_interval",
12743 ntohl (mp->template_interval));
12744 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
12746 vat_json_print (vam->ofp, &node);
12747 vat_json_free (&node);
12749 vam->result_ready = 1;
12753 api_ipfix_exporter_dump (vat_main_t * vam)
12755 vl_api_ipfix_exporter_dump_t *mp;
12758 /* Construct the API message */
12759 M (IPFIX_EXPORTER_DUMP, mp);
12768 api_ipfix_classify_stream_dump (vat_main_t * vam)
12770 vl_api_ipfix_classify_stream_dump_t *mp;
12773 /* Construct the API message */
12774 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
12785 vl_api_ipfix_classify_stream_details_t_handler
12786 (vl_api_ipfix_classify_stream_details_t * mp)
12788 vat_main_t *vam = &vat_main;
12789 print (vam->ofp, "domain_id %d, src_port %d",
12790 ntohl (mp->domain_id), ntohs (mp->src_port));
12792 vam->result_ready = 1;
12796 vl_api_ipfix_classify_stream_details_t_handler_json
12797 (vl_api_ipfix_classify_stream_details_t * mp)
12799 vat_main_t *vam = &vat_main;
12800 vat_json_node_t node;
12802 vat_json_init_object (&node);
12803 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
12804 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
12806 vat_json_print (vam->ofp, &node);
12807 vat_json_free (&node);
12809 vam->result_ready = 1;
12813 api_ipfix_classify_table_dump (vat_main_t * vam)
12815 vl_api_ipfix_classify_table_dump_t *mp;
12816 vl_api_control_ping_t *mp_ping;
12819 if (!vam->json_output)
12821 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
12822 "transport_protocol");
12825 /* Construct the API message */
12826 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
12831 /* Use a control ping for synchronization */
12832 MPING (CONTROL_PING, mp_ping);
12840 vl_api_ipfix_classify_table_details_t_handler
12841 (vl_api_ipfix_classify_table_details_t * mp)
12843 vat_main_t *vam = &vat_main;
12844 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
12845 mp->transport_protocol);
12849 vl_api_ipfix_classify_table_details_t_handler_json
12850 (vl_api_ipfix_classify_table_details_t * mp)
12852 vat_json_node_t *node = NULL;
12853 vat_main_t *vam = &vat_main;
12855 if (VAT_JSON_ARRAY != vam->json_tree.type)
12857 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12858 vat_json_init_array (&vam->json_tree);
12861 node = vat_json_array_add (&vam->json_tree);
12862 vat_json_init_object (node);
12864 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
12865 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
12866 vat_json_object_add_uint (node, "transport_protocol",
12867 mp->transport_protocol);
12871 api_sw_interface_span_enable_disable (vat_main_t * vam)
12873 unformat_input_t *i = vam->input;
12874 vl_api_sw_interface_span_enable_disable_t *mp;
12875 u32 src_sw_if_index = ~0;
12876 u32 dst_sw_if_index = ~0;
12881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12884 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
12886 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
12890 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
12892 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
12894 else if (unformat (i, "disable"))
12896 else if (unformat (i, "rx"))
12898 else if (unformat (i, "tx"))
12900 else if (unformat (i, "both"))
12902 else if (unformat (i, "l2"))
12908 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
12910 mp->sw_if_index_from = htonl (src_sw_if_index);
12911 mp->sw_if_index_to = htonl (dst_sw_if_index);
12921 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
12924 vat_main_t *vam = &vat_main;
12925 u8 *sw_if_from_name = 0;
12926 u8 *sw_if_to_name = 0;
12927 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
12928 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
12929 char *states[] = { "none", "rx", "tx", "both" };
12933 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
12935 if ((u32) p->value[0] == sw_if_index_from)
12937 sw_if_from_name = (u8 *)(p->key);
12941 if ((u32) p->value[0] == sw_if_index_to)
12943 sw_if_to_name = (u8 *)(p->key);
12944 if (sw_if_from_name)
12949 print (vam->ofp, "%20s => %20s (%s) %s",
12950 sw_if_from_name, sw_if_to_name, states[mp->state],
12951 mp->is_l2 ? "l2" : "device");
12955 vl_api_sw_interface_span_details_t_handler_json
12956 (vl_api_sw_interface_span_details_t * mp)
12958 vat_main_t *vam = &vat_main;
12959 vat_json_node_t *node = NULL;
12960 u8 *sw_if_from_name = 0;
12961 u8 *sw_if_to_name = 0;
12962 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
12963 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
12967 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
12969 if ((u32) p->value[0] == sw_if_index_from)
12971 sw_if_from_name = (u8 *)(p->key);
12975 if ((u32) p->value[0] == sw_if_index_to)
12977 sw_if_to_name = (u8 *)(p->key);
12978 if (sw_if_from_name)
12984 if (VAT_JSON_ARRAY != vam->json_tree.type)
12986 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12987 vat_json_init_array (&vam->json_tree);
12989 node = vat_json_array_add (&vam->json_tree);
12991 vat_json_init_object (node);
12992 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
12993 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
12994 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
12995 if (0 != sw_if_to_name)
12997 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
12999 vat_json_object_add_uint (node, "state", mp->state);
13000 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
13004 api_sw_interface_span_dump (vat_main_t * vam)
13006 unformat_input_t *input = vam->input;
13007 vl_api_sw_interface_span_dump_t *mp;
13008 vl_api_control_ping_t *mp_ping;
13012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13014 if (unformat (input, "l2"))
13020 M (SW_INTERFACE_SPAN_DUMP, mp);
13024 /* Use a control ping for synchronization */
13025 MPING (CONTROL_PING, mp_ping);
13033 api_pg_create_interface (vat_main_t * vam)
13035 unformat_input_t *input = vam->input;
13036 vl_api_pg_create_interface_t *mp;
13038 u32 if_id = ~0, gso_size = 0;
13039 u8 gso_enabled = 0;
13041 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13043 if (unformat (input, "if_id %d", &if_id))
13045 else if (unformat (input, "gso-enabled"))
13048 if (unformat (input, "gso-size %u", &gso_size))
13052 errmsg ("missing gso-size");
13061 errmsg ("missing pg interface index");
13065 /* Construct the API message */
13066 M (PG_CREATE_INTERFACE, mp);
13068 mp->interface_id = ntohl (if_id);
13069 mp->gso_enabled = gso_enabled;
13077 api_pg_capture (vat_main_t * vam)
13079 unformat_input_t *input = vam->input;
13080 vl_api_pg_capture_t *mp;
13085 u8 pcap_file_set = 0;
13088 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13090 if (unformat (input, "if_id %d", &if_id))
13092 else if (unformat (input, "pcap %s", &pcap_file))
13094 else if (unformat (input, "count %d", &count))
13096 else if (unformat (input, "disable"))
13103 errmsg ("missing pg interface index");
13106 if (pcap_file_set > 0)
13108 if (vec_len (pcap_file) > 255)
13110 errmsg ("pcap file name is too long");
13115 /* Construct the API message */
13116 M (PG_CAPTURE, mp);
13118 mp->interface_id = ntohl (if_id);
13119 mp->is_enabled = enable;
13120 mp->count = ntohl (count);
13121 if (pcap_file_set != 0)
13123 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
13125 vec_free (pcap_file);
13133 api_pg_enable_disable (vat_main_t * vam)
13135 unformat_input_t *input = vam->input;
13136 vl_api_pg_enable_disable_t *mp;
13139 u8 stream_name_set = 0;
13140 u8 *stream_name = 0;
13142 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13144 if (unformat (input, "stream %s", &stream_name))
13145 stream_name_set = 1;
13146 else if (unformat (input, "disable"))
13152 if (stream_name_set > 0)
13154 if (vec_len (stream_name) > 255)
13156 errmsg ("stream name too long");
13161 /* Construct the API message */
13162 M (PG_ENABLE_DISABLE, mp);
13164 mp->is_enabled = enable;
13165 if (stream_name_set != 0)
13167 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
13169 vec_free (stream_name);
13177 api_pg_interface_enable_disable_coalesce (vat_main_t * vam)
13179 unformat_input_t *input = vam->input;
13180 vl_api_pg_interface_enable_disable_coalesce_t *mp;
13182 u32 sw_if_index = ~0;
13185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13187 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13189 else if (unformat (input, "sw_if_index %d", &sw_if_index))
13191 else if (unformat (input, "disable"))
13197 if (sw_if_index == ~0)
13199 errmsg ("Interface required but not specified");
13203 /* Construct the API message */
13204 M (PG_INTERFACE_ENABLE_DISABLE_COALESCE, mp);
13206 mp->coalesce_enabled = enable;
13207 mp->sw_if_index = htonl (sw_if_index);
13215 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
13217 unformat_input_t *input = vam->input;
13218 vl_api_ip_source_and_port_range_check_add_del_t *mp;
13220 u16 *low_ports = 0;
13221 u16 *high_ports = 0;
13224 vl_api_prefix_t prefix;
13231 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13233 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
13235 else if (unformat (input, "vrf %d", &vrf_id))
13237 else if (unformat (input, "del"))
13239 else if (unformat (input, "port %d", &tmp))
13241 if (tmp == 0 || tmp > 65535)
13243 errmsg ("port %d out of range", tmp);
13247 this_hi = this_low + 1;
13248 vec_add1 (low_ports, this_low);
13249 vec_add1 (high_ports, this_hi);
13251 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
13253 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
13255 errmsg ("incorrect range parameters");
13259 /* Note: in debug CLI +1 is added to high before
13260 passing to real fn that does "the work"
13261 (ip_source_and_port_range_check_add_del).
13262 This fn is a wrapper around the binary API fn a
13263 control plane will call, which expects this increment
13264 to have occurred. Hence letting the binary API control
13265 plane fn do the increment for consistency between VAT
13266 and other control planes.
13269 vec_add1 (low_ports, this_low);
13270 vec_add1 (high_ports, this_hi);
13276 if (prefix_set == 0)
13278 errmsg ("<address>/<mask> not specified");
13284 errmsg ("VRF ID required, not specified");
13291 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
13295 if (vec_len (low_ports) == 0)
13297 errmsg ("At least one port or port range required");
13301 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
13303 mp->is_add = is_add;
13305 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
13307 mp->number_of_ranges = vec_len (low_ports);
13309 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
13310 vec_free (low_ports);
13312 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
13313 vec_free (high_ports);
13315 mp->vrf_id = ntohl (vrf_id);
13323 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
13325 unformat_input_t *input = vam->input;
13326 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
13327 u32 sw_if_index = ~0;
13329 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
13330 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
13334 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13336 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13338 else if (unformat (input, "sw_if_index %d", &sw_if_index))
13340 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
13342 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
13344 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
13346 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
13348 else if (unformat (input, "del"))
13354 if (sw_if_index == ~0)
13356 errmsg ("Interface required but not specified");
13362 errmsg ("VRF ID required but not specified");
13366 if (tcp_out_vrf_id == 0
13367 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
13370 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
13374 /* Construct the API message */
13375 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
13377 mp->sw_if_index = ntohl (sw_if_index);
13378 mp->is_add = is_add;
13379 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
13380 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
13381 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
13382 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
13387 /* Wait for a reply... */
13393 api_set_punt (vat_main_t * vam)
13395 unformat_input_t *i = vam->input;
13396 vl_api_address_family_t af;
13397 vl_api_set_punt_t *mp;
13403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13405 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
13407 else if (unformat (i, "protocol %d", &protocol))
13409 else if (unformat (i, "port %d", &port))
13411 else if (unformat (i, "del"))
13415 clib_warning ("parse error '%U'", format_unformat_error, i);
13422 mp->is_add = (u8) is_add;
13423 mp->punt.type = PUNT_API_TYPE_L4;
13424 mp->punt.punt.l4.af = af;
13425 mp->punt.punt.l4.protocol = (u8) protocol;
13426 mp->punt.punt.l4.port = htons ((u16) port);
13434 api_delete_subif (vat_main_t * vam)
13436 unformat_input_t *i = vam->input;
13437 vl_api_delete_subif_t *mp;
13438 u32 sw_if_index = ~0;
13441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13443 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13445 if (unformat (i, "sw_if_index %d", &sw_if_index))
13451 if (sw_if_index == ~0)
13453 errmsg ("missing sw_if_index");
13457 /* Construct the API message */
13458 M (DELETE_SUBIF, mp);
13459 mp->sw_if_index = ntohl (sw_if_index);
13466 #define foreach_pbb_vtr_op \
13467 _("disable", L2_VTR_DISABLED) \
13468 _("pop", L2_VTR_POP_2) \
13469 _("push", L2_VTR_PUSH_2)
13472 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
13474 unformat_input_t *i = vam->input;
13475 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
13476 u32 sw_if_index = ~0, vtr_op = ~0;
13477 u16 outer_tag = ~0;
13478 u8 dmac[6], smac[6];
13479 u8 dmac_set = 0, smac_set = 0;
13485 /* Shut up coverity */
13486 clib_memset (dmac, 0, sizeof (dmac));
13487 clib_memset (smac, 0, sizeof (smac));
13489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13491 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13493 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13495 else if (unformat (i, "vtr_op %d", &vtr_op))
13497 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
13500 else if (unformat (i, "translate_pbb_stag"))
13502 if (unformat (i, "%d", &tmp))
13504 vtr_op = L2_VTR_TRANSLATE_2_1;
13510 ("translate_pbb_stag operation requires outer tag definition");
13514 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
13516 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
13518 else if (unformat (i, "sid %d", &sid))
13520 else if (unformat (i, "vlanid %d", &tmp))
13524 clib_warning ("parse error '%U'", format_unformat_error, i);
13529 if ((sw_if_index == ~0) || (vtr_op == ~0))
13531 errmsg ("missing sw_if_index or vtr operation");
13534 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
13535 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
13538 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
13542 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
13543 mp->sw_if_index = ntohl (sw_if_index);
13544 mp->vtr_op = ntohl (vtr_op);
13545 mp->outer_tag = ntohs (outer_tag);
13546 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
13547 clib_memcpy (mp->b_smac, smac, sizeof (smac));
13548 mp->b_vlanid = ntohs (vlanid);
13549 mp->i_sid = ntohl (sid);
13557 api_flow_classify_set_interface (vat_main_t * vam)
13559 unformat_input_t *i = vam->input;
13560 vl_api_flow_classify_set_interface_t *mp;
13562 int sw_if_index_set;
13563 u32 ip4_table_index = ~0;
13564 u32 ip6_table_index = ~0;
13568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13570 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13571 sw_if_index_set = 1;
13572 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13573 sw_if_index_set = 1;
13574 else if (unformat (i, "del"))
13576 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13578 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13582 clib_warning ("parse error '%U'", format_unformat_error, i);
13587 if (sw_if_index_set == 0)
13589 errmsg ("missing interface name or sw_if_index");
13593 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
13595 mp->sw_if_index = ntohl (sw_if_index);
13596 mp->ip4_table_index = ntohl (ip4_table_index);
13597 mp->ip6_table_index = ntohl (ip6_table_index);
13598 mp->is_add = is_add;
13606 api_flow_classify_dump (vat_main_t * vam)
13608 unformat_input_t *i = vam->input;
13609 vl_api_flow_classify_dump_t *mp;
13610 vl_api_control_ping_t *mp_ping;
13611 u8 type = FLOW_CLASSIFY_N_TABLES;
13614 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
13618 errmsg ("classify table type must be specified");
13622 if (!vam->json_output)
13624 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
13627 M (FLOW_CLASSIFY_DUMP, mp);
13632 /* Use a control ping for synchronization */
13633 MPING (CONTROL_PING, mp_ping);
13636 /* Wait for a reply... */
13642 api_feature_enable_disable (vat_main_t * vam)
13644 unformat_input_t *i = vam->input;
13645 vl_api_feature_enable_disable_t *mp;
13647 u8 *feature_name = 0;
13648 u32 sw_if_index = ~0;
13652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13654 if (unformat (i, "arc_name %s", &arc_name))
13656 else if (unformat (i, "feature_name %s", &feature_name))
13659 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13661 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13663 else if (unformat (i, "disable"))
13671 errmsg ("missing arc name");
13674 if (vec_len (arc_name) > 63)
13676 errmsg ("arc name too long");
13679 if (feature_name == 0)
13681 errmsg ("missing feature name");
13684 if (vec_len (feature_name) > 63)
13686 errmsg ("feature name too long");
13689 if (sw_if_index == ~0)
13691 errmsg ("missing interface name or sw_if_index");
13695 /* Construct the API message */
13696 M (FEATURE_ENABLE_DISABLE, mp);
13697 mp->sw_if_index = ntohl (sw_if_index);
13698 mp->enable = enable;
13699 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
13700 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
13701 vec_free (arc_name);
13702 vec_free (feature_name);
13710 api_feature_gso_enable_disable (vat_main_t * vam)
13712 unformat_input_t *i = vam->input;
13713 vl_api_feature_gso_enable_disable_t *mp;
13714 u32 sw_if_index = ~0;
13718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13720 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13722 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13724 else if (unformat (i, "enable"))
13726 else if (unformat (i, "disable"))
13732 if (sw_if_index == ~0)
13734 errmsg ("missing interface name or sw_if_index");
13738 /* Construct the API message */
13739 M (FEATURE_GSO_ENABLE_DISABLE, mp);
13740 mp->sw_if_index = ntohl (sw_if_index);
13741 mp->enable_disable = enable;
13749 api_sw_interface_tag_add_del (vat_main_t * vam)
13751 unformat_input_t *i = vam->input;
13752 vl_api_sw_interface_tag_add_del_t *mp;
13753 u32 sw_if_index = ~0;
13758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13760 if (unformat (i, "tag %s", &tag))
13762 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13764 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13766 else if (unformat (i, "del"))
13772 if (sw_if_index == ~0)
13774 errmsg ("missing interface name or sw_if_index");
13778 if (enable && (tag == 0))
13780 errmsg ("no tag specified");
13784 /* Construct the API message */
13785 M (SW_INTERFACE_TAG_ADD_DEL, mp);
13786 mp->sw_if_index = ntohl (sw_if_index);
13787 mp->is_add = enable;
13789 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13798 api_sw_interface_add_del_mac_address (vat_main_t * vam)
13800 unformat_input_t *i = vam->input;
13801 vl_api_mac_address_t mac = { 0 };
13802 vl_api_sw_interface_add_del_mac_address_t *mp;
13803 u32 sw_if_index = ~0;
13808 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13810 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13812 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13814 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
13816 else if (unformat (i, "del"))
13822 if (sw_if_index == ~0)
13824 errmsg ("missing interface name or sw_if_index");
13830 errmsg ("missing MAC address");
13834 /* Construct the API message */
13835 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
13836 mp->sw_if_index = ntohl (sw_if_index);
13837 mp->is_add = is_add;
13838 clib_memcpy (&mp->addr, &mac, sizeof (mac));
13845 static void vl_api_l2_xconnect_details_t_handler
13846 (vl_api_l2_xconnect_details_t * mp)
13848 vat_main_t *vam = &vat_main;
13850 print (vam->ofp, "%15d%15d",
13851 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
13854 static void vl_api_l2_xconnect_details_t_handler_json
13855 (vl_api_l2_xconnect_details_t * mp)
13857 vat_main_t *vam = &vat_main;
13858 vat_json_node_t *node = NULL;
13860 if (VAT_JSON_ARRAY != vam->json_tree.type)
13862 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13863 vat_json_init_array (&vam->json_tree);
13865 node = vat_json_array_add (&vam->json_tree);
13867 vat_json_init_object (node);
13868 vat_json_object_add_uint (node, "rx_sw_if_index",
13869 ntohl (mp->rx_sw_if_index));
13870 vat_json_object_add_uint (node, "tx_sw_if_index",
13871 ntohl (mp->tx_sw_if_index));
13875 api_l2_xconnect_dump (vat_main_t * vam)
13877 vl_api_l2_xconnect_dump_t *mp;
13878 vl_api_control_ping_t *mp_ping;
13881 if (!vam->json_output)
13883 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
13886 M (L2_XCONNECT_DUMP, mp);
13890 /* Use a control ping for synchronization */
13891 MPING (CONTROL_PING, mp_ping);
13899 api_hw_interface_set_mtu (vat_main_t * vam)
13901 unformat_input_t *i = vam->input;
13902 vl_api_hw_interface_set_mtu_t *mp;
13903 u32 sw_if_index = ~0;
13907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13909 if (unformat (i, "mtu %d", &mtu))
13911 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13913 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13919 if (sw_if_index == ~0)
13921 errmsg ("missing interface name or sw_if_index");
13927 errmsg ("no mtu specified");
13931 /* Construct the API message */
13932 M (HW_INTERFACE_SET_MTU, mp);
13933 mp->sw_if_index = ntohl (sw_if_index);
13934 mp->mtu = ntohs ((u16) mtu);
13942 api_p2p_ethernet_add (vat_main_t * vam)
13944 unformat_input_t *i = vam->input;
13945 vl_api_p2p_ethernet_add_t *mp;
13946 u32 parent_if_index = ~0;
13952 clib_memset (remote_mac, 0, sizeof (remote_mac));
13953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13955 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
13957 else if (unformat (i, "sw_if_index %d", &parent_if_index))
13961 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
13963 else if (unformat (i, "sub_id %d", &sub_id))
13967 clib_warning ("parse error '%U'", format_unformat_error, i);
13972 if (parent_if_index == ~0)
13974 errmsg ("missing interface name or sw_if_index");
13979 errmsg ("missing remote mac address");
13984 errmsg ("missing sub-interface id");
13988 M (P2P_ETHERNET_ADD, mp);
13989 mp->parent_if_index = ntohl (parent_if_index);
13990 mp->subif_id = ntohl (sub_id);
13991 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
13999 api_p2p_ethernet_del (vat_main_t * vam)
14001 unformat_input_t *i = vam->input;
14002 vl_api_p2p_ethernet_del_t *mp;
14003 u32 parent_if_index = ~0;
14008 clib_memset (remote_mac, 0, sizeof (remote_mac));
14009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
14013 else if (unformat (i, "sw_if_index %d", &parent_if_index))
14017 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
14021 clib_warning ("parse error '%U'", format_unformat_error, i);
14026 if (parent_if_index == ~0)
14028 errmsg ("missing interface name or sw_if_index");
14033 errmsg ("missing remote mac address");
14037 M (P2P_ETHERNET_DEL, mp);
14038 mp->parent_if_index = ntohl (parent_if_index);
14039 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
14047 api_tcp_configure_src_addresses (vat_main_t * vam)
14049 vl_api_tcp_configure_src_addresses_t *mp;
14050 unformat_input_t *i = vam->input;
14051 vl_api_address_t first, last;
14056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14058 if (unformat (i, "%U - %U",
14059 unformat_vl_api_address, &first,
14060 unformat_vl_api_address, &last))
14064 errmsg ("one range per message (range already set)");
14069 else if (unformat (i, "vrf %d", &vrf_id))
14075 if (range_set == 0)
14077 errmsg ("address range not set");
14081 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
14083 mp->vrf_id = ntohl (vrf_id);
14084 clib_memcpy (&mp->first_address, &first, sizeof (first));
14085 clib_memcpy (&mp->last_address, &last, sizeof (last));
14092 static void vl_api_app_namespace_add_del_reply_t_handler
14093 (vl_api_app_namespace_add_del_reply_t * mp)
14095 vat_main_t *vam = &vat_main;
14096 i32 retval = ntohl (mp->retval);
14097 if (vam->async_mode)
14099 vam->async_errors += (retval < 0);
14103 vam->retval = retval;
14105 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
14106 vam->result_ready = 1;
14110 static void vl_api_app_namespace_add_del_reply_t_handler_json
14111 (vl_api_app_namespace_add_del_reply_t * mp)
14113 vat_main_t *vam = &vat_main;
14114 vat_json_node_t node;
14116 vat_json_init_object (&node);
14117 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
14118 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
14120 vat_json_print (vam->ofp, &node);
14121 vat_json_free (&node);
14123 vam->retval = ntohl (mp->retval);
14124 vam->result_ready = 1;
14128 api_app_namespace_add_del (vat_main_t * vam)
14130 vl_api_app_namespace_add_del_t *mp;
14131 unformat_input_t *i = vam->input;
14132 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
14133 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
14137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14139 if (unformat (i, "id %_%v%_", &ns_id))
14141 else if (unformat (i, "secret %lu", &secret))
14143 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14144 sw_if_index_set = 1;
14145 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
14147 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
14152 if (!ns_id || !secret_set || !sw_if_index_set)
14154 errmsg ("namespace id, secret and sw_if_index must be set");
14157 if (vec_len (ns_id) > 64)
14159 errmsg ("namespace id too long");
14162 M (APP_NAMESPACE_ADD_DEL, mp);
14164 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
14165 mp->secret = clib_host_to_net_u64 (secret);
14166 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
14167 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
14168 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
14176 api_sock_init_shm (vat_main_t * vam)
14178 #if VPP_API_TEST_BUILTIN == 0
14179 unformat_input_t *i = vam->input;
14180 vl_api_shm_elem_config_t *config = 0;
14181 u64 size = 64 << 20;
14184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14186 if (unformat (i, "size %U", unformat_memory_size, &size))
14193 * Canned custom ring allocator config.
14194 * Should probably parse all of this
14196 vec_validate (config, 6);
14197 config[0].type = VL_API_VLIB_RING;
14198 config[0].size = 256;
14199 config[0].count = 32;
14201 config[1].type = VL_API_VLIB_RING;
14202 config[1].size = 1024;
14203 config[1].count = 16;
14205 config[2].type = VL_API_VLIB_RING;
14206 config[2].size = 4096;
14207 config[2].count = 2;
14209 config[3].type = VL_API_CLIENT_RING;
14210 config[3].size = 256;
14211 config[3].count = 32;
14213 config[4].type = VL_API_CLIENT_RING;
14214 config[4].size = 1024;
14215 config[4].count = 16;
14217 config[5].type = VL_API_CLIENT_RING;
14218 config[5].size = 4096;
14219 config[5].count = 2;
14221 config[6].type = VL_API_QUEUE;
14222 config[6].count = 128;
14223 config[6].size = sizeof (uword);
14225 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
14227 vam->client_index_invalid = 1;
14235 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
14237 vat_main_t *vam = &vat_main;
14238 fib_prefix_t lcl, rmt;
14240 ip_prefix_decode (&mp->lcl, &lcl);
14241 ip_prefix_decode (&mp->rmt, &rmt);
14243 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
14246 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
14247 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
14248 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
14249 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
14250 &rmt.fp_addr.ip4, rmt.fp_len,
14251 clib_net_to_host_u16 (mp->rmt_port),
14252 clib_net_to_host_u32 (mp->action_index), mp->tag);
14257 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
14258 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
14259 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
14260 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
14261 &rmt.fp_addr.ip6, rmt.fp_len,
14262 clib_net_to_host_u16 (mp->rmt_port),
14263 clib_net_to_host_u32 (mp->action_index), mp->tag);
14268 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
14271 vat_main_t *vam = &vat_main;
14272 vat_json_node_t *node = NULL;
14273 struct in6_addr ip6;
14274 struct in_addr ip4;
14276 fib_prefix_t lcl, rmt;
14278 ip_prefix_decode (&mp->lcl, &lcl);
14279 ip_prefix_decode (&mp->rmt, &rmt);
14281 if (VAT_JSON_ARRAY != vam->json_tree.type)
14283 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14284 vat_json_init_array (&vam->json_tree);
14286 node = vat_json_array_add (&vam->json_tree);
14287 vat_json_init_object (node);
14289 vat_json_object_add_uint (node, "appns_index",
14290 clib_net_to_host_u32 (mp->appns_index));
14291 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
14292 vat_json_object_add_uint (node, "scope", mp->scope);
14293 vat_json_object_add_uint (node, "action_index",
14294 clib_net_to_host_u32 (mp->action_index));
14295 vat_json_object_add_uint (node, "lcl_port",
14296 clib_net_to_host_u16 (mp->lcl_port));
14297 vat_json_object_add_uint (node, "rmt_port",
14298 clib_net_to_host_u16 (mp->rmt_port));
14299 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
14300 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
14301 vat_json_object_add_string_copy (node, "tag", mp->tag);
14302 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
14304 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
14305 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
14306 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
14307 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
14311 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
14312 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
14313 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
14314 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
14319 api_session_rule_add_del (vat_main_t * vam)
14321 vl_api_session_rule_add_del_t *mp;
14322 unformat_input_t *i = vam->input;
14323 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
14324 u32 appns_index = 0, scope = 0;
14325 ip4_address_t lcl_ip4, rmt_ip4;
14326 ip6_address_t lcl_ip6, rmt_ip6;
14327 u8 is_ip4 = 1, conn_set = 0;
14328 u8 is_add = 1, *tag = 0;
14330 fib_prefix_t lcl, rmt;
14332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14334 if (unformat (i, "del"))
14336 else if (unformat (i, "add"))
14338 else if (unformat (i, "proto tcp"))
14340 else if (unformat (i, "proto udp"))
14342 else if (unformat (i, "appns %d", &appns_index))
14344 else if (unformat (i, "scope %d", &scope))
14346 else if (unformat (i, "tag %_%v%_", &tag))
14350 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
14351 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
14359 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
14360 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
14366 else if (unformat (i, "action %d", &action))
14371 if (proto == ~0 || !conn_set || action == ~0)
14373 errmsg ("transport proto, connection and action must be set");
14379 errmsg ("scope should be 0-3");
14383 M (SESSION_RULE_ADD_DEL, mp);
14385 clib_memset (&lcl, 0, sizeof (lcl));
14386 clib_memset (&rmt, 0, sizeof (rmt));
14389 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
14390 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
14391 lcl.fp_len = lcl_plen;
14392 rmt.fp_len = rmt_plen;
14396 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
14397 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
14398 lcl.fp_len = lcl_plen;
14399 rmt.fp_len = rmt_plen;
14403 ip_prefix_encode (&lcl, &mp->lcl);
14404 ip_prefix_encode (&rmt, &mp->rmt);
14405 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
14406 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
14407 mp->transport_proto =
14408 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
14409 mp->action_index = clib_host_to_net_u32 (action);
14410 mp->appns_index = clib_host_to_net_u32 (appns_index);
14412 mp->is_add = is_add;
14415 clib_memcpy (mp->tag, tag, vec_len (tag));
14425 api_session_rules_dump (vat_main_t * vam)
14427 vl_api_session_rules_dump_t *mp;
14428 vl_api_control_ping_t *mp_ping;
14431 if (!vam->json_output)
14433 print (vam->ofp, "%=20s", "Session Rules");
14436 M (SESSION_RULES_DUMP, mp);
14440 /* Use a control ping for synchronization */
14441 MPING (CONTROL_PING, mp_ping);
14444 /* Wait for a reply... */
14450 api_ip_container_proxy_add_del (vat_main_t * vam)
14452 vl_api_ip_container_proxy_add_del_t *mp;
14453 unformat_input_t *i = vam->input;
14454 u32 sw_if_index = ~0;
14455 vl_api_prefix_t pfx = { };
14459 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14461 if (unformat (i, "del"))
14463 else if (unformat (i, "add"))
14465 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
14467 else if (unformat (i, "sw_if_index %u", &sw_if_index))
14472 if (sw_if_index == ~0 || pfx.len == 0)
14474 errmsg ("address and sw_if_index must be set");
14478 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
14480 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
14481 mp->is_add = is_add;
14482 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
14490 api_qos_record_enable_disable (vat_main_t * vam)
14492 unformat_input_t *i = vam->input;
14493 vl_api_qos_record_enable_disable_t *mp;
14494 u32 sw_if_index, qs = 0xff;
14495 u8 sw_if_index_set = 0;
14499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14501 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14502 sw_if_index_set = 1;
14503 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14504 sw_if_index_set = 1;
14505 else if (unformat (i, "%U", unformat_qos_source, &qs))
14507 else if (unformat (i, "disable"))
14511 clib_warning ("parse error '%U'", format_unformat_error, i);
14516 if (sw_if_index_set == 0)
14518 errmsg ("missing interface name or sw_if_index");
14523 errmsg ("input location must be specified");
14527 M (QOS_RECORD_ENABLE_DISABLE, mp);
14529 mp->record.sw_if_index = ntohl (sw_if_index);
14530 mp->record.input_source = qs;
14531 mp->enable = enable;
14540 q_or_quit (vat_main_t * vam)
14542 #if VPP_API_TEST_BUILTIN == 0
14543 longjmp (vam->jump_buf, 1);
14545 return 0; /* not so much */
14549 q (vat_main_t * vam)
14551 return q_or_quit (vam);
14555 quit (vat_main_t * vam)
14557 return q_or_quit (vam);
14561 comment (vat_main_t * vam)
14567 elog_save (vat_main_t * vam)
14569 #if VPP_API_TEST_BUILTIN == 0
14570 elog_main_t *em = &vam->elog_main;
14571 unformat_input_t *i = vam->input;
14572 char *file, *chroot_file;
14573 clib_error_t *error;
14575 if (!unformat (i, "%s", &file))
14577 errmsg ("expected file name, got `%U'", format_unformat_error, i);
14581 /* It's fairly hard to get "../oopsie" through unformat; just in case */
14582 if (strstr (file, "..") || index (file, '/'))
14584 errmsg ("illegal characters in filename '%s'", file);
14588 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
14592 errmsg ("Saving %wd of %wd events to %s",
14593 elog_n_events_in_buffer (em),
14594 elog_buffer_capacity (em), chroot_file);
14596 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
14597 vec_free (chroot_file);
14600 clib_error_report (error);
14602 errmsg ("Use the vpp event loger...");
14609 elog_setup (vat_main_t * vam)
14611 #if VPP_API_TEST_BUILTIN == 0
14612 elog_main_t *em = &vam->elog_main;
14613 unformat_input_t *i = vam->input;
14614 u32 nevents = 128 << 10;
14616 (void) unformat (i, "nevents %d", &nevents);
14618 elog_init (em, nevents);
14619 vl_api_set_elog_main (em);
14620 vl_api_set_elog_trace_api_messages (1);
14621 errmsg ("Event logger initialized with %u events", nevents);
14623 errmsg ("Use the vpp event loger...");
14629 elog_enable (vat_main_t * vam)
14631 #if VPP_API_TEST_BUILTIN == 0
14632 elog_main_t *em = &vam->elog_main;
14634 elog_enable_disable (em, 1 /* enable */ );
14635 vl_api_set_elog_trace_api_messages (1);
14636 errmsg ("Event logger enabled...");
14638 errmsg ("Use the vpp event loger...");
14644 elog_disable (vat_main_t * vam)
14646 #if VPP_API_TEST_BUILTIN == 0
14647 elog_main_t *em = &vam->elog_main;
14649 elog_enable_disable (em, 0 /* enable */ );
14650 vl_api_set_elog_trace_api_messages (1);
14651 errmsg ("Event logger disabled...");
14653 errmsg ("Use the vpp event loger...");
14659 statseg (vat_main_t * vam)
14661 ssvm_private_t *ssvmp = &vam->stat_segment;
14662 ssvm_shared_header_t *shared_header = ssvmp->sh;
14663 vlib_counter_t **counters;
14664 u64 thread0_index1_packets;
14665 u64 thread0_index1_bytes;
14666 f64 vector_rate, input_rate;
14669 uword *counter_vector_by_name;
14670 if (vam->stat_segment_lockp == 0)
14672 errmsg ("Stat segment not mapped...");
14676 /* look up "/if/rx for sw_if_index 1 as a test */
14678 clib_spinlock_lock (vam->stat_segment_lockp);
14680 counter_vector_by_name = (uword *) shared_header->opaque[1];
14682 p = hash_get_mem (counter_vector_by_name, "/if/rx");
14685 clib_spinlock_unlock (vam->stat_segment_lockp);
14686 errmsg ("/if/tx not found?");
14690 /* Fish per-thread vector of combined counters from shared memory */
14691 counters = (vlib_counter_t **) p[0];
14693 if (vec_len (counters[0]) < 2)
14695 clib_spinlock_unlock (vam->stat_segment_lockp);
14696 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
14700 /* Read thread 0 sw_if_index 1 counter */
14701 thread0_index1_packets = counters[0][1].packets;
14702 thread0_index1_bytes = counters[0][1].bytes;
14704 p = hash_get_mem (counter_vector_by_name, "vector_rate");
14707 clib_spinlock_unlock (vam->stat_segment_lockp);
14708 errmsg ("vector_rate not found?");
14712 vector_rate = *(f64 *) (p[0]);
14713 p = hash_get_mem (counter_vector_by_name, "input_rate");
14716 clib_spinlock_unlock (vam->stat_segment_lockp);
14717 errmsg ("input_rate not found?");
14720 input_rate = *(f64 *) (p[0]);
14722 clib_spinlock_unlock (vam->stat_segment_lockp);
14724 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
14725 vector_rate, input_rate);
14726 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
14727 thread0_index1_packets, thread0_index1_bytes);
14733 cmd_cmp (void *a1, void *a2)
14738 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
14742 help (vat_main_t * vam)
14747 unformat_input_t *i = vam->input;
14750 if (unformat (i, "%s", &name))
14754 vec_add1 (name, 0);
14756 hs = hash_get_mem (vam->help_by_name, name);
14758 print (vam->ofp, "usage: %s %s", name, hs[0]);
14760 print (vam->ofp, "No such msg / command '%s'", name);
14765 print (vam->ofp, "Help is available for the following:");
14768 hash_foreach_pair (p, vam->function_by_name,
14770 vec_add1 (cmds, (u8 *)(p->key));
14774 vec_sort_with_function (cmds, cmd_cmp);
14776 for (j = 0; j < vec_len (cmds); j++)
14777 print (vam->ofp, "%s", cmds[j]);
14784 set (vat_main_t * vam)
14786 u8 *name = 0, *value = 0;
14787 unformat_input_t *i = vam->input;
14789 if (unformat (i, "%s", &name))
14791 /* The input buffer is a vector, not a string. */
14792 value = vec_dup (i->buffer);
14793 vec_delete (value, i->index, 0);
14794 /* Almost certainly has a trailing newline */
14795 if (value[vec_len (value) - 1] == '\n')
14796 value[vec_len (value) - 1] = 0;
14797 /* Make sure it's a proper string, one way or the other */
14798 vec_add1 (value, 0);
14799 (void) clib_macro_set_value (&vam->macro_main,
14800 (char *) name, (char *) value);
14803 errmsg ("usage: set <name> <value>");
14811 unset (vat_main_t * vam)
14815 if (unformat (vam->input, "%s", &name))
14816 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
14817 errmsg ("unset: %s wasn't set", name);
14830 macro_sort_cmp (void *a1, void *a2)
14832 macro_sort_t *s1 = a1;
14833 macro_sort_t *s2 = a2;
14835 return strcmp ((char *) (s1->name), (char *) (s2->name));
14839 dump_macro_table (vat_main_t * vam)
14841 macro_sort_t *sort_me = 0, *sm;
14846 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
14848 vec_add2 (sort_me, sm, 1);
14849 sm->name = (u8 *)(p->key);
14850 sm->value = (u8 *) (p->value[0]);
14854 vec_sort_with_function (sort_me, macro_sort_cmp);
14856 if (vec_len (sort_me))
14857 print (vam->ofp, "%-15s%s", "Name", "Value");
14859 print (vam->ofp, "The macro table is empty...");
14861 for (i = 0; i < vec_len (sort_me); i++)
14862 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
14867 dump_node_table (vat_main_t * vam)
14870 vlib_node_t *node, *next_node;
14872 if (vec_len (vam->graph_nodes) == 0)
14874 print (vam->ofp, "Node table empty, issue get_node_graph...");
14878 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
14880 node = vam->graph_nodes[0][i];
14881 print (vam->ofp, "[%d] %s", i, node->name);
14882 for (j = 0; j < vec_len (node->next_nodes); j++)
14884 if (node->next_nodes[j] != ~0)
14886 next_node = vam->graph_nodes[0][node->next_nodes[j]];
14887 print (vam->ofp, " [%d] %s", j, next_node->name);
14895 value_sort_cmp (void *a1, void *a2)
14897 name_sort_t *n1 = a1;
14898 name_sort_t *n2 = a2;
14900 if (n1->value < n2->value)
14902 if (n1->value > n2->value)
14909 dump_msg_api_table (vat_main_t * vam)
14911 api_main_t *am = vlibapi_get_main ();
14912 name_sort_t *nses = 0, *ns;
14917 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
14919 vec_add2 (nses, ns, 1);
14920 ns->name = (u8 *)(hp->key);
14921 ns->value = (u32) hp->value[0];
14925 vec_sort_with_function (nses, value_sort_cmp);
14927 for (i = 0; i < vec_len (nses); i++)
14928 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
14934 get_msg_id (vat_main_t * vam)
14939 if (unformat (vam->input, "%s", &name_and_crc))
14941 message_index = vl_msg_api_get_msg_index (name_and_crc);
14942 if (message_index == ~0)
14944 print (vam->ofp, " '%s' not found", name_and_crc);
14947 print (vam->ofp, " '%s' has message index %d",
14948 name_and_crc, message_index);
14951 errmsg ("name_and_crc required...");
14956 search_node_table (vat_main_t * vam)
14958 unformat_input_t *line_input = vam->input;
14961 vlib_node_t *node, *next_node;
14964 if (vam->graph_node_index_by_name == 0)
14966 print (vam->ofp, "Node table empty, issue get_node_graph...");
14970 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14972 if (unformat (line_input, "%s", &node_to_find))
14974 vec_add1 (node_to_find, 0);
14975 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
14978 print (vam->ofp, "%s not found...", node_to_find);
14981 node = vam->graph_nodes[0][p[0]];
14982 print (vam->ofp, "[%d] %s", p[0], node->name);
14983 for (j = 0; j < vec_len (node->next_nodes); j++)
14985 if (node->next_nodes[j] != ~0)
14987 next_node = vam->graph_nodes[0][node->next_nodes[j]];
14988 print (vam->ofp, " [%d] %s", j, next_node->name);
14995 clib_warning ("parse error '%U'", format_unformat_error,
15001 vec_free (node_to_find);
15010 script (vat_main_t * vam)
15012 #if (VPP_API_TEST_BUILTIN==0)
15014 char *save_current_file;
15015 unformat_input_t save_input;
15016 jmp_buf save_jump_buf;
15017 u32 save_line_number;
15019 FILE *new_fp, *save_ifp;
15021 if (unformat (vam->input, "%s", &s))
15023 new_fp = fopen ((char *) s, "r");
15026 errmsg ("Couldn't open script file %s", s);
15033 errmsg ("Missing script name");
15037 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15038 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15039 save_ifp = vam->ifp;
15040 save_line_number = vam->input_line_number;
15041 save_current_file = (char *) vam->current_file;
15043 vam->input_line_number = 0;
15045 vam->current_file = s;
15048 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
15049 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15050 vam->ifp = save_ifp;
15051 vam->input_line_number = save_line_number;
15052 vam->current_file = (u8 *) save_current_file;
15057 clib_warning ("use the exec command...");
15063 echo (vat_main_t * vam)
15065 print (vam->ofp, "%v", vam->input->buffer);
15069 /* List of API message constructors, CLI names map to api_xxx */
15070 #define foreach_vpe_api_msg \
15071 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
15072 _(sw_interface_dump,"") \
15073 _(sw_interface_set_flags, \
15074 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15075 _(sw_interface_add_del_address, \
15076 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15077 _(sw_interface_set_rx_mode, \
15078 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
15079 _(sw_interface_set_rx_placement, \
15080 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
15081 _(sw_interface_rx_placement_dump, \
15082 "[<intfc> | sw_if_index <id>]") \
15083 _(sw_interface_set_table, \
15084 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15085 _(sw_interface_set_mpls_enable, \
15086 "<intfc> | sw_if_index [disable | dis]") \
15087 _(sw_interface_set_vpath, \
15088 "<intfc> | sw_if_index <id> enable | disable") \
15089 _(sw_interface_set_vxlan_bypass, \
15090 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
15091 _(sw_interface_set_l2_xconnect, \
15092 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15093 "enable | disable") \
15094 _(sw_interface_set_l2_bridge, \
15095 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
15096 "[shg <split-horizon-group>] [bvi]\n" \
15097 "enable | disable") \
15098 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
15099 _(bridge_domain_add_del, \
15100 "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") \
15101 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15103 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15104 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
15105 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
15107 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15109 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15111 "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]") \
15113 "<vpp-if-name> | sw_if_index <id>") \
15114 _(sw_interface_tap_v2_dump, "") \
15115 _(virtio_pci_create_v2, \
15116 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled [gro-coalesce] | csum-offload-enabled] [packed] [in-order]") \
15117 _(virtio_pci_delete, \
15118 "<vpp-if-name> | sw_if_index <id>") \
15119 _(sw_interface_virtio_pci_dump, "") \
15121 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
15122 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
15125 "[hw-addr <mac-addr>] {mode round-robin | active-backup | " \
15126 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
15127 "[id <if-id>] [gso]") \
15129 "<vpp-if-name> | sw_if_index <id>") \
15130 _(bond_add_member, \
15131 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
15132 _(bond_detach_member, \
15133 "sw_if_index <n>") \
15134 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
15135 _(sw_bond_interface_dump, "<intfc> | sw_if_index <nn>") \
15136 _(sw_member_interface_dump, \
15137 "<vpp-if-name> | sw_if_index <id>") \
15138 _(ip_table_add_del, \
15139 "table <n> [ipv6] [add | del]\n") \
15140 _(ip_route_add_del, \
15141 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
15142 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
15143 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
15144 "[multipath] [count <n>] [del]") \
15145 _(ip_mroute_add_del, \
15146 "<src> <grp>/<mask> [table-id <n>]\n" \
15147 "[<intfc> | sw_if_index <id>] [local] [del]") \
15148 _(mpls_table_add_del, \
15149 "table <n> [add | del]\n") \
15150 _(mpls_route_add_del, \
15151 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
15152 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
15153 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
15154 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
15155 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
15156 "[count <n>] [del]") \
15157 _(mpls_ip_bind_unbind, \
15158 "<label> <addr/len>") \
15159 _(mpls_tunnel_add_del, \
15160 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
15161 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
15162 "[l2-only] [out-label <n>]") \
15163 _(sr_mpls_policy_add, \
15164 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
15165 _(sr_mpls_policy_del, \
15167 _(bier_table_add_del, \
15168 "<label> <sub-domain> <set> <bsl> [del]") \
15169 _(bier_route_add_del, \
15170 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
15171 "[<intfc> | sw_if_index <id>]" \
15172 "[weight <n>] [del] [multipath]") \
15173 _(sw_interface_set_unnumbered, \
15174 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15175 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15176 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15177 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15178 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15179 "[outer_vlan_id_any][inner_vlan_id_any]") \
15180 _(ip_table_replace_begin, "table <n> [ipv6]") \
15181 _(ip_table_flush, "table <n> [ipv6]") \
15182 _(ip_table_replace_end, "table <n> [ipv6]") \
15183 _(set_ip_flow_hash, \
15184 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15185 _(sw_interface_ip6_enable_disable, \
15186 "<intfc> | sw_if_index <id> enable | disable") \
15187 _(l2_patch_add_del, \
15188 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15189 "enable | disable") \
15190 _(sr_localsid_add_del, \
15191 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
15192 "fib-table <num> (end.psp) sw_if_index <num>") \
15193 _(classify_add_del_table, \
15194 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15195 " [del] [del-chain] mask <mask-value>\n" \
15196 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
15197 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
15198 _(classify_add_del_session, \
15199 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15200 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15201 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
15202 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
15203 _(classify_set_interface_ip_table, \
15204 "<intfc> | sw_if_index <nn> table <nn>") \
15205 _(classify_set_interface_l2_tables, \
15206 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15207 " [other-table <nn>]") \
15208 _(get_node_index, "node <node-name") \
15209 _(add_node_next, "node <node-name> next <next-node-name>") \
15210 _(vxlan_offload_rx, \
15211 "hw { <interface name> | hw_if_index <nn>} " \
15212 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
15213 _(vxlan_add_del_tunnel, \
15214 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
15215 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
15216 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
15217 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15218 _(gre_tunnel_add_del, \
15219 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
15220 "[teb | erspan <session-id>] [del]") \
15221 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15222 _(l2_fib_clear_table, "") \
15223 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15224 _(l2_interface_vlan_tag_rewrite, \
15225 "<intfc> | sw_if_index <nn> \n" \
15226 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15227 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15228 _(create_vhost_user_if, \
15229 "socket <filename> [server] [renumber <dev_instance>] " \
15230 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
15231 "[mac <mac_address>] [packed]") \
15232 _(modify_vhost_user_if, \
15233 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15234 "[server] [renumber <dev_instance>] [gso] [packed]") \
15235 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15236 _(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
15237 _(show_version, "") \
15238 _(show_threads, "") \
15239 _(vxlan_gpe_add_del_tunnel, \
15240 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
15241 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
15242 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
15243 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
15244 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15245 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15246 _(interface_name_renumber, \
15247 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15248 _(input_acl_set_interface, \
15249 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15250 " [l2-table <nn>] [del]") \
15251 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
15252 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15253 _(ip_dump, "ipv4 | ipv6") \
15254 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15255 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15257 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15258 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15259 " integ_alg <alg> integ_key <hex>") \
15260 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
15261 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15262 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15263 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
15264 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
15265 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
15266 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
15267 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
15268 " [instance <n>]") \
15269 _(ipsec_sa_dump, "[sa_id <n>]") \
15270 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
15271 _(delete_loopback,"sw_if_index <nn>") \
15272 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15273 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
15274 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
15275 _(want_interface_events, "enable|disable") \
15276 _(get_first_msg_id, "client <name>") \
15277 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15278 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15279 "fib-id <nn> [ip4][ip6][default]") \
15280 _(get_node_graph, " ") \
15281 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15282 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
15283 _(ioam_disable, "") \
15284 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15285 _(af_packet_delete, "name <host interface name>") \
15286 _(af_packet_dump, "") \
15287 _(policer_add_del, "name <policer name> <params> [del]") \
15288 _(policer_dump, "[name <policer name>]") \
15289 _(policer_classify_set_interface, \
15290 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15291 " [l2-table <nn>] [del]") \
15292 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15293 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
15294 _(mpls_table_dump, "") \
15295 _(mpls_route_dump, "table-id <ID>") \
15296 _(classify_table_ids, "") \
15297 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15298 _(classify_table_info, "table_id <nn>") \
15299 _(classify_session_dump, "table_id <nn>") \
15300 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
15301 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
15302 "[template_interval <nn>] [udp_checksum]") \
15303 _(ipfix_exporter_dump, "") \
15304 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
15305 _(ipfix_classify_stream_dump, "") \
15306 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
15307 _(ipfix_classify_table_dump, "") \
15308 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
15309 _(sw_interface_span_dump, "[l2]") \
15310 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15311 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
15312 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15313 _(pg_enable_disable, "[stream <id>] disable") \
15314 _(pg_interface_enable_disable_coalesce, "<intf> | sw_if_index <nn> enable | disable") \
15315 _(ip_source_and_port_range_check_add_del, \
15316 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15317 _(ip_source_and_port_range_check_interface_add_del, \
15318 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15319 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15320 _(delete_subif,"<intfc> | sw_if_index <nn>") \
15321 _(l2_interface_pbb_tag_rewrite, \
15322 "<intfc> | sw_if_index <nn> \n" \
15323 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
15324 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
15325 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
15326 _(flow_classify_set_interface, \
15327 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
15328 _(flow_classify_dump, "type [ip4|ip6]") \
15329 _(ip_table_dump, "") \
15330 _(ip_route_dump, "table-id [ip4|ip6]") \
15331 _(ip_mtable_dump, "") \
15332 _(ip_mroute_dump, "table-id [ip4|ip6]") \
15333 _(feature_enable_disable, "arc_name <arc_name> " \
15334 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
15335 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
15336 "[enable | disable] ") \
15337 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
15339 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
15340 "mac <mac-address> [del]") \
15341 _(l2_xconnect_dump, "") \
15342 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
15343 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
15344 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
15345 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
15346 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
15347 _(sock_init_shm, "size <nnn>") \
15348 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
15349 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
15350 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
15351 _(session_rules_dump, "") \
15352 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
15353 _(output_acl_set_interface, \
15354 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15355 " [l2-table <nn>] [del]") \
15356 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
15358 /* List of command functions, CLI names map directly to functions */
15359 #define foreach_cli_function \
15360 _(comment, "usage: comment <ignore-rest-of-line>") \
15361 _(dump_interface_table, "usage: dump_interface_table") \
15362 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15363 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15364 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15365 _(dump_macro_table, "usage: dump_macro_table ") \
15366 _(dump_node_table, "usage: dump_node_table") \
15367 _(dump_msg_api_table, "usage: dump_msg_api_table") \
15368 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
15369 _(elog_disable, "usage: elog_disable") \
15370 _(elog_enable, "usage: elog_enable") \
15371 _(elog_save, "usage: elog_save <filename>") \
15372 _(get_msg_id, "usage: get_msg_id name_and_crc") \
15373 _(echo, "usage: echo <message>") \
15374 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15375 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
15376 _(help, "usage: help") \
15377 _(q, "usage: quit") \
15378 _(quit, "usage: quit") \
15379 _(search_node_table, "usage: search_node_table <name>...") \
15380 _(set, "usage: set <variable-name> <value>") \
15381 _(script, "usage: script <file-name>") \
15382 _(statseg, "usage: statseg") \
15383 _(unset, "usage: unset <variable-name>")
15386 static void vl_api_##n##_t_handler_uni \
15387 (vl_api_##n##_t * mp) \
15389 vat_main_t * vam = &vat_main; \
15390 if (vam->json_output) { \
15391 vl_api_##n##_t_handler_json(mp); \
15393 vl_api_##n##_t_handler(mp); \
15396 foreach_vpe_api_reply_msg;
15397 #if VPP_API_TEST_BUILTIN == 0
15398 foreach_standalone_reply_msg;
15403 vat_api_hookup (vat_main_t * vam)
15406 vl_msg_api_set_handlers(VL_API_##N, #n, \
15407 vl_api_##n##_t_handler_uni, \
15409 vl_api_##n##_t_endian, \
15410 vl_api_##n##_t_print, \
15411 sizeof(vl_api_##n##_t), 1);
15412 foreach_vpe_api_reply_msg;
15413 #if VPP_API_TEST_BUILTIN == 0
15414 foreach_standalone_reply_msg;
15418 #if (VPP_API_TEST_BUILTIN==0)
15419 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15421 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15423 vam->function_by_name = hash_create_string (0, sizeof (uword));
15425 vam->help_by_name = hash_create_string (0, sizeof (uword));
15428 /* API messages we can send */
15429 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15430 foreach_vpe_api_msg;
15434 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15435 foreach_vpe_api_msg;
15438 /* CLI functions */
15439 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15440 foreach_cli_function;
15444 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15445 foreach_cli_function;
15449 #if VPP_API_TEST_BUILTIN
15450 static clib_error_t *
15451 vat_api_hookup_shim (vlib_main_t * vm)
15453 vat_api_hookup (&vat_main);
15457 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
15461 * fd.io coding-style-patch-verification: ON
15464 * eval: (c-set-style "gnu")