2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2020 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/udp/udp_local.h>
32 #include <vpp/api/vpe_msg_enum.h>
33 #include <vnet/l2/l2_classify.h>
34 #include <vnet/l2/l2_vtr.h>
35 #include <vnet/classify/in_out_acl.h>
36 #include <vnet/classify/policer_classify.h>
37 #include <vnet/classify/flow_classify.h>
38 #include <vnet/mpls/mpls.h>
39 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ip/ip6_hop_by_hop.h>
42 #include <vnet/ip/ip_source_and_port_range_check.h>
43 #include <vnet/policer/xlate.h>
44 #include <vnet/span/span.h>
45 #include <vnet/policer/policer.h>
46 #include <vnet/policer/police.h>
47 #include <vnet/mfib/mfib_types.h>
48 #include <vnet/bonding/node.h>
49 #include <vnet/qos/qos_types.h>
50 #include <vnet/ethernet/ethernet_types_api.h>
51 #include <vnet/ip/ip_types_api.h>
52 #include "vat/json_format.h"
53 #include <vnet/ip/ip_types_api.h>
54 #include <vnet/ethernet/ethernet_types_api.h>
59 #define vl_typedefs /* define message structures */
60 #include <vpp/api/vpe_all_api_h.h>
63 /* declare message handlers for each api */
65 #define vl_endianfun /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* instantiate all the print functions we know about */
70 #if VPP_API_TEST_BUILTIN == 0
71 #define vl_print(handle, ...)
73 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
76 #include <vpp/api/vpe_all_api_h.h>
79 #define __plugin_msg_base 0
80 #include <vlibapi/vat_helper_macros.h>
82 void vl_api_set_elog_main (elog_main_t * m);
83 int vl_api_set_elog_trace_api_messages (int enable);
85 #if VPP_API_TEST_BUILTIN == 0
95 vat_socket_connect (vat_main_t * vam)
98 api_main_t *am = vlibapi_get_main ();
99 vam->socket_client_main = &socket_client_main;
100 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
102 0 /* default socket rx, tx buffer */ )))
105 /* vpp expects the client index in network order */
106 vam->my_client_index = htonl (socket_client_main.client_index);
107 am->my_client_index = vam->my_client_index;
110 #else /* vpp built-in case, we don't do sockets... */
112 vat_socket_connect (vat_main_t * vam)
118 vl_socket_client_read (int wait)
124 vl_socket_client_write ()
130 vl_socket_client_msg_alloc (int nbytes)
138 vat_time_now (vat_main_t * vam)
140 #if VPP_API_TEST_BUILTIN
141 return vlib_time_now (vam->vlib_main);
143 return clib_time_now (&vam->clib_time);
148 errmsg (char *fmt, ...)
150 vat_main_t *vam = &vat_main;
155 s = va_format (0, fmt, &va);
160 #if VPP_API_TEST_BUILTIN
161 vlib_cli_output (vam->vlib_main, (char *) s);
164 if (vam->ifp != stdin)
165 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
166 vam->input_line_number);
168 fformat (vam->ofp, "%s\n", (char *) s);
176 #if VPP_API_TEST_BUILTIN == 0
178 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
180 vat_main_t *vam = va_arg (*args, vat_main_t *);
181 u32 *result = va_arg (*args, u32 *);
185 if (!unformat (input, "%s", &if_name))
188 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
195 /* Parse an IP4 address %d.%d.%d.%d. */
197 unformat_ip4_address (unformat_input_t * input, va_list * args)
199 u8 *result = va_arg (*args, u8 *);
202 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
205 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
217 unformat_ethernet_address (unformat_input_t * input, va_list * args)
219 u8 *result = va_arg (*args, u8 *);
222 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
223 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
227 for (i = 0; i < 6; i++)
228 if (a[i] >= (1 << 8))
231 for (i = 0; i < 6; i++)
237 /* Returns ethernet type as an int in host byte order. */
239 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
242 u16 *result = va_arg (*args, u16 *);
246 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
248 if (type >= (1 << 16))
256 /* Parse an IP46 address. */
258 unformat_ip46_address (unformat_input_t * input, va_list * args)
260 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
261 ip46_type_t type = va_arg (*args, ip46_type_t);
262 if ((type != IP46_TYPE_IP6) &&
263 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
265 ip46_address_mask_ip4 (ip46);
268 else if ((type != IP46_TYPE_IP4) &&
269 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
276 /* Parse an IP6 address. */
278 unformat_ip6_address (unformat_input_t * input, va_list * args)
280 ip6_address_t *result = va_arg (*args, ip6_address_t *);
282 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
283 uword c, n_colon, double_colon_index;
285 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
286 double_colon_index = ARRAY_LEN (hex_quads);
287 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
290 if (c >= '0' && c <= '9')
292 else if (c >= 'a' && c <= 'f')
293 hex_digit = c + 10 - 'a';
294 else if (c >= 'A' && c <= 'F')
295 hex_digit = c + 10 - 'A';
296 else if (c == ':' && n_colon < 2)
300 unformat_put_input (input);
304 /* Too many hex quads. */
305 if (n_hex_quads >= ARRAY_LEN (hex_quads))
310 hex_quad = (hex_quad << 4) | hex_digit;
312 /* Hex quad must fit in 16 bits. */
313 if (n_hex_digits >= 4)
320 /* Save position of :: */
323 /* More than one :: ? */
324 if (double_colon_index < ARRAY_LEN (hex_quads))
326 double_colon_index = n_hex_quads;
329 if (n_colon > 0 && n_hex_digits > 0)
331 hex_quads[n_hex_quads++] = hex_quad;
337 if (n_hex_digits > 0)
338 hex_quads[n_hex_quads++] = hex_quad;
343 /* Expand :: to appropriate number of zero hex quads. */
344 if (double_colon_index < ARRAY_LEN (hex_quads))
346 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
348 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
349 hex_quads[n_zero + i] = hex_quads[i];
351 for (i = 0; i < n_zero; i++)
352 hex_quads[double_colon_index + i] = 0;
354 n_hex_quads = ARRAY_LEN (hex_quads);
357 /* Too few hex quads given. */
358 if (n_hex_quads < ARRAY_LEN (hex_quads))
361 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
362 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
369 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
371 u32 *r = va_arg (*args, u32 *);
374 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
375 foreach_ipsec_policy_action
383 format_ipsec_crypto_alg (u8 * s, va_list * args)
385 u32 i = va_arg (*args, u32);
390 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
391 foreach_ipsec_crypto_alg
394 return format (s, "unknown");
396 return format (s, "%s", t);
400 format_ipsec_integ_alg (u8 * s, va_list * args)
402 u32 i = va_arg (*args, u32);
407 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
408 foreach_ipsec_integ_alg
411 return format (s, "unknown");
413 return format (s, "%s", t);
416 #else /* VPP_API_TEST_BUILTIN == 1 */
418 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
420 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
421 vnet_main_t *vnm = vnet_get_main ();
422 u32 *result = va_arg (*args, u32 *);
424 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
427 #endif /* VPP_API_TEST_BUILTIN */
429 #if (VPP_API_TEST_BUILTIN==0)
431 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
432 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
433 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
434 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
437 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
439 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
440 mfib_itf_attribute_t attr;
443 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
445 if (unformat (input, mfib_itf_flag_long_names[attr]))
446 *iflags |= (1 << attr);
448 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
450 if (unformat (input, mfib_itf_flag_names[attr]))
451 *iflags |= (1 << attr);
454 return (old == *iflags ? 0 : 1);
458 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
460 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
461 mfib_entry_attribute_t attr;
464 FOR_EACH_MFIB_ATTRIBUTE (attr)
466 if (unformat (input, mfib_flag_long_names[attr]))
467 *eflags |= (1 << attr);
469 FOR_EACH_MFIB_ATTRIBUTE (attr)
471 if (unformat (input, mfib_flag_names[attr]))
472 *eflags |= (1 << attr);
475 return (old == *eflags ? 0 : 1);
479 format_ip4_address (u8 * s, va_list * args)
481 u8 *a = va_arg (*args, u8 *);
482 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
486 format_ip6_address (u8 * s, va_list * args)
488 ip6_address_t *a = va_arg (*args, ip6_address_t *);
489 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
491 i_max_n_zero = ARRAY_LEN (a->as_u16);
493 i_first_zero = i_max_n_zero;
495 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
497 u32 is_zero = a->as_u16[i] == 0;
498 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
504 if ((!is_zero && n_zeros > max_n_zeros)
505 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
507 i_max_n_zero = i_first_zero;
508 max_n_zeros = n_zeros;
509 i_first_zero = ARRAY_LEN (a->as_u16);
514 last_double_colon = 0;
515 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
517 if (i == i_max_n_zero && max_n_zeros > 1)
519 s = format (s, "::");
520 i += max_n_zeros - 1;
521 last_double_colon = 1;
525 s = format (s, "%s%x",
526 (last_double_colon || i == 0) ? "" : ":",
527 clib_net_to_host_u16 (a->as_u16[i]));
528 last_double_colon = 0;
535 /* Format an IP46 address. */
537 format_ip46_address (u8 * s, va_list * args)
539 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
540 ip46_type_t type = va_arg (*args, ip46_type_t);
546 is_ip4 = ip46_address_is_ip4 (ip46);
557 format (s, "%U", format_ip4_address, &ip46->ip4) :
558 format (s, "%U", format_ip6_address, &ip46->ip6);
562 format_ethernet_address (u8 * s, va_list * args)
564 u8 *a = va_arg (*args, u8 *);
566 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
567 a[0], a[1], a[2], a[3], a[4], a[5]);
572 increment_v4_address (vl_api_ip4_address_t * i)
574 ip4_address_t *a = (ip4_address_t *) i;
577 v = ntohl (a->as_u32) + 1;
578 a->as_u32 = ntohl (v);
582 increment_v6_address (vl_api_ip6_address_t * i)
584 ip6_address_t *a = (ip6_address_t *) i;
587 v0 = clib_net_to_host_u64 (a->as_u64[0]);
588 v1 = clib_net_to_host_u64 (a->as_u64[1]);
593 a->as_u64[0] = clib_net_to_host_u64 (v0);
594 a->as_u64[1] = clib_net_to_host_u64 (v1);
598 increment_address (vl_api_address_t * a)
600 if (a->af == ADDRESS_IP4)
601 increment_v4_address (&a->un.ip4);
602 else if (a->af == ADDRESS_IP6)
603 increment_v6_address (&a->un.ip6);
607 set_ip4_address (vl_api_address_t * a, u32 v)
609 if (a->af == ADDRESS_IP4)
611 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
617 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
620 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
622 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
623 sizeof (ip6_address_t));
627 increment_mac_address (u8 * mac)
629 u64 tmp = *((u64 *) mac);
630 tmp = clib_net_to_host_u64 (tmp);
631 tmp += 1 << 16; /* skip unused (least significant) octets */
632 tmp = clib_host_to_net_u64 (tmp);
634 clib_memcpy (mac, &tmp, 6);
638 vat_json_object_add_address (vat_json_node_t * node,
639 const char *str, const vl_api_address_t * addr)
641 if (ADDRESS_IP6 == addr->af)
645 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
646 vat_json_object_add_ip6 (node, str, ip6);
652 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
653 vat_json_object_add_ip4 (node, str, ip4);
658 vat_json_object_add_prefix (vat_json_node_t * node,
659 const vl_api_prefix_t * prefix)
661 vat_json_object_add_uint (node, "len", prefix->len);
662 vat_json_object_add_address (node, "address", &prefix->address);
665 static void vl_api_create_loopback_reply_t_handler
666 (vl_api_create_loopback_reply_t * mp)
668 vat_main_t *vam = &vat_main;
669 i32 retval = ntohl (mp->retval);
671 vam->retval = retval;
672 vam->regenerate_interface_table = 1;
673 vam->sw_if_index = ntohl (mp->sw_if_index);
674 vam->result_ready = 1;
677 static void vl_api_create_loopback_reply_t_handler_json
678 (vl_api_create_loopback_reply_t * mp)
680 vat_main_t *vam = &vat_main;
681 vat_json_node_t node;
683 vat_json_init_object (&node);
684 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
685 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
687 vat_json_print (vam->ofp, &node);
688 vat_json_free (&node);
689 vam->retval = ntohl (mp->retval);
690 vam->result_ready = 1;
693 static void vl_api_create_loopback_instance_reply_t_handler
694 (vl_api_create_loopback_instance_reply_t * mp)
696 vat_main_t *vam = &vat_main;
697 i32 retval = ntohl (mp->retval);
699 vam->retval = retval;
700 vam->regenerate_interface_table = 1;
701 vam->sw_if_index = ntohl (mp->sw_if_index);
702 vam->result_ready = 1;
705 static void vl_api_create_loopback_instance_reply_t_handler_json
706 (vl_api_create_loopback_instance_reply_t * mp)
708 vat_main_t *vam = &vat_main;
709 vat_json_node_t node;
711 vat_json_init_object (&node);
712 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
713 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
715 vat_json_print (vam->ofp, &node);
716 vat_json_free (&node);
717 vam->retval = ntohl (mp->retval);
718 vam->result_ready = 1;
721 static void vl_api_create_vlan_subif_reply_t_handler
722 (vl_api_create_vlan_subif_reply_t * mp)
724 vat_main_t *vam = &vat_main;
725 i32 retval = ntohl (mp->retval);
727 vam->retval = retval;
728 vam->regenerate_interface_table = 1;
729 vam->sw_if_index = ntohl (mp->sw_if_index);
730 vam->result_ready = 1;
733 static void vl_api_create_vlan_subif_reply_t_handler_json
734 (vl_api_create_vlan_subif_reply_t * mp)
736 vat_main_t *vam = &vat_main;
737 vat_json_node_t node;
739 vat_json_init_object (&node);
740 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
741 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
743 vat_json_print (vam->ofp, &node);
744 vat_json_free (&node);
746 vam->retval = ntohl (mp->retval);
747 vam->result_ready = 1;
750 static void vl_api_create_subif_reply_t_handler
751 (vl_api_create_subif_reply_t * mp)
753 vat_main_t *vam = &vat_main;
754 i32 retval = ntohl (mp->retval);
756 vam->retval = retval;
757 vam->regenerate_interface_table = 1;
758 vam->sw_if_index = ntohl (mp->sw_if_index);
759 vam->result_ready = 1;
762 static void vl_api_create_subif_reply_t_handler_json
763 (vl_api_create_subif_reply_t * mp)
765 vat_main_t *vam = &vat_main;
766 vat_json_node_t node;
768 vat_json_init_object (&node);
769 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
770 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
772 vat_json_print (vam->ofp, &node);
773 vat_json_free (&node);
775 vam->retval = ntohl (mp->retval);
776 vam->result_ready = 1;
779 static void vl_api_interface_name_renumber_reply_t_handler
780 (vl_api_interface_name_renumber_reply_t * mp)
782 vat_main_t *vam = &vat_main;
783 i32 retval = ntohl (mp->retval);
785 vam->retval = retval;
786 vam->regenerate_interface_table = 1;
787 vam->result_ready = 1;
790 static void vl_api_interface_name_renumber_reply_t_handler_json
791 (vl_api_interface_name_renumber_reply_t * mp)
793 vat_main_t *vam = &vat_main;
794 vat_json_node_t node;
796 vat_json_init_object (&node);
797 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
799 vat_json_print (vam->ofp, &node);
800 vat_json_free (&node);
802 vam->retval = ntohl (mp->retval);
803 vam->result_ready = 1;
807 * Special-case: build the interface table, maintain
808 * the next loopback sw_if_index vbl.
810 static void vl_api_sw_interface_details_t_handler
811 (vl_api_sw_interface_details_t * mp)
813 vat_main_t *vam = &vat_main;
814 u8 *s = format (0, "%s%c", mp->interface_name, 0);
816 hash_set_mem (vam->sw_if_index_by_interface_name, s,
817 ntohl (mp->sw_if_index));
819 /* In sub interface case, fill the sub interface table entry */
820 if (mp->sw_if_index != mp->sup_sw_if_index)
822 sw_interface_subif_t *sub = NULL;
824 vec_add2 (vam->sw_if_subif_table, sub, 1);
826 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
827 strncpy ((char *) sub->interface_name, (char *) s,
828 vec_len (sub->interface_name));
829 sub->sw_if_index = ntohl (mp->sw_if_index);
830 sub->sub_id = ntohl (mp->sub_id);
832 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
834 sub->sub_number_of_tags = mp->sub_number_of_tags;
835 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
836 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
838 /* vlan tag rewrite */
839 sub->vtr_op = ntohl (mp->vtr_op);
840 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
841 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
842 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
846 static void vl_api_sw_interface_details_t_handler_json
847 (vl_api_sw_interface_details_t * mp)
849 vat_main_t *vam = &vat_main;
850 vat_json_node_t *node = NULL;
852 if (VAT_JSON_ARRAY != vam->json_tree.type)
854 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
855 vat_json_init_array (&vam->json_tree);
857 node = vat_json_array_add (&vam->json_tree);
859 vat_json_init_object (node);
860 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
861 vat_json_object_add_uint (node, "sup_sw_if_index",
862 ntohl (mp->sup_sw_if_index));
863 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
864 sizeof (mp->l2_address));
865 vat_json_object_add_string_copy (node, "interface_name",
867 vat_json_object_add_string_copy (node, "interface_dev_type",
868 mp->interface_dev_type);
869 vat_json_object_add_uint (node, "flags", mp->flags);
870 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
871 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
872 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
873 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
874 vat_json_object_add_uint (node, "sub_number_of_tags",
875 mp->sub_number_of_tags);
876 vat_json_object_add_uint (node, "sub_outer_vlan_id",
877 ntohs (mp->sub_outer_vlan_id));
878 vat_json_object_add_uint (node, "sub_inner_vlan_id",
879 ntohs (mp->sub_inner_vlan_id));
880 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
881 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
882 vat_json_object_add_uint (node, "vtr_push_dot1q",
883 ntohl (mp->vtr_push_dot1q));
884 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
885 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
886 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
888 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
890 format_ethernet_address,
892 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
894 format_ethernet_address,
896 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
897 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
901 #if VPP_API_TEST_BUILTIN == 0
902 static void vl_api_sw_interface_event_t_handler
903 (vl_api_sw_interface_event_t * mp)
905 vat_main_t *vam = &vat_main;
906 if (vam->interface_event_display)
907 errmsg ("interface flags: sw_if_index %d %s %s",
908 ntohl (mp->sw_if_index),
909 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
910 "admin-up" : "admin-down",
911 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
912 "link-up" : "link-down");
916 __clib_unused static void
917 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
919 /* JSON output not supported */
923 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
925 vat_main_t *vam = &vat_main;
926 i32 retval = ntohl (mp->retval);
928 vam->retval = retval;
929 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
930 vam->result_ready = 1;
934 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
936 vat_main_t *vam = &vat_main;
937 vat_json_node_t node;
941 vat_json_init_object (&node);
942 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
943 vat_json_object_add_uint (&node, "reply_in_shmem",
944 ntohl (mp->reply_in_shmem));
945 /* Toss the shared-memory original... */
946 oldheap = vl_msg_push_heap ();
948 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
951 vl_msg_pop_heap (oldheap);
953 vat_json_print (vam->ofp, &node);
954 vat_json_free (&node);
956 vam->retval = ntohl (mp->retval);
957 vam->result_ready = 1;
961 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
963 vat_main_t *vam = &vat_main;
964 i32 retval = ntohl (mp->retval);
966 vec_reset_length (vam->cmd_reply);
968 vam->retval = retval;
970 vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
971 vam->result_ready = 1;
975 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
977 vat_main_t *vam = &vat_main;
978 vat_json_node_t node;
979 u8 *reply = 0; /* reply vector */
981 reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
982 vec_reset_length (vam->cmd_reply);
984 vat_json_init_object (&node);
985 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
986 vat_json_object_add_string_copy (&node, "reply", reply);
988 vat_json_print (vam->ofp, &node);
989 vat_json_free (&node);
992 vam->retval = ntohl (mp->retval);
993 vam->result_ready = 1;
996 static void vl_api_get_node_index_reply_t_handler
997 (vl_api_get_node_index_reply_t * mp)
999 vat_main_t *vam = &vat_main;
1000 i32 retval = ntohl (mp->retval);
1001 if (vam->async_mode)
1003 vam->async_errors += (retval < 0);
1007 vam->retval = retval;
1009 errmsg ("node index %d", ntohl (mp->node_index));
1010 vam->result_ready = 1;
1014 static void vl_api_get_node_index_reply_t_handler_json
1015 (vl_api_get_node_index_reply_t * mp)
1017 vat_main_t *vam = &vat_main;
1018 vat_json_node_t node;
1020 vat_json_init_object (&node);
1021 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1022 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1024 vat_json_print (vam->ofp, &node);
1025 vat_json_free (&node);
1027 vam->retval = ntohl (mp->retval);
1028 vam->result_ready = 1;
1031 static void vl_api_get_next_index_reply_t_handler
1032 (vl_api_get_next_index_reply_t * mp)
1034 vat_main_t *vam = &vat_main;
1035 i32 retval = ntohl (mp->retval);
1036 if (vam->async_mode)
1038 vam->async_errors += (retval < 0);
1042 vam->retval = retval;
1044 errmsg ("next node index %d", ntohl (mp->next_index));
1045 vam->result_ready = 1;
1049 static void vl_api_get_next_index_reply_t_handler_json
1050 (vl_api_get_next_index_reply_t * mp)
1052 vat_main_t *vam = &vat_main;
1053 vat_json_node_t node;
1055 vat_json_init_object (&node);
1056 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1057 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1059 vat_json_print (vam->ofp, &node);
1060 vat_json_free (&node);
1062 vam->retval = ntohl (mp->retval);
1063 vam->result_ready = 1;
1066 static void vl_api_add_node_next_reply_t_handler
1067 (vl_api_add_node_next_reply_t * mp)
1069 vat_main_t *vam = &vat_main;
1070 i32 retval = ntohl (mp->retval);
1071 if (vam->async_mode)
1073 vam->async_errors += (retval < 0);
1077 vam->retval = retval;
1079 errmsg ("next index %d", ntohl (mp->next_index));
1080 vam->result_ready = 1;
1084 static void vl_api_add_node_next_reply_t_handler_json
1085 (vl_api_add_node_next_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 vat_json_node_t node;
1090 vat_json_init_object (&node);
1091 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1092 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1094 vat_json_print (vam->ofp, &node);
1095 vat_json_free (&node);
1097 vam->retval = ntohl (mp->retval);
1098 vam->result_ready = 1;
1101 static void vl_api_show_version_reply_t_handler
1102 (vl_api_show_version_reply_t * mp)
1104 vat_main_t *vam = &vat_main;
1105 i32 retval = ntohl (mp->retval);
1109 errmsg (" program: %s", mp->program);
1110 errmsg (" version: %s", mp->version);
1111 errmsg (" build date: %s", mp->build_date);
1112 errmsg ("build directory: %s", mp->build_directory);
1114 vam->retval = retval;
1115 vam->result_ready = 1;
1118 static void vl_api_show_version_reply_t_handler_json
1119 (vl_api_show_version_reply_t * mp)
1121 vat_main_t *vam = &vat_main;
1122 vat_json_node_t node;
1124 vat_json_init_object (&node);
1125 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1126 vat_json_object_add_string_copy (&node, "program", mp->program);
1127 vat_json_object_add_string_copy (&node, "version", mp->version);
1128 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1129 vat_json_object_add_string_copy (&node, "build_directory",
1130 mp->build_directory);
1132 vat_json_print (vam->ofp, &node);
1133 vat_json_free (&node);
1135 vam->retval = ntohl (mp->retval);
1136 vam->result_ready = 1;
1139 static void vl_api_show_threads_reply_t_handler
1140 (vl_api_show_threads_reply_t * mp)
1142 vat_main_t *vam = &vat_main;
1143 i32 retval = ntohl (mp->retval);
1147 count = ntohl (mp->count);
1149 for (i = 0; i < count; i++)
1151 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1152 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1153 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1154 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1155 ntohl (mp->thread_data[i].cpu_socket));
1157 vam->retval = retval;
1158 vam->result_ready = 1;
1161 static void vl_api_show_threads_reply_t_handler_json
1162 (vl_api_show_threads_reply_t * mp)
1164 vat_main_t *vam = &vat_main;
1165 vat_json_node_t node;
1166 vl_api_thread_data_t *td;
1167 i32 retval = ntohl (mp->retval);
1171 count = ntohl (mp->count);
1173 vat_json_init_object (&node);
1174 vat_json_object_add_int (&node, "retval", retval);
1175 vat_json_object_add_uint (&node, "count", count);
1177 for (i = 0; i < count; i++)
1179 td = &mp->thread_data[i];
1180 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1181 vat_json_object_add_string_copy (&node, "name", td->name);
1182 vat_json_object_add_string_copy (&node, "type", td->type);
1183 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1184 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1185 vat_json_object_add_int (&node, "core", ntohl (td->id));
1186 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1189 vat_json_print (vam->ofp, &node);
1190 vat_json_free (&node);
1192 vam->retval = retval;
1193 vam->result_ready = 1;
1197 api_show_threads (vat_main_t * vam)
1199 vl_api_show_threads_t *mp;
1203 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1204 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1206 M (SHOW_THREADS, mp);
1214 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1216 u32 n_macs = ntohl (mp->n_macs);
1217 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1218 ntohl (mp->pid), mp->client_index, n_macs);
1220 for (i = 0; i < n_macs; i++)
1222 vl_api_mac_entry_t *mac = &mp->mac[i];
1223 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1224 i + 1, ntohl (mac->sw_if_index),
1225 format_ethernet_address, mac->mac_addr, mac->action);
1232 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1234 /* JSON output not supported */
1237 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1238 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1241 * Special-case: build the bridge domain table, maintain
1242 * the next bd id vbl.
1244 static void vl_api_bridge_domain_details_t_handler
1245 (vl_api_bridge_domain_details_t * mp)
1247 vat_main_t *vam = &vat_main;
1248 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1251 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1252 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1254 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1255 ntohl (mp->bd_id), mp->learn, mp->forward,
1256 mp->flood, ntohl (mp->bvi_sw_if_index),
1257 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1261 vl_api_bridge_domain_sw_if_t *sw_ifs;
1262 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1265 sw_ifs = mp->sw_if_details;
1266 for (i = 0; i < n_sw_ifs; i++)
1272 sw_if_index = ntohl (sw_ifs->sw_if_index);
1275 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1277 if ((u32) p->value[0] == sw_if_index)
1279 sw_if_name = (u8 *)(p->key);
1284 print (vam->ofp, "%7d %3d %s", sw_if_index,
1285 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1286 "sw_if_index not found!");
1293 static void vl_api_bridge_domain_details_t_handler_json
1294 (vl_api_bridge_domain_details_t * mp)
1296 vat_main_t *vam = &vat_main;
1297 vat_json_node_t *node, *array = NULL;
1298 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1300 if (VAT_JSON_ARRAY != vam->json_tree.type)
1302 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1303 vat_json_init_array (&vam->json_tree);
1305 node = vat_json_array_add (&vam->json_tree);
1307 vat_json_init_object (node);
1308 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1309 vat_json_object_add_uint (node, "flood", mp->flood);
1310 vat_json_object_add_uint (node, "forward", mp->forward);
1311 vat_json_object_add_uint (node, "learn", mp->learn);
1312 vat_json_object_add_uint (node, "bvi_sw_if_index",
1313 ntohl (mp->bvi_sw_if_index));
1314 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1315 array = vat_json_object_add (node, "sw_if");
1316 vat_json_init_array (array);
1322 vl_api_bridge_domain_sw_if_t *sw_ifs;
1325 sw_ifs = mp->sw_if_details;
1326 for (i = 0; i < n_sw_ifs; i++)
1328 node = vat_json_array_add (array);
1329 vat_json_init_object (node);
1330 vat_json_object_add_uint (node, "sw_if_index",
1331 ntohl (sw_ifs->sw_if_index));
1332 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1338 static void vl_api_control_ping_reply_t_handler
1339 (vl_api_control_ping_reply_t * mp)
1341 vat_main_t *vam = &vat_main;
1342 i32 retval = ntohl (mp->retval);
1343 if (vam->async_mode)
1345 vam->async_errors += (retval < 0);
1349 vam->retval = retval;
1350 vam->result_ready = 1;
1352 if (vam->socket_client_main)
1353 vam->socket_client_main->control_pings_outstanding--;
1356 static void vl_api_control_ping_reply_t_handler_json
1357 (vl_api_control_ping_reply_t * mp)
1359 vat_main_t *vam = &vat_main;
1360 i32 retval = ntohl (mp->retval);
1362 if (VAT_JSON_NONE != vam->json_tree.type)
1364 vat_json_print (vam->ofp, &vam->json_tree);
1365 vat_json_free (&vam->json_tree);
1366 vam->json_tree.type = VAT_JSON_NONE;
1371 vat_json_init_array (&vam->json_tree);
1372 vat_json_print (vam->ofp, &vam->json_tree);
1373 vam->json_tree.type = VAT_JSON_NONE;
1376 vam->retval = retval;
1377 vam->result_ready = 1;
1381 vl_api_bridge_domain_set_mac_age_reply_t_handler
1382 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1384 vat_main_t *vam = &vat_main;
1385 i32 retval = ntohl (mp->retval);
1386 if (vam->async_mode)
1388 vam->async_errors += (retval < 0);
1392 vam->retval = retval;
1393 vam->result_ready = 1;
1397 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1398 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1400 vat_main_t *vam = &vat_main;
1401 vat_json_node_t node;
1403 vat_json_init_object (&node);
1404 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1406 vat_json_print (vam->ofp, &node);
1407 vat_json_free (&node);
1409 vam->retval = ntohl (mp->retval);
1410 vam->result_ready = 1;
1414 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1416 vat_main_t *vam = &vat_main;
1417 i32 retval = ntohl (mp->retval);
1418 if (vam->async_mode)
1420 vam->async_errors += (retval < 0);
1424 vam->retval = retval;
1425 vam->result_ready = 1;
1429 static void vl_api_l2_flags_reply_t_handler_json
1430 (vl_api_l2_flags_reply_t * mp)
1432 vat_main_t *vam = &vat_main;
1433 vat_json_node_t node;
1435 vat_json_init_object (&node);
1436 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1437 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1438 ntohl (mp->resulting_feature_bitmap));
1440 vat_json_print (vam->ofp, &node);
1441 vat_json_free (&node);
1443 vam->retval = ntohl (mp->retval);
1444 vam->result_ready = 1;
1447 static void vl_api_bridge_flags_reply_t_handler
1448 (vl_api_bridge_flags_reply_t * mp)
1450 vat_main_t *vam = &vat_main;
1451 i32 retval = ntohl (mp->retval);
1452 if (vam->async_mode)
1454 vam->async_errors += (retval < 0);
1458 vam->retval = retval;
1459 vam->result_ready = 1;
1463 static void vl_api_bridge_flags_reply_t_handler_json
1464 (vl_api_bridge_flags_reply_t * mp)
1466 vat_main_t *vam = &vat_main;
1467 vat_json_node_t node;
1469 vat_json_init_object (&node);
1470 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1471 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1472 ntohl (mp->resulting_feature_bitmap));
1474 vat_json_print (vam->ofp, &node);
1475 vat_json_free (&node);
1477 vam->retval = ntohl (mp->retval);
1478 vam->result_ready = 1;
1482 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1485 vat_main_t *vam = &vat_main;
1486 i32 retval = ntohl (mp->retval);
1487 if (vam->async_mode)
1489 vam->async_errors += (retval < 0);
1493 vam->retval = retval;
1494 vam->sw_if_index = ntohl (mp->sw_if_index);
1495 vam->result_ready = 1;
1499 static void vl_api_virtio_pci_create_reply_t_handler_json
1500 (vl_api_virtio_pci_create_reply_t * mp)
1502 vat_main_t *vam = &vat_main;
1503 vat_json_node_t node;
1505 vat_json_init_object (&node);
1506 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1507 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1509 vat_json_print (vam->ofp, &node);
1510 vat_json_free (&node);
1512 vam->retval = ntohl (mp->retval);
1513 vam->result_ready = 1;
1518 vl_api_virtio_pci_create_v2_reply_t_handler
1519 (vl_api_virtio_pci_create_v2_reply_t * mp)
1521 vat_main_t *vam = &vat_main;
1522 i32 retval = ntohl (mp->retval);
1523 if (vam->async_mode)
1525 vam->async_errors += (retval < 0);
1529 vam->retval = retval;
1530 vam->sw_if_index = ntohl (mp->sw_if_index);
1531 vam->result_ready = 1;
1535 static void vl_api_virtio_pci_create_v2_reply_t_handler_json
1536 (vl_api_virtio_pci_create_v2_reply_t * mp)
1538 vat_main_t *vam = &vat_main;
1539 vat_json_node_t node;
1541 vat_json_init_object (&node);
1542 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1543 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1545 vat_json_print (vam->ofp, &node);
1546 vat_json_free (&node);
1548 vam->retval = ntohl (mp->retval);
1549 vam->result_ready = 1;
1553 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1556 vat_main_t *vam = &vat_main;
1557 i32 retval = ntohl (mp->retval);
1558 if (vam->async_mode)
1560 vam->async_errors += (retval < 0);
1564 vam->retval = retval;
1565 vam->result_ready = 1;
1569 static void vl_api_virtio_pci_delete_reply_t_handler_json
1570 (vl_api_virtio_pci_delete_reply_t * mp)
1572 vat_main_t *vam = &vat_main;
1573 vat_json_node_t node;
1575 vat_json_init_object (&node);
1576 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1578 vat_json_print (vam->ofp, &node);
1579 vat_json_free (&node);
1581 vam->retval = ntohl (mp->retval);
1582 vam->result_ready = 1;
1585 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1586 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1588 vat_main_t *vam = &vat_main;
1589 i32 retval = ntohl (mp->retval);
1590 if (vam->async_mode)
1592 vam->async_errors += (retval < 0);
1596 vam->retval = retval;
1597 vam->sw_if_index = ntohl (mp->sw_if_index);
1598 vam->result_ready = 1;
1600 vam->regenerate_interface_table = 1;
1603 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1604 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1606 vat_main_t *vam = &vat_main;
1607 vat_json_node_t node;
1609 vat_json_init_object (&node);
1610 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1611 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1612 ntohl (mp->sw_if_index));
1614 vat_json_print (vam->ofp, &node);
1615 vat_json_free (&node);
1617 vam->retval = ntohl (mp->retval);
1618 vam->result_ready = 1;
1621 static void vl_api_create_vhost_user_if_reply_t_handler
1622 (vl_api_create_vhost_user_if_reply_t * mp)
1624 vat_main_t *vam = &vat_main;
1625 i32 retval = ntohl (mp->retval);
1626 if (vam->async_mode)
1628 vam->async_errors += (retval < 0);
1632 vam->retval = retval;
1633 vam->sw_if_index = ntohl (mp->sw_if_index);
1634 vam->result_ready = 1;
1636 vam->regenerate_interface_table = 1;
1639 static void vl_api_create_vhost_user_if_reply_t_handler_json
1640 (vl_api_create_vhost_user_if_reply_t * mp)
1642 vat_main_t *vam = &vat_main;
1643 vat_json_node_t node;
1645 vat_json_init_object (&node);
1646 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1647 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1649 vat_json_print (vam->ofp, &node);
1650 vat_json_free (&node);
1652 vam->retval = ntohl (mp->retval);
1653 vam->result_ready = 1;
1656 static void vl_api_create_vhost_user_if_v2_reply_t_handler
1657 (vl_api_create_vhost_user_if_v2_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->sw_if_index = ntohl (mp->sw_if_index);
1669 vam->result_ready = 1;
1671 vam->regenerate_interface_table = 1;
1674 static void vl_api_create_vhost_user_if_v2_reply_t_handler_json
1675 (vl_api_create_vhost_user_if_v2_reply_t * mp)
1677 vat_main_t *vam = &vat_main;
1678 vat_json_node_t node;
1680 vat_json_init_object (&node);
1681 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1682 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1684 vat_json_print (vam->ofp, &node);
1685 vat_json_free (&node);
1687 vam->retval = ntohl (mp->retval);
1688 vam->result_ready = 1;
1691 static void vl_api_ip_address_details_t_handler
1692 (vl_api_ip_address_details_t * mp)
1694 vat_main_t *vam = &vat_main;
1695 static ip_address_details_t empty_ip_address_details = { {0} };
1696 ip_address_details_t *address = NULL;
1697 ip_details_t *current_ip_details = NULL;
1698 ip_details_t *details = NULL;
1700 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1702 if (!details || vam->current_sw_if_index >= vec_len (details)
1703 || !details[vam->current_sw_if_index].present)
1705 errmsg ("ip address details arrived but not stored");
1706 errmsg ("ip_dump should be called first");
1710 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1712 #define addresses (current_ip_details->addr)
1714 vec_validate_init_empty (addresses, vec_len (addresses),
1715 empty_ip_address_details);
1717 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1719 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
1720 address->prefix_length = mp->prefix.len;
1724 static void vl_api_ip_address_details_t_handler_json
1725 (vl_api_ip_address_details_t * mp)
1727 vat_main_t *vam = &vat_main;
1728 vat_json_node_t *node = NULL;
1730 if (VAT_JSON_ARRAY != vam->json_tree.type)
1732 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1733 vat_json_init_array (&vam->json_tree);
1735 node = vat_json_array_add (&vam->json_tree);
1737 vat_json_init_object (node);
1738 vat_json_object_add_prefix (node, &mp->prefix);
1742 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1744 vat_main_t *vam = &vat_main;
1745 static ip_details_t empty_ip_details = { 0 };
1746 ip_details_t *ip = NULL;
1747 u32 sw_if_index = ~0;
1749 sw_if_index = ntohl (mp->sw_if_index);
1751 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1752 sw_if_index, empty_ip_details);
1754 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1761 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1763 vat_main_t *vam = &vat_main;
1765 if (VAT_JSON_ARRAY != vam->json_tree.type)
1767 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1768 vat_json_init_array (&vam->json_tree);
1770 vat_json_array_add_uint (&vam->json_tree,
1771 clib_net_to_host_u32 (mp->sw_if_index));
1774 static void vl_api_get_first_msg_id_reply_t_handler
1775 (vl_api_get_first_msg_id_reply_t * mp)
1777 vat_main_t *vam = &vat_main;
1778 i32 retval = ntohl (mp->retval);
1780 if (vam->async_mode)
1782 vam->async_errors += (retval < 0);
1786 vam->retval = retval;
1787 vam->result_ready = 1;
1791 errmsg ("first message id %d", ntohs (mp->first_msg_id));
1795 static void vl_api_get_first_msg_id_reply_t_handler_json
1796 (vl_api_get_first_msg_id_reply_t * mp)
1798 vat_main_t *vam = &vat_main;
1799 vat_json_node_t node;
1801 vat_json_init_object (&node);
1802 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1803 vat_json_object_add_uint (&node, "first_msg_id",
1804 (uint) ntohs (mp->first_msg_id));
1806 vat_json_print (vam->ofp, &node);
1807 vat_json_free (&node);
1809 vam->retval = ntohl (mp->retval);
1810 vam->result_ready = 1;
1813 static void vl_api_get_node_graph_reply_t_handler
1814 (vl_api_get_node_graph_reply_t * mp)
1816 vat_main_t *vam = &vat_main;
1817 i32 retval = ntohl (mp->retval);
1818 u8 *pvt_copy, *reply;
1823 if (vam->async_mode)
1825 vam->async_errors += (retval < 0);
1829 vam->retval = retval;
1830 vam->result_ready = 1;
1833 /* "Should never happen..." */
1837 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1838 pvt_copy = vec_dup (reply);
1840 /* Toss the shared-memory original... */
1841 oldheap = vl_msg_push_heap ();
1845 vl_msg_pop_heap (oldheap);
1847 if (vam->graph_nodes)
1849 hash_free (vam->graph_node_index_by_name);
1851 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1853 node = vam->graph_nodes[0][i];
1854 vec_free (node->name);
1855 vec_free (node->next_nodes);
1858 vec_free (vam->graph_nodes[0]);
1859 vec_free (vam->graph_nodes);
1862 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
1863 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
1864 vec_free (pvt_copy);
1866 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1868 node = vam->graph_nodes[0][i];
1869 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
1873 static void vl_api_get_node_graph_reply_t_handler_json
1874 (vl_api_get_node_graph_reply_t * mp)
1876 vat_main_t *vam = &vat_main;
1878 vat_json_node_t node;
1881 /* $$$$ make this real? */
1882 vat_json_init_object (&node);
1883 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1884 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
1886 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1888 /* Toss the shared-memory original... */
1889 oldheap = vl_msg_push_heap ();
1893 vl_msg_pop_heap (oldheap);
1895 vat_json_print (vam->ofp, &node);
1896 vat_json_free (&node);
1898 vam->retval = ntohl (mp->retval);
1899 vam->result_ready = 1;
1902 /* Format hex dump. */
1904 format_hex_bytes (u8 * s, va_list * va)
1906 u8 *bytes = va_arg (*va, u8 *);
1907 int n_bytes = va_arg (*va, int);
1910 /* Print short or long form depending on byte count. */
1911 uword short_form = n_bytes <= 32;
1912 u32 indent = format_get_indent (s);
1917 for (i = 0; i < n_bytes; i++)
1919 if (!short_form && (i % 32) == 0)
1920 s = format (s, "%08x: ", i);
1921 s = format (s, "%02x", bytes[i]);
1922 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
1923 s = format (s, "\n%U", format_white_space, indent);
1930 * Generate boilerplate reply handlers, which
1931 * dig the return value out of the xxx_reply_t API message,
1932 * stick it into vam->retval, and set vam->result_ready
1934 * Could also do this by pointing N message decode slots at
1935 * a single function, but that could break in subtle ways.
1938 #define foreach_standard_reply_retval_handler \
1939 _(sw_interface_set_flags_reply) \
1940 _(sw_interface_add_del_address_reply) \
1941 _(sw_interface_set_rx_mode_reply) \
1942 _(sw_interface_set_rx_placement_reply) \
1943 _(sw_interface_set_table_reply) \
1944 _(sw_interface_set_mpls_enable_reply) \
1945 _(sw_interface_set_vpath_reply) \
1946 _(sw_interface_set_l2_bridge_reply) \
1947 _(bridge_domain_add_del_reply) \
1948 _(sw_interface_set_l2_xconnect_reply) \
1949 _(l2fib_add_del_reply) \
1950 _(l2fib_flush_int_reply) \
1951 _(l2fib_flush_bd_reply) \
1952 _(ip_route_add_del_reply) \
1953 _(ip_table_add_del_reply) \
1954 _(ip_table_replace_begin_reply) \
1955 _(ip_table_flush_reply) \
1956 _(ip_table_replace_end_reply) \
1957 _(ip_mroute_add_del_reply) \
1958 _(mpls_route_add_del_reply) \
1959 _(mpls_table_add_del_reply) \
1960 _(mpls_ip_bind_unbind_reply) \
1961 _(sw_interface_set_unnumbered_reply) \
1962 _(set_ip_flow_hash_reply) \
1963 _(sw_interface_ip6_enable_disable_reply) \
1964 _(l2_patch_add_del_reply) \
1965 _(l2_fib_clear_table_reply) \
1966 _(l2_interface_efp_filter_reply) \
1967 _(l2_interface_vlan_tag_rewrite_reply) \
1968 _(modify_vhost_user_if_reply) \
1969 _(modify_vhost_user_if_v2_reply) \
1970 _(delete_vhost_user_if_reply) \
1971 _(want_l2_macs_events_reply) \
1972 _(delete_loopback_reply) \
1973 _(bd_ip_mac_add_del_reply) \
1974 _(bd_ip_mac_flush_reply) \
1975 _(want_interface_events_reply) \
1976 _(sw_interface_clear_stats_reply) \
1977 _(ioam_enable_reply) \
1978 _(ioam_disable_reply) \
1979 _(sw_interface_span_enable_disable_reply) \
1980 _(ip_source_and_port_range_check_add_del_reply) \
1981 _(ip_source_and_port_range_check_interface_add_del_reply)\
1982 _(delete_subif_reply) \
1983 _(l2_interface_pbb_tag_rewrite_reply) \
1985 _(sw_interface_tag_add_del_reply) \
1986 _(sw_interface_add_del_mac_address_reply) \
1987 _(hw_interface_set_mtu_reply) \
1988 _(tcp_configure_src_addresses_reply) \
1989 _(session_rule_add_del_reply) \
1990 _(ip_container_proxy_add_del_reply) \
1993 static void vl_api_##n##_t_handler \
1994 (vl_api_##n##_t * mp) \
1996 vat_main_t * vam = &vat_main; \
1997 i32 retval = ntohl(mp->retval); \
1998 if (vam->async_mode) { \
1999 vam->async_errors += (retval < 0); \
2001 vam->retval = retval; \
2002 vam->result_ready = 1; \
2005 foreach_standard_reply_retval_handler;
2009 static void vl_api_##n##_t_handler_json \
2010 (vl_api_##n##_t * mp) \
2012 vat_main_t * vam = &vat_main; \
2013 vat_json_node_t node; \
2014 vat_json_init_object(&node); \
2015 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
2016 vat_json_print(vam->ofp, &node); \
2017 vam->retval = ntohl(mp->retval); \
2018 vam->result_ready = 1; \
2020 foreach_standard_reply_retval_handler;
2024 * Table of message reply handlers, must include boilerplate handlers
2028 #define foreach_vpe_api_reply_msg \
2029 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
2030 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
2031 _(SW_INTERFACE_DETAILS, sw_interface_details) \
2032 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
2033 _(CONTROL_PING_REPLY, control_ping_reply) \
2034 _(CLI_REPLY, cli_reply) \
2035 _(CLI_INBAND_REPLY, cli_inband_reply) \
2036 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
2037 sw_interface_add_del_address_reply) \
2038 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
2039 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
2040 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
2041 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
2042 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
2043 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
2044 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
2045 sw_interface_set_l2_xconnect_reply) \
2046 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
2047 sw_interface_set_l2_bridge_reply) \
2048 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
2049 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
2050 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
2051 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
2052 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
2053 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
2054 _(L2_FLAGS_REPLY, l2_flags_reply) \
2055 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
2056 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
2057 _(VIRTIO_PCI_CREATE_V2_REPLY, virtio_pci_create_v2_reply) \
2058 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
2059 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
2060 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
2061 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
2062 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
2063 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
2064 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
2065 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
2066 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
2067 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
2068 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
2069 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
2070 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
2071 sw_interface_set_unnumbered_reply) \
2072 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
2073 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2074 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2075 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2076 sw_interface_ip6_enable_disable_reply) \
2077 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2078 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2079 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2080 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2081 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2082 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2083 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
2084 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
2085 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
2086 _(CREATE_VHOST_USER_IF_V2_REPLY, create_vhost_user_if_v2_reply) \
2087 _(MODIFY_VHOST_USER_IF_V2_REPLY, modify_vhost_user_if_v2_reply) \
2088 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
2089 _(SHOW_VERSION_REPLY, show_version_reply) \
2090 _(SHOW_THREADS_REPLY, show_threads_reply) \
2091 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
2092 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2093 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
2094 _(L2_MACS_EVENT, l2_macs_event) \
2095 _(IP_ADDRESS_DETAILS, ip_address_details) \
2096 _(IP_DETAILS, ip_details) \
2097 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
2098 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
2099 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
2100 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
2101 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
2102 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
2103 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
2104 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
2105 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
2106 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
2107 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
2108 _(MPLS_TABLE_DETAILS, mpls_table_details) \
2109 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
2110 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
2111 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
2112 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
2113 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
2114 ip_source_and_port_range_check_add_del_reply) \
2115 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
2116 ip_source_and_port_range_check_interface_add_del_reply) \
2117 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
2118 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
2119 _(SET_PUNT_REPLY, set_punt_reply) \
2120 _(IP_TABLE_DETAILS, ip_table_details) \
2121 _(IP_ROUTE_DETAILS, ip_route_details) \
2122 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
2123 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
2124 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
2125 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
2126 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
2127 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
2128 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
2129 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
2130 _(SESSION_RULES_DETAILS, session_rules_details) \
2131 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
2133 #define foreach_standalone_reply_msg \
2134 _(SW_INTERFACE_EVENT, sw_interface_event)
2142 #define STR_VTR_OP_CASE(op) \
2143 case L2_VTR_ ## op: \
2147 str_vtr_op (u32 vtr_op)
2151 STR_VTR_OP_CASE (DISABLED);
2152 STR_VTR_OP_CASE (PUSH_1);
2153 STR_VTR_OP_CASE (PUSH_2);
2154 STR_VTR_OP_CASE (POP_1);
2155 STR_VTR_OP_CASE (POP_2);
2156 STR_VTR_OP_CASE (TRANSLATE_1_1);
2157 STR_VTR_OP_CASE (TRANSLATE_1_2);
2158 STR_VTR_OP_CASE (TRANSLATE_2_1);
2159 STR_VTR_OP_CASE (TRANSLATE_2_2);
2166 dump_sub_interface_table (vat_main_t * vam)
2168 const sw_interface_subif_t *sub = NULL;
2170 if (vam->json_output)
2173 ("JSON output supported only for VPE API calls and dump_stats_table");
2178 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
2179 "Interface", "sw_if_index",
2180 "sub id", "dot1ad", "tags", "outer id",
2181 "inner id", "exact", "default", "outer any", "inner any");
2183 vec_foreach (sub, vam->sw_if_subif_table)
2186 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
2187 sub->interface_name,
2189 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
2190 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
2191 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
2192 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
2193 if (sub->vtr_op != L2_VTR_DISABLED)
2196 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
2197 "tag1: %d tag2: %d ]",
2198 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
2199 sub->vtr_tag1, sub->vtr_tag2);
2207 name_sort_cmp (void *a1, void *a2)
2209 name_sort_t *n1 = a1;
2210 name_sort_t *n2 = a2;
2212 return strcmp ((char *) n1->name, (char *) n2->name);
2216 dump_interface_table (vat_main_t * vam)
2219 name_sort_t *nses = 0, *ns;
2221 if (vam->json_output)
2224 ("JSON output supported only for VPE API calls and dump_stats_table");
2229 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2231 vec_add2 (nses, ns, 1);
2232 ns->name = (u8 *)(p->key);
2233 ns->value = (u32) p->value[0];
2237 vec_sort_with_function (nses, name_sort_cmp);
2239 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
2240 vec_foreach (ns, nses)
2242 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
2249 dump_ip_table (vat_main_t * vam, int is_ipv6)
2251 const ip_details_t *det = NULL;
2252 const ip_address_details_t *address = NULL;
2255 print (vam->ofp, "%-12s", "sw_if_index");
2257 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
2264 print (vam->ofp, "%-12d", i);
2265 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
2270 vec_foreach (address, det->addr)
2274 is_ipv6 ? format_ip6_address : format_ip4_address,
2275 address->ip, address->prefix_length);
2283 dump_ipv4_table (vat_main_t * vam)
2285 if (vam->json_output)
2288 ("JSON output supported only for VPE API calls and dump_stats_table");
2292 return dump_ip_table (vam, 0);
2296 dump_ipv6_table (vat_main_t * vam)
2298 if (vam->json_output)
2301 ("JSON output supported only for VPE API calls and dump_stats_table");
2305 return dump_ip_table (vam, 1);
2309 * Pass CLI buffers directly in the CLI_INBAND API message,
2310 * instead of an additional shared memory area.
2313 exec_inband (vat_main_t * vam)
2315 vl_api_cli_inband_t *mp;
2316 unformat_input_t *i = vam->input;
2319 if (vec_len (i->buffer) == 0)
2322 if (vam->exec_mode == 0 && unformat (i, "mode"))
2327 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
2334 * In order for the CLI command to work, it
2335 * must be a vector ending in \n, not a C-string ending
2338 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
2339 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
2343 /* json responses may or may not include a useful reply... */
2344 if (vec_len (vam->cmd_reply))
2345 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
2350 exec (vat_main_t * vam)
2352 return exec_inband (vam);
2356 api_create_loopback (vat_main_t * vam)
2358 unformat_input_t *i = vam->input;
2359 vl_api_create_loopback_t *mp;
2360 vl_api_create_loopback_instance_t *mp_lbi;
2363 u8 is_specified = 0;
2364 u32 user_instance = 0;
2367 clib_memset (mac_address, 0, sizeof (mac_address));
2369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2371 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
2373 if (unformat (i, "instance %d", &user_instance))
2381 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
2382 mp_lbi->is_specified = is_specified;
2384 mp_lbi->user_instance = htonl (user_instance);
2386 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
2391 /* Construct the API message */
2392 M (CREATE_LOOPBACK, mp);
2394 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
2403 api_delete_loopback (vat_main_t * vam)
2405 unformat_input_t *i = vam->input;
2406 vl_api_delete_loopback_t *mp;
2407 u32 sw_if_index = ~0;
2410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2412 if (unformat (i, "sw_if_index %d", &sw_if_index))
2418 if (sw_if_index == ~0)
2420 errmsg ("missing sw_if_index");
2424 /* Construct the API message */
2425 M (DELETE_LOOPBACK, mp);
2426 mp->sw_if_index = ntohl (sw_if_index);
2434 api_want_interface_events (vat_main_t * vam)
2436 unformat_input_t *i = vam->input;
2437 vl_api_want_interface_events_t *mp;
2441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2443 if (unformat (i, "enable"))
2445 else if (unformat (i, "disable"))
2453 errmsg ("missing enable|disable");
2457 M (WANT_INTERFACE_EVENTS, mp);
2458 mp->enable_disable = enable;
2460 vam->interface_event_display = enable;
2468 /* Note: non-static, called once to set up the initial intfc table */
2470 api_sw_interface_dump (vat_main_t * vam)
2472 vl_api_sw_interface_dump_t *mp;
2473 vl_api_control_ping_t *mp_ping;
2475 name_sort_t *nses = 0, *ns;
2476 sw_interface_subif_t *sub = NULL;
2479 /* Toss the old name table */
2481 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2483 vec_add2 (nses, ns, 1);
2484 ns->name = (u8 *)(p->key);
2485 ns->value = (u32) p->value[0];
2489 hash_free (vam->sw_if_index_by_interface_name);
2491 vec_foreach (ns, nses) vec_free (ns->name);
2495 vec_foreach (sub, vam->sw_if_subif_table)
2497 vec_free (sub->interface_name);
2499 vec_free (vam->sw_if_subif_table);
2501 /* recreate the interface name hash table */
2502 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
2505 * Ask for all interface names. Otherwise, the epic catalog of
2506 * name filters becomes ridiculously long, and vat ends up needing
2507 * to be taught about new interface types.
2509 M (SW_INTERFACE_DUMP, mp);
2512 /* Use a control ping for synchronization */
2513 MPING (CONTROL_PING, mp_ping);
2521 api_sw_interface_set_flags (vat_main_t * vam)
2523 unformat_input_t *i = vam->input;
2524 vl_api_sw_interface_set_flags_t *mp;
2526 u8 sw_if_index_set = 0;
2530 /* Parse args required to build the message */
2531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2533 if (unformat (i, "admin-up"))
2535 else if (unformat (i, "admin-down"))
2538 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2539 sw_if_index_set = 1;
2540 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2541 sw_if_index_set = 1;
2546 if (sw_if_index_set == 0)
2548 errmsg ("missing interface name or sw_if_index");
2552 /* Construct the API message */
2553 M (SW_INTERFACE_SET_FLAGS, mp);
2554 mp->sw_if_index = ntohl (sw_if_index);
2555 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
2560 /* Wait for a reply, return the good/bad news... */
2566 api_sw_interface_set_rx_mode (vat_main_t * vam)
2568 unformat_input_t *i = vam->input;
2569 vl_api_sw_interface_set_rx_mode_t *mp;
2571 u8 sw_if_index_set = 0;
2573 u8 queue_id_valid = 0;
2575 vnet_hw_if_rx_mode mode = VNET_HW_IF_RX_MODE_UNKNOWN;
2577 /* Parse args required to build the message */
2578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2580 if (unformat (i, "queue %d", &queue_id))
2582 else if (unformat (i, "polling"))
2583 mode = VNET_HW_IF_RX_MODE_POLLING;
2584 else if (unformat (i, "interrupt"))
2585 mode = VNET_HW_IF_RX_MODE_INTERRUPT;
2586 else if (unformat (i, "adaptive"))
2587 mode = VNET_HW_IF_RX_MODE_ADAPTIVE;
2589 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2590 sw_if_index_set = 1;
2591 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2592 sw_if_index_set = 1;
2597 if (sw_if_index_set == 0)
2599 errmsg ("missing interface name or sw_if_index");
2602 if (mode == VNET_HW_IF_RX_MODE_UNKNOWN)
2604 errmsg ("missing rx-mode");
2608 /* Construct the API message */
2609 M (SW_INTERFACE_SET_RX_MODE, mp);
2610 mp->sw_if_index = ntohl (sw_if_index);
2611 mp->mode = (vl_api_rx_mode_t) mode;
2612 mp->queue_id_valid = queue_id_valid;
2613 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
2618 /* Wait for a reply, return the good/bad news... */
2624 api_sw_interface_set_rx_placement (vat_main_t * vam)
2626 unformat_input_t *i = vam->input;
2627 vl_api_sw_interface_set_rx_placement_t *mp;
2629 u8 sw_if_index_set = 0;
2632 u32 queue_id, thread_index;
2634 /* Parse args required to build the message */
2635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2637 if (unformat (i, "queue %d", &queue_id))
2639 else if (unformat (i, "main"))
2641 else if (unformat (i, "worker %d", &thread_index))
2644 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2645 sw_if_index_set = 1;
2646 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2647 sw_if_index_set = 1;
2652 if (sw_if_index_set == 0)
2654 errmsg ("missing interface name or sw_if_index");
2660 /* Construct the API message */
2661 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
2662 mp->sw_if_index = ntohl (sw_if_index);
2663 mp->worker_id = ntohl (thread_index);
2664 mp->queue_id = ntohl (queue_id);
2665 mp->is_main = is_main;
2669 /* Wait for a reply, return the good/bad news... */
2674 static void vl_api_sw_interface_rx_placement_details_t_handler
2675 (vl_api_sw_interface_rx_placement_details_t * mp)
2677 vat_main_t *vam = &vat_main;
2678 u32 worker_id = ntohl (mp->worker_id);
2681 "\n%-11d %-11s %-6d %-5d %-9s",
2682 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
2683 worker_id, ntohl (mp->queue_id),
2685 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
2688 static void vl_api_sw_interface_rx_placement_details_t_handler_json
2689 (vl_api_sw_interface_rx_placement_details_t * mp)
2691 vat_main_t *vam = &vat_main;
2692 vat_json_node_t *node = NULL;
2694 if (VAT_JSON_ARRAY != vam->json_tree.type)
2696 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2697 vat_json_init_array (&vam->json_tree);
2699 node = vat_json_array_add (&vam->json_tree);
2701 vat_json_init_object (node);
2702 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2703 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
2704 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
2705 vat_json_object_add_uint (node, "mode", mp->mode);
2709 api_sw_interface_rx_placement_dump (vat_main_t * vam)
2711 unformat_input_t *i = vam->input;
2712 vl_api_sw_interface_rx_placement_dump_t *mp;
2713 vl_api_control_ping_t *mp_ping;
2716 u8 sw_if_index_set = 0;
2718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2720 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2722 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2729 "\n%-11s %-11s %-6s %-5s %-4s",
2730 "sw_if_index", "main/worker", "thread", "queue", "mode");
2732 /* Dump Interface rx placement */
2733 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
2735 if (sw_if_index_set)
2736 mp->sw_if_index = htonl (sw_if_index);
2738 mp->sw_if_index = ~0;
2742 /* Use a control ping for synchronization */
2743 MPING (CONTROL_PING, mp_ping);
2751 api_sw_interface_clear_stats (vat_main_t * vam)
2753 unformat_input_t *i = vam->input;
2754 vl_api_sw_interface_clear_stats_t *mp;
2756 u8 sw_if_index_set = 0;
2759 /* Parse args required to build the message */
2760 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2762 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2763 sw_if_index_set = 1;
2764 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2765 sw_if_index_set = 1;
2770 /* Construct the API message */
2771 M (SW_INTERFACE_CLEAR_STATS, mp);
2773 if (sw_if_index_set == 1)
2774 mp->sw_if_index = ntohl (sw_if_index);
2776 mp->sw_if_index = ~0;
2781 /* Wait for a reply, return the good/bad news... */
2787 api_sw_interface_add_del_address (vat_main_t * vam)
2789 unformat_input_t *i = vam->input;
2790 vl_api_sw_interface_add_del_address_t *mp;
2792 u8 sw_if_index_set = 0;
2793 u8 is_add = 1, del_all = 0;
2794 u32 address_length = 0;
2795 u8 v4_address_set = 0;
2796 u8 v6_address_set = 0;
2797 ip4_address_t v4address;
2798 ip6_address_t v6address;
2801 /* Parse args required to build the message */
2802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2804 if (unformat (i, "del-all"))
2806 else if (unformat (i, "del"))
2809 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2810 sw_if_index_set = 1;
2811 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2812 sw_if_index_set = 1;
2813 else if (unformat (i, "%U/%d",
2814 unformat_ip4_address, &v4address, &address_length))
2816 else if (unformat (i, "%U/%d",
2817 unformat_ip6_address, &v6address, &address_length))
2823 if (sw_if_index_set == 0)
2825 errmsg ("missing interface name or sw_if_index");
2828 if (v4_address_set && v6_address_set)
2830 errmsg ("both v4 and v6 addresses set");
2833 if (!v4_address_set && !v6_address_set && !del_all)
2835 errmsg ("no addresses set");
2839 /* Construct the API message */
2840 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
2842 mp->sw_if_index = ntohl (sw_if_index);
2843 mp->is_add = is_add;
2844 mp->del_all = del_all;
2847 mp->prefix.address.af = ADDRESS_IP6;
2848 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
2852 mp->prefix.address.af = ADDRESS_IP4;
2853 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
2855 mp->prefix.len = address_length;
2860 /* Wait for a reply, return good/bad news */
2866 api_sw_interface_set_mpls_enable (vat_main_t * vam)
2868 unformat_input_t *i = vam->input;
2869 vl_api_sw_interface_set_mpls_enable_t *mp;
2871 u8 sw_if_index_set = 0;
2875 /* Parse args required to build the message */
2876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2879 sw_if_index_set = 1;
2880 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2881 sw_if_index_set = 1;
2882 else if (unformat (i, "disable"))
2884 else if (unformat (i, "dis"))
2890 if (sw_if_index_set == 0)
2892 errmsg ("missing interface name or sw_if_index");
2896 /* Construct the API message */
2897 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
2899 mp->sw_if_index = ntohl (sw_if_index);
2900 mp->enable = enable;
2905 /* Wait for a reply... */
2911 api_sw_interface_set_table (vat_main_t * vam)
2913 unformat_input_t *i = vam->input;
2914 vl_api_sw_interface_set_table_t *mp;
2915 u32 sw_if_index, vrf_id = 0;
2916 u8 sw_if_index_set = 0;
2920 /* Parse args required to build the message */
2921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2923 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2924 sw_if_index_set = 1;
2925 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2926 sw_if_index_set = 1;
2927 else if (unformat (i, "vrf %d", &vrf_id))
2929 else if (unformat (i, "ipv6"))
2935 if (sw_if_index_set == 0)
2937 errmsg ("missing interface name or sw_if_index");
2941 /* Construct the API message */
2942 M (SW_INTERFACE_SET_TABLE, mp);
2944 mp->sw_if_index = ntohl (sw_if_index);
2945 mp->is_ipv6 = is_ipv6;
2946 mp->vrf_id = ntohl (vrf_id);
2951 /* Wait for a reply... */
2956 static void vl_api_sw_interface_get_table_reply_t_handler
2957 (vl_api_sw_interface_get_table_reply_t * mp)
2959 vat_main_t *vam = &vat_main;
2961 print (vam->ofp, "%d", ntohl (mp->vrf_id));
2963 vam->retval = ntohl (mp->retval);
2964 vam->result_ready = 1;
2968 static void vl_api_sw_interface_get_table_reply_t_handler_json
2969 (vl_api_sw_interface_get_table_reply_t * mp)
2971 vat_main_t *vam = &vat_main;
2972 vat_json_node_t node;
2974 vat_json_init_object (&node);
2975 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2976 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
2978 vat_json_print (vam->ofp, &node);
2979 vat_json_free (&node);
2981 vam->retval = ntohl (mp->retval);
2982 vam->result_ready = 1;
2986 api_sw_interface_get_table (vat_main_t * vam)
2988 unformat_input_t *i = vam->input;
2989 vl_api_sw_interface_get_table_t *mp;
2991 u8 sw_if_index_set = 0;
2995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2997 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2998 sw_if_index_set = 1;
2999 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3000 sw_if_index_set = 1;
3001 else if (unformat (i, "ipv6"))
3007 if (sw_if_index_set == 0)
3009 errmsg ("missing interface name or sw_if_index");
3013 M (SW_INTERFACE_GET_TABLE, mp);
3014 mp->sw_if_index = htonl (sw_if_index);
3015 mp->is_ipv6 = is_ipv6;
3023 api_sw_interface_set_vpath (vat_main_t * vam)
3025 unformat_input_t *i = vam->input;
3026 vl_api_sw_interface_set_vpath_t *mp;
3027 u32 sw_if_index = 0;
3028 u8 sw_if_index_set = 0;
3032 /* Parse args required to build the message */
3033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3035 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3036 sw_if_index_set = 1;
3037 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3038 sw_if_index_set = 1;
3039 else if (unformat (i, "enable"))
3041 else if (unformat (i, "disable"))
3047 if (sw_if_index_set == 0)
3049 errmsg ("missing interface name or sw_if_index");
3053 /* Construct the API message */
3054 M (SW_INTERFACE_SET_VPATH, mp);
3056 mp->sw_if_index = ntohl (sw_if_index);
3057 mp->enable = is_enable;
3062 /* Wait for a reply... */
3068 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
3070 unformat_input_t *i = vam->input;
3071 vl_api_sw_interface_set_l2_xconnect_t *mp;
3073 u8 rx_sw_if_index_set = 0;
3075 u8 tx_sw_if_index_set = 0;
3079 /* Parse args required to build the message */
3080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3082 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
3083 rx_sw_if_index_set = 1;
3084 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
3085 tx_sw_if_index_set = 1;
3086 else if (unformat (i, "rx"))
3088 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3090 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
3092 rx_sw_if_index_set = 1;
3097 else if (unformat (i, "tx"))
3099 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3101 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
3103 tx_sw_if_index_set = 1;
3108 else if (unformat (i, "enable"))
3110 else if (unformat (i, "disable"))
3116 if (rx_sw_if_index_set == 0)
3118 errmsg ("missing rx interface name or rx_sw_if_index");
3122 if (enable && (tx_sw_if_index_set == 0))
3124 errmsg ("missing tx interface name or tx_sw_if_index");
3128 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
3130 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
3131 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
3132 mp->enable = enable;
3140 api_sw_interface_set_l2_bridge (vat_main_t * vam)
3142 unformat_input_t *i = vam->input;
3143 vl_api_sw_interface_set_l2_bridge_t *mp;
3144 vl_api_l2_port_type_t port_type;
3146 u8 rx_sw_if_index_set = 0;
3153 port_type = L2_API_PORT_TYPE_NORMAL;
3155 /* Parse args required to build the message */
3156 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3158 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
3159 rx_sw_if_index_set = 1;
3160 else if (unformat (i, "bd_id %d", &bd_id))
3164 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
3165 rx_sw_if_index_set = 1;
3166 else if (unformat (i, "shg %d", &shg))
3168 else if (unformat (i, "bvi"))
3169 port_type = L2_API_PORT_TYPE_BVI;
3170 else if (unformat (i, "uu-fwd"))
3171 port_type = L2_API_PORT_TYPE_UU_FWD;
3172 else if (unformat (i, "enable"))
3174 else if (unformat (i, "disable"))
3180 if (rx_sw_if_index_set == 0)
3182 errmsg ("missing rx interface name or sw_if_index");
3186 if (enable && (bd_id_set == 0))
3188 errmsg ("missing bridge domain");
3192 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
3194 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
3195 mp->bd_id = ntohl (bd_id);
3197 mp->port_type = ntohl (port_type);
3198 mp->enable = enable;
3206 api_bridge_domain_dump (vat_main_t * vam)
3208 unformat_input_t *i = vam->input;
3209 vl_api_bridge_domain_dump_t *mp;
3210 vl_api_control_ping_t *mp_ping;
3214 /* Parse args required to build the message */
3215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3217 if (unformat (i, "bd_id %d", &bd_id))
3223 M (BRIDGE_DOMAIN_DUMP, mp);
3224 mp->bd_id = ntohl (bd_id);
3227 /* Use a control ping for synchronization */
3228 MPING (CONTROL_PING, mp_ping);
3236 api_bridge_domain_add_del (vat_main_t * vam)
3238 unformat_input_t *i = vam->input;
3239 vl_api_bridge_domain_add_del_t *mp;
3242 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
3247 /* Parse args required to build the message */
3248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3250 if (unformat (i, "bd_id %d", &bd_id))
3252 else if (unformat (i, "flood %d", &flood))
3254 else if (unformat (i, "uu-flood %d", &uu_flood))
3256 else if (unformat (i, "forward %d", &forward))
3258 else if (unformat (i, "learn %d", &learn))
3260 else if (unformat (i, "arp-term %d", &arp_term))
3262 else if (unformat (i, "mac-age %d", &mac_age))
3264 else if (unformat (i, "bd-tag %s", &bd_tag))
3266 else if (unformat (i, "del"))
3269 flood = uu_flood = forward = learn = 0;
3277 errmsg ("missing bridge domain");
3284 errmsg ("mac age must be less than 256 ");
3289 if ((bd_tag) && (vec_len (bd_tag) > 63))
3291 errmsg ("bd-tag cannot be longer than 63");
3296 M (BRIDGE_DOMAIN_ADD_DEL, mp);
3298 mp->bd_id = ntohl (bd_id);
3300 mp->uu_flood = uu_flood;
3301 mp->forward = forward;
3303 mp->arp_term = arp_term;
3304 mp->is_add = is_add;
3305 mp->mac_age = (u8) mac_age;
3308 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
3309 mp->bd_tag[vec_len (bd_tag)] = 0;
3320 api_l2fib_flush_bd (vat_main_t * vam)
3322 unformat_input_t *i = vam->input;
3323 vl_api_l2fib_flush_bd_t *mp;
3327 /* Parse args required to build the message */
3328 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3330 if (unformat (i, "bd_id %d", &bd_id));
3337 errmsg ("missing bridge domain");
3341 M (L2FIB_FLUSH_BD, mp);
3343 mp->bd_id = htonl (bd_id);
3351 api_l2fib_flush_int (vat_main_t * vam)
3353 unformat_input_t *i = vam->input;
3354 vl_api_l2fib_flush_int_t *mp;
3355 u32 sw_if_index = ~0;
3358 /* Parse args required to build the message */
3359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3361 if (unformat (i, "sw_if_index %d", &sw_if_index));
3363 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
3368 if (sw_if_index == ~0)
3370 errmsg ("missing interface name or sw_if_index");
3374 M (L2FIB_FLUSH_INT, mp);
3376 mp->sw_if_index = ntohl (sw_if_index);
3384 api_l2fib_add_del (vat_main_t * vam)
3386 unformat_input_t *i = vam->input;
3387 vl_api_l2fib_add_del_t *mp;
3393 u32 sw_if_index = 0;
3394 u8 sw_if_index_set = 0;
3403 /* Parse args required to build the message */
3404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3406 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
3408 else if (unformat (i, "bd_id %d", &bd_id))
3410 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3411 sw_if_index_set = 1;
3412 else if (unformat (i, "sw_if"))
3414 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3417 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3418 sw_if_index_set = 1;
3423 else if (unformat (i, "static"))
3425 else if (unformat (i, "filter"))
3430 else if (unformat (i, "bvi"))
3435 else if (unformat (i, "del"))
3437 else if (unformat (i, "count %d", &count))
3445 errmsg ("missing mac address");
3451 errmsg ("missing bridge domain");
3455 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
3457 errmsg ("missing interface name or sw_if_index");
3463 /* Turn on async mode */
3464 vam->async_mode = 1;
3465 vam->async_errors = 0;
3466 before = vat_time_now (vam);
3469 for (j = 0; j < count; j++)
3471 M (L2FIB_ADD_DEL, mp);
3473 clib_memcpy (mp->mac, mac, 6);
3474 mp->bd_id = ntohl (bd_id);
3475 mp->is_add = is_add;
3476 mp->sw_if_index = ntohl (sw_if_index);
3480 mp->static_mac = static_mac;
3481 mp->filter_mac = filter_mac;
3482 mp->bvi_mac = bvi_mac;
3484 increment_mac_address (mac);
3491 vl_api_control_ping_t *mp_ping;
3494 /* Shut off async mode */
3495 vam->async_mode = 0;
3497 MPING (CONTROL_PING, mp_ping);
3500 timeout = vat_time_now (vam) + 1.0;
3501 while (vat_time_now (vam) < timeout)
3502 if (vam->result_ready == 1)
3507 if (vam->retval == -99)
3510 if (vam->async_errors > 0)
3512 errmsg ("%d asynchronous errors", vam->async_errors);
3515 vam->async_errors = 0;
3516 after = vat_time_now (vam);
3518 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
3519 count, after - before, count / (after - before));
3525 /* Wait for a reply... */
3529 /* Return the good/bad news */
3530 return (vam->retval);
3534 api_bridge_domain_set_mac_age (vat_main_t * vam)
3536 unformat_input_t *i = vam->input;
3537 vl_api_bridge_domain_set_mac_age_t *mp;
3542 /* Parse args required to build the message */
3543 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3545 if (unformat (i, "bd_id %d", &bd_id));
3546 else if (unformat (i, "mac-age %d", &mac_age));
3553 errmsg ("missing bridge domain");
3559 errmsg ("mac age must be less than 256 ");
3563 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
3565 mp->bd_id = htonl (bd_id);
3566 mp->mac_age = (u8) mac_age;
3574 api_l2_flags (vat_main_t * vam)
3576 unformat_input_t *i = vam->input;
3577 vl_api_l2_flags_t *mp;
3580 u8 sw_if_index_set = 0;
3584 /* Parse args required to build the message */
3585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3587 if (unformat (i, "sw_if_index %d", &sw_if_index))
3588 sw_if_index_set = 1;
3589 else if (unformat (i, "sw_if"))
3591 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3594 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3595 sw_if_index_set = 1;
3600 else if (unformat (i, "learn"))
3602 else if (unformat (i, "forward"))
3604 else if (unformat (i, "flood"))
3606 else if (unformat (i, "uu-flood"))
3607 flags |= L2_UU_FLOOD;
3608 else if (unformat (i, "arp-term"))
3609 flags |= L2_ARP_TERM;
3610 else if (unformat (i, "off"))
3612 else if (unformat (i, "disable"))
3618 if (sw_if_index_set == 0)
3620 errmsg ("missing interface name or sw_if_index");
3626 mp->sw_if_index = ntohl (sw_if_index);
3627 mp->feature_bitmap = ntohl (flags);
3628 mp->is_set = is_set;
3636 api_bridge_flags (vat_main_t * vam)
3638 unformat_input_t *i = vam->input;
3639 vl_api_bridge_flags_t *mp;
3643 bd_flags_t flags = 0;
3646 /* Parse args required to build the message */
3647 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3649 if (unformat (i, "bd_id %d", &bd_id))
3651 else if (unformat (i, "learn"))
3652 flags |= BRIDGE_API_FLAG_LEARN;
3653 else if (unformat (i, "forward"))
3654 flags |= BRIDGE_API_FLAG_FWD;
3655 else if (unformat (i, "flood"))
3656 flags |= BRIDGE_API_FLAG_FLOOD;
3657 else if (unformat (i, "uu-flood"))
3658 flags |= BRIDGE_API_FLAG_UU_FLOOD;
3659 else if (unformat (i, "arp-term"))
3660 flags |= BRIDGE_API_FLAG_ARP_TERM;
3661 else if (unformat (i, "off"))
3663 else if (unformat (i, "disable"))
3671 errmsg ("missing bridge domain");
3675 M (BRIDGE_FLAGS, mp);
3677 mp->bd_id = ntohl (bd_id);
3678 mp->flags = ntohl (flags);
3679 mp->is_set = is_set;
3687 api_bd_ip_mac_add_del (vat_main_t * vam)
3689 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
3690 vl_api_mac_address_t mac = { 0 };
3691 unformat_input_t *i = vam->input;
3692 vl_api_bd_ip_mac_add_del_t *mp;
3701 /* Parse args required to build the message */
3702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3704 if (unformat (i, "bd_id %d", &bd_id))
3708 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
3712 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
3716 else if (unformat (i, "del"))
3724 errmsg ("missing bridge domain");
3727 else if (ip_set == 0)
3729 errmsg ("missing IP address");
3732 else if (mac_set == 0)
3734 errmsg ("missing MAC address");
3738 M (BD_IP_MAC_ADD_DEL, mp);
3740 mp->entry.bd_id = ntohl (bd_id);
3741 mp->is_add = is_add;
3743 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
3744 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
3752 api_bd_ip_mac_flush (vat_main_t * vam)
3754 unformat_input_t *i = vam->input;
3755 vl_api_bd_ip_mac_flush_t *mp;
3760 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3762 if (unformat (i, "bd_id %d", &bd_id))
3772 errmsg ("missing bridge domain");
3776 M (BD_IP_MAC_FLUSH, mp);
3778 mp->bd_id = ntohl (bd_id);
3785 static void vl_api_bd_ip_mac_details_t_handler
3786 (vl_api_bd_ip_mac_details_t * mp)
3788 vat_main_t *vam = &vat_main;
3792 ntohl (mp->entry.bd_id),
3793 format_vl_api_mac_address, mp->entry.mac,
3794 format_vl_api_address, &mp->entry.ip);
3797 static void vl_api_bd_ip_mac_details_t_handler_json
3798 (vl_api_bd_ip_mac_details_t * mp)
3800 vat_main_t *vam = &vat_main;
3801 vat_json_node_t *node = NULL;
3803 if (VAT_JSON_ARRAY != vam->json_tree.type)
3805 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3806 vat_json_init_array (&vam->json_tree);
3808 node = vat_json_array_add (&vam->json_tree);
3810 vat_json_init_object (node);
3811 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
3812 vat_json_object_add_string_copy (node, "mac_address",
3813 format (0, "%U", format_vl_api_mac_address,
3817 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
3818 vat_json_object_add_string_copy (node, "ip_address", ip);
3823 api_bd_ip_mac_dump (vat_main_t * vam)
3825 unformat_input_t *i = vam->input;
3826 vl_api_bd_ip_mac_dump_t *mp;
3827 vl_api_control_ping_t *mp_ping;
3832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3834 if (unformat (i, "bd_id %d", &bd_id))
3843 "\n%-5s %-7s %-20s %-30s",
3844 "bd_id", "is_ipv6", "mac_address", "ip_address");
3846 /* Dump Bridge Domain Ip to Mac entries */
3847 M (BD_IP_MAC_DUMP, mp);
3850 mp->bd_id = htonl (bd_id);
3856 /* Use a control ping for synchronization */
3857 MPING (CONTROL_PING, mp_ping);
3865 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
3867 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
3870 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
3873 addr->domain = x[0];
3876 addr->function = x[3];
3882 api_virtio_pci_create_v2 (vat_main_t * vam)
3884 unformat_input_t *i = vam->input;
3885 vl_api_virtio_pci_create_v2_t *mp;
3889 u64 features = (u64) ~ (0ULL);
3890 u32 virtio_flags = 0;
3893 clib_memset (mac_address, 0, sizeof (mac_address));
3895 /* Parse args required to build the message */
3896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3898 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
3902 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
3904 else if (unformat (i, "features 0x%llx", &features))
3906 else if (unformat (i, "gso-enabled"))
3907 virtio_flags |= VIRTIO_API_FLAG_GSO;
3908 else if (unformat (i, "csum-offload-enabled"))
3909 virtio_flags |= VIRTIO_API_FLAG_CSUM_OFFLOAD;
3910 else if (unformat (i, "gro-coalesce"))
3911 virtio_flags |= VIRTIO_API_FLAG_GRO_COALESCE;
3912 else if (unformat (i, "packed"))
3913 virtio_flags |= VIRTIO_API_FLAG_PACKED;
3914 else if (unformat (i, "in-order"))
3915 virtio_flags |= VIRTIO_API_FLAG_IN_ORDER;
3916 else if (unformat (i, "buffering"))
3917 virtio_flags |= VIRTIO_API_FLAG_BUFFERING;
3924 errmsg ("pci address must be non zero. ");
3928 /* Construct the API message */
3929 M (VIRTIO_PCI_CREATE_V2, mp);
3931 mp->use_random_mac = random_mac;
3933 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
3934 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
3935 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
3936 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
3938 mp->features = clib_host_to_net_u64 (features);
3939 mp->virtio_flags = clib_host_to_net_u32 (virtio_flags);
3941 if (random_mac == 0)
3942 clib_memcpy (mp->mac_address, mac_address, 6);
3947 /* Wait for a reply... */
3953 api_virtio_pci_delete (vat_main_t * vam)
3955 unformat_input_t *i = vam->input;
3956 vl_api_virtio_pci_delete_t *mp;
3957 u32 sw_if_index = ~0;
3958 u8 sw_if_index_set = 0;
3961 /* Parse args required to build the message */
3962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3964 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3965 sw_if_index_set = 1;
3966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3967 sw_if_index_set = 1;
3972 if (sw_if_index_set == 0)
3974 errmsg ("missing vpp interface name. ");
3978 /* Construct the API message */
3979 M (VIRTIO_PCI_DELETE, mp);
3981 mp->sw_if_index = htonl (sw_if_index);
3986 /* Wait for a reply... */
3992 api_ip_table_add_del (vat_main_t * vam)
3994 unformat_input_t *i = vam->input;
3995 vl_api_ip_table_add_del_t *mp;
4001 /* Parse args required to build the message */
4002 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4004 if (unformat (i, "ipv6"))
4006 else if (unformat (i, "del"))
4008 else if (unformat (i, "add"))
4010 else if (unformat (i, "table %d", &table_id))
4014 clib_warning ("parse error '%U'", format_unformat_error, i);
4021 errmsg ("missing table-ID");
4025 /* Construct the API message */
4026 M (IP_TABLE_ADD_DEL, mp);
4028 mp->table.table_id = ntohl (table_id);
4029 mp->table.is_ip6 = is_ipv6;
4030 mp->is_add = is_add;
4035 /* Wait for a reply... */
4042 unformat_fib_path (unformat_input_t * input, va_list * args)
4044 vat_main_t *vam = va_arg (*args, vat_main_t *);
4045 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
4046 u32 weight, preference;
4047 mpls_label_t out_label;
4049 clib_memset (path, 0, sizeof (*path));
4051 path->sw_if_index = ~0;
4055 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4057 if (unformat (input, "%U %U",
4058 unformat_vl_api_ip4_address,
4059 &path->nh.address.ip4,
4060 api_unformat_sw_if_index, vam, &path->sw_if_index))
4062 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4064 else if (unformat (input, "%U %U",
4065 unformat_vl_api_ip6_address,
4066 &path->nh.address.ip6,
4067 api_unformat_sw_if_index, vam, &path->sw_if_index))
4069 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4071 else if (unformat (input, "weight %u", &weight))
4073 path->weight = weight;
4075 else if (unformat (input, "preference %u", &preference))
4077 path->preference = preference;
4079 else if (unformat (input, "%U next-hop-table %d",
4080 unformat_vl_api_ip4_address,
4081 &path->nh.address.ip4, &path->table_id))
4083 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4085 else if (unformat (input, "%U next-hop-table %d",
4086 unformat_vl_api_ip6_address,
4087 &path->nh.address.ip6, &path->table_id))
4089 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4091 else if (unformat (input, "%U",
4092 unformat_vl_api_ip4_address, &path->nh.address.ip4))
4095 * the recursive next-hops are by default in the default table
4098 path->sw_if_index = ~0;
4099 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4101 else if (unformat (input, "%U",
4102 unformat_vl_api_ip6_address, &path->nh.address.ip6))
4105 * the recursive next-hops are by default in the default table
4108 path->sw_if_index = ~0;
4109 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4111 else if (unformat (input, "resolve-via-host"))
4113 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
4115 else if (unformat (input, "resolve-via-attached"))
4117 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
4119 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
4121 path->type = FIB_API_PATH_TYPE_LOCAL;
4122 path->sw_if_index = ~0;
4123 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4125 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
4127 path->type = FIB_API_PATH_TYPE_LOCAL;
4128 path->sw_if_index = ~0;
4129 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4131 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
4133 else if (unformat (input, "via-label %d", &path->nh.via_label))
4135 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
4136 path->sw_if_index = ~0;
4138 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
4140 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
4141 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
4143 else if (unformat (input, "local"))
4145 path->type = FIB_API_PATH_TYPE_LOCAL;
4147 else if (unformat (input, "out-labels"))
4149 while (unformat (input, "%d", &out_label))
4151 path->label_stack[path->n_labels].label = out_label;
4152 path->label_stack[path->n_labels].is_uniform = 0;
4153 path->label_stack[path->n_labels].ttl = 64;
4157 else if (unformat (input, "via"))
4159 /* new path, back up and return */
4160 unformat_put_input (input);
4161 unformat_put_input (input);
4162 unformat_put_input (input);
4163 unformat_put_input (input);
4172 path->proto = ntohl (path->proto);
4173 path->type = ntohl (path->type);
4174 path->flags = ntohl (path->flags);
4175 path->table_id = ntohl (path->table_id);
4176 path->sw_if_index = ntohl (path->sw_if_index);
4182 api_ip_route_add_del (vat_main_t * vam)
4184 unformat_input_t *i = vam->input;
4185 vl_api_ip_route_add_del_t *mp;
4188 u8 is_multipath = 0;
4191 vl_api_prefix_t pfx = { };
4192 vl_api_fib_path_t paths[8];
4196 u32 random_add_del = 0;
4197 u32 *random_vector = 0;
4198 u32 random_seed = 0xdeaddabe;
4200 /* Parse args required to build the message */
4201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4203 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
4205 else if (unformat (i, "del"))
4207 else if (unformat (i, "add"))
4209 else if (unformat (i, "vrf %d", &vrf_id))
4211 else if (unformat (i, "count %d", &count))
4213 else if (unformat (i, "random"))
4215 else if (unformat (i, "multipath"))
4217 else if (unformat (i, "seed %d", &random_seed))
4221 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4224 if (8 == path_count)
4226 errmsg ("max 8 paths");
4232 clib_warning ("parse error '%U'", format_unformat_error, i);
4239 errmsg ("specify a path; via ...");
4242 if (prefix_set == 0)
4244 errmsg ("missing prefix");
4248 /* Generate a pile of unique, random routes */
4251 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
4252 u32 this_random_address;
4255 random_hash = hash_create (count, sizeof (uword));
4257 hash_set (random_hash, i->as_u32, 1);
4258 for (j = 0; j <= count; j++)
4262 this_random_address = random_u32 (&random_seed);
4263 this_random_address =
4264 clib_host_to_net_u32 (this_random_address);
4266 while (hash_get (random_hash, this_random_address));
4267 vec_add1 (random_vector, this_random_address);
4268 hash_set (random_hash, this_random_address, 1);
4270 hash_free (random_hash);
4271 set_ip4_address (&pfx.address, random_vector[0]);
4276 /* Turn on async mode */
4277 vam->async_mode = 1;
4278 vam->async_errors = 0;
4279 before = vat_time_now (vam);
4282 for (j = 0; j < count; j++)
4284 /* Construct the API message */
4285 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4287 mp->is_add = is_add;
4288 mp->is_multipath = is_multipath;
4290 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
4291 mp->route.table_id = ntohl (vrf_id);
4292 mp->route.n_paths = path_count;
4294 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
4297 set_ip4_address (&pfx.address, random_vector[j + 1]);
4299 increment_address (&pfx.address);
4302 /* If we receive SIGTERM, stop now... */
4307 /* When testing multiple add/del ops, use a control-ping to sync */
4310 vl_api_control_ping_t *mp_ping;
4314 /* Shut off async mode */
4315 vam->async_mode = 0;
4317 MPING (CONTROL_PING, mp_ping);
4320 timeout = vat_time_now (vam) + 1.0;
4321 while (vat_time_now (vam) < timeout)
4322 if (vam->result_ready == 1)
4327 if (vam->retval == -99)
4330 if (vam->async_errors > 0)
4332 errmsg ("%d asynchronous errors", vam->async_errors);
4335 vam->async_errors = 0;
4336 after = vat_time_now (vam);
4338 /* slim chance, but we might have eaten SIGTERM on the first iteration */
4342 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4343 count, after - before, count / (after - before));
4349 /* Wait for a reply... */
4354 /* Return the good/bad news */
4355 return (vam->retval);
4359 api_ip_mroute_add_del (vat_main_t * vam)
4361 unformat_input_t *i = vam->input;
4362 u8 path_set = 0, prefix_set = 0, is_add = 1;
4363 vl_api_ip_mroute_add_del_t *mp;
4364 mfib_entry_flags_t eflags = 0;
4365 vl_api_mfib_path_t path;
4366 vl_api_mprefix_t pfx = { };
4370 /* Parse args required to build the message */
4371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4373 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
4376 pfx.grp_address_length = htons (pfx.grp_address_length);
4378 else if (unformat (i, "del"))
4380 else if (unformat (i, "add"))
4382 else if (unformat (i, "vrf %d", &vrf_id))
4384 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
4385 path.itf_flags = htonl (path.itf_flags);
4386 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
4388 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
4392 clib_warning ("parse error '%U'", format_unformat_error, i);
4397 if (prefix_set == 0)
4399 errmsg ("missing addresses\n");
4404 errmsg ("missing path\n");
4408 /* Construct the API message */
4409 M (IP_MROUTE_ADD_DEL, mp);
4411 mp->is_add = is_add;
4412 mp->is_multipath = 1;
4414 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
4415 mp->route.table_id = htonl (vrf_id);
4416 mp->route.n_paths = 1;
4417 mp->route.entry_flags = htonl (eflags);
4419 clib_memcpy (&mp->route.paths, &path, sizeof (path));
4423 /* Wait for a reply... */
4429 api_mpls_table_add_del (vat_main_t * vam)
4431 unformat_input_t *i = vam->input;
4432 vl_api_mpls_table_add_del_t *mp;
4437 /* Parse args required to build the message */
4438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4440 if (unformat (i, "table %d", &table_id))
4442 else if (unformat (i, "del"))
4444 else if (unformat (i, "add"))
4448 clib_warning ("parse error '%U'", format_unformat_error, i);
4455 errmsg ("missing table-ID");
4459 /* Construct the API message */
4460 M (MPLS_TABLE_ADD_DEL, mp);
4462 mp->mt_table.mt_table_id = ntohl (table_id);
4463 mp->mt_is_add = is_add;
4468 /* Wait for a reply... */
4475 api_mpls_route_add_del (vat_main_t * vam)
4477 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
4478 mpls_label_t local_label = MPLS_LABEL_INVALID;
4479 unformat_input_t *i = vam->input;
4480 vl_api_mpls_route_add_del_t *mp;
4481 vl_api_fib_path_t paths[8];
4485 /* Parse args required to build the message */
4486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4488 if (unformat (i, "%d", &local_label))
4490 else if (unformat (i, "eos"))
4492 else if (unformat (i, "non-eos"))
4494 else if (unformat (i, "del"))
4496 else if (unformat (i, "add"))
4498 else if (unformat (i, "multipath"))
4500 else if (unformat (i, "count %d", &count))
4504 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4507 if (8 == path_count)
4509 errmsg ("max 8 paths");
4515 clib_warning ("parse error '%U'", format_unformat_error, i);
4522 errmsg ("specify a path; via ...");
4526 if (MPLS_LABEL_INVALID == local_label)
4528 errmsg ("missing label");
4534 /* Turn on async mode */
4535 vam->async_mode = 1;
4536 vam->async_errors = 0;
4537 before = vat_time_now (vam);
4540 for (j = 0; j < count; j++)
4542 /* Construct the API message */
4543 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4545 mp->mr_is_add = is_add;
4546 mp->mr_is_multipath = is_multipath;
4548 mp->mr_route.mr_label = local_label;
4549 mp->mr_route.mr_eos = is_eos;
4550 mp->mr_route.mr_table_id = 0;
4551 mp->mr_route.mr_n_paths = path_count;
4553 clib_memcpy (&mp->mr_route.mr_paths, paths,
4554 sizeof (paths[0]) * path_count);
4560 /* If we receive SIGTERM, stop now... */
4565 /* When testing multiple add/del ops, use a control-ping to sync */
4568 vl_api_control_ping_t *mp_ping;
4572 /* Shut off async mode */
4573 vam->async_mode = 0;
4575 MPING (CONTROL_PING, mp_ping);
4578 timeout = vat_time_now (vam) + 1.0;
4579 while (vat_time_now (vam) < timeout)
4580 if (vam->result_ready == 1)
4585 if (vam->retval == -99)
4588 if (vam->async_errors > 0)
4590 errmsg ("%d asynchronous errors", vam->async_errors);
4593 vam->async_errors = 0;
4594 after = vat_time_now (vam);
4596 /* slim chance, but we might have eaten SIGTERM on the first iteration */
4600 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4601 count, after - before, count / (after - before));
4607 /* Wait for a reply... */
4612 /* Return the good/bad news */
4613 return (vam->retval);
4618 api_mpls_ip_bind_unbind (vat_main_t * vam)
4620 unformat_input_t *i = vam->input;
4621 vl_api_mpls_ip_bind_unbind_t *mp;
4622 u32 ip_table_id = 0;
4624 vl_api_prefix_t pfx;
4626 mpls_label_t local_label = MPLS_LABEL_INVALID;
4629 /* Parse args required to build the message */
4630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4632 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
4634 else if (unformat (i, "%d", &local_label))
4636 else if (unformat (i, "table-id %d", &ip_table_id))
4638 else if (unformat (i, "unbind"))
4640 else if (unformat (i, "bind"))
4644 clib_warning ("parse error '%U'", format_unformat_error, i);
4651 errmsg ("IP prefix not set");
4655 if (MPLS_LABEL_INVALID == local_label)
4657 errmsg ("missing label");
4661 /* Construct the API message */
4662 M (MPLS_IP_BIND_UNBIND, mp);
4664 mp->mb_is_bind = is_bind;
4665 mp->mb_ip_table_id = ntohl (ip_table_id);
4666 mp->mb_mpls_table_id = 0;
4667 mp->mb_label = ntohl (local_label);
4668 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
4673 /* Wait for a reply... */
4680 api_mpls_tunnel_add_del (vat_main_t * vam)
4682 unformat_input_t *i = vam->input;
4683 vl_api_mpls_tunnel_add_del_t *mp;
4685 vl_api_fib_path_t paths[8];
4686 u32 sw_if_index = ~0;
4692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4694 if (unformat (i, "add"))
4698 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
4700 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
4702 else if (unformat (i, "l2-only"))
4706 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4709 if (8 == path_count)
4711 errmsg ("max 8 paths");
4717 clib_warning ("parse error '%U'", format_unformat_error, i);
4722 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4724 mp->mt_is_add = is_add;
4725 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
4726 mp->mt_tunnel.mt_l2_only = l2_only;
4727 mp->mt_tunnel.mt_is_multicast = 0;
4728 mp->mt_tunnel.mt_n_paths = path_count;
4730 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
4731 sizeof (paths[0]) * path_count);
4739 api_sw_interface_set_unnumbered (vat_main_t * vam)
4741 unformat_input_t *i = vam->input;
4742 vl_api_sw_interface_set_unnumbered_t *mp;
4744 u32 unnum_sw_index = ~0;
4746 u8 sw_if_index_set = 0;
4749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4751 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4752 sw_if_index_set = 1;
4753 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4754 sw_if_index_set = 1;
4755 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4757 else if (unformat (i, "del"))
4761 clib_warning ("parse error '%U'", format_unformat_error, i);
4766 if (sw_if_index_set == 0)
4768 errmsg ("missing interface name or sw_if_index");
4772 M (SW_INTERFACE_SET_UNNUMBERED, mp);
4774 mp->sw_if_index = ntohl (sw_if_index);
4775 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
4776 mp->is_add = is_add;
4785 api_create_vlan_subif (vat_main_t * vam)
4787 unformat_input_t *i = vam->input;
4788 vl_api_create_vlan_subif_t *mp;
4790 u8 sw_if_index_set = 0;
4795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4797 if (unformat (i, "sw_if_index %d", &sw_if_index))
4798 sw_if_index_set = 1;
4800 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4801 sw_if_index_set = 1;
4802 else if (unformat (i, "vlan %d", &vlan_id))
4806 clib_warning ("parse error '%U'", format_unformat_error, i);
4811 if (sw_if_index_set == 0)
4813 errmsg ("missing interface name or sw_if_index");
4817 if (vlan_id_set == 0)
4819 errmsg ("missing vlan_id");
4822 M (CREATE_VLAN_SUBIF, mp);
4824 mp->sw_if_index = ntohl (sw_if_index);
4825 mp->vlan_id = ntohl (vlan_id);
4832 #define foreach_create_subif_bit \
4839 _(outer_vlan_id_any) \
4840 _(inner_vlan_id_any)
4842 #define foreach_create_subif_flag \
4847 _(4, "exact_match") \
4848 _(5, "default_sub") \
4849 _(6, "outer_vlan_id_any") \
4850 _(7, "inner_vlan_id_any")
4853 api_create_subif (vat_main_t * vam)
4855 unformat_input_t *i = vam->input;
4856 vl_api_create_subif_t *mp;
4858 u8 sw_if_index_set = 0;
4861 u32 __attribute__ ((unused)) no_tags = 0;
4862 u32 __attribute__ ((unused)) one_tag = 0;
4863 u32 __attribute__ ((unused)) two_tags = 0;
4864 u32 __attribute__ ((unused)) dot1ad = 0;
4865 u32 __attribute__ ((unused)) exact_match = 0;
4866 u32 __attribute__ ((unused)) default_sub = 0;
4867 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
4868 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
4870 u16 outer_vlan_id = 0;
4871 u16 inner_vlan_id = 0;
4874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4876 if (unformat (i, "sw_if_index %d", &sw_if_index))
4877 sw_if_index_set = 1;
4879 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4880 sw_if_index_set = 1;
4881 else if (unformat (i, "sub_id %d", &sub_id))
4883 else if (unformat (i, "outer_vlan_id %d", &tmp))
4884 outer_vlan_id = tmp;
4885 else if (unformat (i, "inner_vlan_id %d", &tmp))
4886 inner_vlan_id = tmp;
4888 #define _(a) else if (unformat (i, #a)) a = 1 ;
4889 foreach_create_subif_bit
4893 clib_warning ("parse error '%U'", format_unformat_error, i);
4898 if (sw_if_index_set == 0)
4900 errmsg ("missing interface name or sw_if_index");
4904 if (sub_id_set == 0)
4906 errmsg ("missing sub_id");
4909 M (CREATE_SUBIF, mp);
4911 mp->sw_if_index = ntohl (sw_if_index);
4912 mp->sub_id = ntohl (sub_id);
4914 #define _(a,b) mp->sub_if_flags |= (1 << a);
4915 foreach_create_subif_flag;
4918 mp->outer_vlan_id = ntohs (outer_vlan_id);
4919 mp->inner_vlan_id = ntohs (inner_vlan_id);
4927 api_ip_table_replace_begin (vat_main_t * vam)
4929 unformat_input_t *i = vam->input;
4930 vl_api_ip_table_replace_begin_t *mp;
4935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4937 if (unformat (i, "table %d", &table_id))
4939 else if (unformat (i, "ipv6"))
4943 clib_warning ("parse error '%U'", format_unformat_error, i);
4948 M (IP_TABLE_REPLACE_BEGIN, mp);
4950 mp->table.table_id = ntohl (table_id);
4951 mp->table.is_ip6 = is_ipv6;
4959 api_ip_table_flush (vat_main_t * vam)
4961 unformat_input_t *i = vam->input;
4962 vl_api_ip_table_flush_t *mp;
4967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4969 if (unformat (i, "table %d", &table_id))
4971 else if (unformat (i, "ipv6"))
4975 clib_warning ("parse error '%U'", format_unformat_error, i);
4980 M (IP_TABLE_FLUSH, mp);
4982 mp->table.table_id = ntohl (table_id);
4983 mp->table.is_ip6 = is_ipv6;
4991 api_ip_table_replace_end (vat_main_t * vam)
4993 unformat_input_t *i = vam->input;
4994 vl_api_ip_table_replace_end_t *mp;
4999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5001 if (unformat (i, "table %d", &table_id))
5003 else if (unformat (i, "ipv6"))
5007 clib_warning ("parse error '%U'", format_unformat_error, i);
5012 M (IP_TABLE_REPLACE_END, mp);
5014 mp->table.table_id = ntohl (table_id);
5015 mp->table.is_ip6 = is_ipv6;
5023 api_set_ip_flow_hash (vat_main_t * vam)
5025 unformat_input_t *i = vam->input;
5026 vl_api_set_ip_flow_hash_t *mp;
5038 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5040 if (unformat (i, "vrf %d", &vrf_id))
5042 else if (unformat (i, "ipv6"))
5044 else if (unformat (i, "src"))
5046 else if (unformat (i, "dst"))
5048 else if (unformat (i, "sport"))
5050 else if (unformat (i, "dport"))
5052 else if (unformat (i, "proto"))
5054 else if (unformat (i, "reverse"))
5059 clib_warning ("parse error '%U'", format_unformat_error, i);
5064 if (vrf_id_set == 0)
5066 errmsg ("missing vrf id");
5070 M (SET_IP_FLOW_HASH, mp);
5076 mp->reverse = reverse;
5077 mp->vrf_id = ntohl (vrf_id);
5078 mp->is_ipv6 = is_ipv6;
5086 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5088 unformat_input_t *i = vam->input;
5089 vl_api_sw_interface_ip6_enable_disable_t *mp;
5091 u8 sw_if_index_set = 0;
5095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5098 sw_if_index_set = 1;
5099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5100 sw_if_index_set = 1;
5101 else if (unformat (i, "enable"))
5103 else if (unformat (i, "disable"))
5107 clib_warning ("parse error '%U'", format_unformat_error, i);
5112 if (sw_if_index_set == 0)
5114 errmsg ("missing interface name or sw_if_index");
5118 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
5120 mp->sw_if_index = ntohl (sw_if_index);
5121 mp->enable = enable;
5130 api_l2_patch_add_del (vat_main_t * vam)
5132 unformat_input_t *i = vam->input;
5133 vl_api_l2_patch_add_del_t *mp;
5135 u8 rx_sw_if_index_set = 0;
5137 u8 tx_sw_if_index_set = 0;
5141 /* Parse args required to build the message */
5142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5144 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5145 rx_sw_if_index_set = 1;
5146 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5147 tx_sw_if_index_set = 1;
5148 else if (unformat (i, "rx"))
5150 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5152 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5154 rx_sw_if_index_set = 1;
5159 else if (unformat (i, "tx"))
5161 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5163 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5165 tx_sw_if_index_set = 1;
5170 else if (unformat (i, "del"))
5176 if (rx_sw_if_index_set == 0)
5178 errmsg ("missing rx interface name or rx_sw_if_index");
5182 if (tx_sw_if_index_set == 0)
5184 errmsg ("missing tx interface name or tx_sw_if_index");
5188 M (L2_PATCH_ADD_DEL, mp);
5190 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5191 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5192 mp->is_add = is_add;
5200 u8 localsid_addr[16];
5209 api_ioam_enable (vat_main_t * vam)
5211 unformat_input_t *input = vam->input;
5212 vl_api_ioam_enable_t *mp;
5214 int has_trace_option = 0;
5215 int has_pot_option = 0;
5216 int has_seqno_option = 0;
5217 int has_analyse_option = 0;
5220 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5222 if (unformat (input, "trace"))
5223 has_trace_option = 1;
5224 else if (unformat (input, "pot"))
5226 else if (unformat (input, "seqno"))
5227 has_seqno_option = 1;
5228 else if (unformat (input, "analyse"))
5229 has_analyse_option = 1;
5233 M (IOAM_ENABLE, mp);
5234 mp->id = htons (id);
5235 mp->seqno = has_seqno_option;
5236 mp->analyse = has_analyse_option;
5237 mp->pot_enable = has_pot_option;
5238 mp->trace_enable = has_trace_option;
5247 api_ioam_disable (vat_main_t * vam)
5249 vl_api_ioam_disable_t *mp;
5252 M (IOAM_DISABLE, mp);
5258 #define foreach_tcp_proto_field \
5262 #define foreach_udp_proto_field \
5266 #define foreach_ip4_proto_field \
5278 u16 src_port, dst_port;
5281 #if VPP_API_TEST_BUILTIN == 0
5283 unformat_tcp_mask (unformat_input_t * input, va_list * args)
5285 u8 **maskp = va_arg (*args, u8 **);
5287 u8 found_something = 0;
5290 #define _(a) u8 a=0;
5291 foreach_tcp_proto_field;
5294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5297 #define _(a) else if (unformat (input, #a)) a=1;
5298 foreach_tcp_proto_field
5304 #define _(a) found_something += a;
5305 foreach_tcp_proto_field;
5308 if (found_something == 0)
5311 vec_validate (mask, sizeof (*tcp) - 1);
5313 tcp = (tcp_header_t *) mask;
5315 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
5316 foreach_tcp_proto_field;
5324 unformat_udp_mask (unformat_input_t * input, va_list * args)
5326 u8 **maskp = va_arg (*args, u8 **);
5328 u8 found_something = 0;
5331 #define _(a) u8 a=0;
5332 foreach_udp_proto_field;
5335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5338 #define _(a) else if (unformat (input, #a)) a=1;
5339 foreach_udp_proto_field
5345 #define _(a) found_something += a;
5346 foreach_udp_proto_field;
5349 if (found_something == 0)
5352 vec_validate (mask, sizeof (*udp) - 1);
5354 udp = (udp_header_t *) mask;
5356 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
5357 foreach_udp_proto_field;
5365 unformat_l4_mask (unformat_input_t * input, va_list * args)
5367 u8 **maskp = va_arg (*args, u8 **);
5368 u16 src_port = 0, dst_port = 0;
5369 tcpudp_header_t *tcpudp;
5371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5373 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
5375 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
5377 else if (unformat (input, "src_port"))
5379 else if (unformat (input, "dst_port"))
5385 if (!src_port && !dst_port)
5389 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
5391 tcpudp = (tcpudp_header_t *) mask;
5392 tcpudp->src_port = src_port;
5393 tcpudp->dst_port = dst_port;
5401 unformat_ip4_mask (unformat_input_t * input, va_list * args)
5403 u8 **maskp = va_arg (*args, u8 **);
5405 u8 found_something = 0;
5408 #define _(a) u8 a=0;
5409 foreach_ip4_proto_field;
5415 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5417 if (unformat (input, "version"))
5419 else if (unformat (input, "hdr_length"))
5421 else if (unformat (input, "src"))
5423 else if (unformat (input, "dst"))
5425 else if (unformat (input, "proto"))
5428 #define _(a) else if (unformat (input, #a)) a=1;
5429 foreach_ip4_proto_field
5435 #define _(a) found_something += a;
5436 foreach_ip4_proto_field;
5439 if (found_something == 0)
5442 vec_validate (mask, sizeof (*ip) - 1);
5444 ip = (ip4_header_t *) mask;
5446 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
5447 foreach_ip4_proto_field;
5450 ip->ip_version_and_header_length = 0;
5453 ip->ip_version_and_header_length |= 0xF0;
5456 ip->ip_version_and_header_length |= 0x0F;
5462 #define foreach_ip6_proto_field \
5470 unformat_ip6_mask (unformat_input_t * input, va_list * args)
5472 u8 **maskp = va_arg (*args, u8 **);
5474 u8 found_something = 0;
5476 u32 ip_version_traffic_class_and_flow_label;
5478 #define _(a) u8 a=0;
5479 foreach_ip6_proto_field;
5482 u8 traffic_class = 0;
5485 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5487 if (unformat (input, "version"))
5489 else if (unformat (input, "traffic-class"))
5491 else if (unformat (input, "flow-label"))
5493 else if (unformat (input, "src"))
5495 else if (unformat (input, "dst"))
5497 else if (unformat (input, "proto"))
5500 #define _(a) else if (unformat (input, #a)) a=1;
5501 foreach_ip6_proto_field
5507 #define _(a) found_something += a;
5508 foreach_ip6_proto_field;
5511 if (found_something == 0)
5514 vec_validate (mask, sizeof (*ip) - 1);
5516 ip = (ip6_header_t *) mask;
5518 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
5519 foreach_ip6_proto_field;
5522 ip_version_traffic_class_and_flow_label = 0;
5525 ip_version_traffic_class_and_flow_label |= 0xF0000000;
5528 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
5531 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
5533 ip->ip_version_traffic_class_and_flow_label =
5534 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
5541 unformat_l3_mask (unformat_input_t * input, va_list * args)
5543 u8 **maskp = va_arg (*args, u8 **);
5545 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5547 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
5549 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
5558 unformat_l2_mask (unformat_input_t * input, va_list * args)
5560 u8 **maskp = va_arg (*args, u8 **);
5575 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5577 if (unformat (input, "src"))
5579 else if (unformat (input, "dst"))
5581 else if (unformat (input, "proto"))
5583 else if (unformat (input, "tag1"))
5585 else if (unformat (input, "tag2"))
5587 else if (unformat (input, "ignore-tag1"))
5589 else if (unformat (input, "ignore-tag2"))
5591 else if (unformat (input, "cos1"))
5593 else if (unformat (input, "cos2"))
5595 else if (unformat (input, "dot1q"))
5597 else if (unformat (input, "dot1ad"))
5602 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
5603 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
5606 if (tag1 || ignore_tag1 || cos1 || dot1q)
5608 if (tag2 || ignore_tag2 || cos2 || dot1ad)
5611 vec_validate (mask, len - 1);
5614 clib_memset (mask, 0xff, 6);
5617 clib_memset (mask + 6, 0xff, 6);
5621 /* inner vlan tag */
5630 mask[21] = mask[20] = 0xff;
5651 mask[16] = mask[17] = 0xff;
5661 mask[12] = mask[13] = 0xff;
5668 unformat_classify_mask (unformat_input_t * input, va_list * args)
5670 u8 **maskp = va_arg (*args, u8 **);
5671 u32 *skipp = va_arg (*args, u32 *);
5672 u32 *matchp = va_arg (*args, u32 *);
5680 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5682 if (unformat (input, "hex %U", unformat_hex_string, &mask))
5684 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
5686 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
5688 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
5702 if (mask || l2 || l3 || l4)
5706 /* "With a free Ethernet header in every package" */
5708 vec_validate (l2, 13);
5712 vec_append (mask, l3);
5717 vec_append (mask, l4);
5722 /* Scan forward looking for the first significant mask octet */
5723 for (i = 0; i < vec_len (mask); i++)
5727 /* compute (skip, match) params */
5728 *skipp = i / sizeof (u32x4);
5729 vec_delete (mask, *skipp * sizeof (u32x4), 0);
5731 /* Pad mask to an even multiple of the vector size */
5732 while (vec_len (mask) % sizeof (u32x4))
5735 match = vec_len (mask) / sizeof (u32x4);
5737 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
5739 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
5740 if (*tmp || *(tmp + 1))
5745 clib_warning ("BUG: match 0");
5747 _vec_len (mask) = match * sizeof (u32x4);
5757 #endif /* VPP_API_TEST_BUILTIN */
5759 #define foreach_l2_next \
5761 _(ethernet, ETHERNET_INPUT) \
5766 unformat_l2_next_index (unformat_input_t * input, va_list * args)
5768 u32 *miss_next_indexp = va_arg (*args, u32 *);
5773 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
5777 if (unformat (input, "%d", &tmp))
5786 *miss_next_indexp = next_index;
5790 #define foreach_ip_next \
5796 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
5798 u32 *miss_next_indexp = va_arg (*args, u32 *);
5803 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
5807 if (unformat (input, "%d", &tmp))
5816 *miss_next_indexp = next_index;
5820 #define foreach_acl_next \
5824 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
5826 u32 *miss_next_indexp = va_arg (*args, u32 *);
5831 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
5835 if (unformat (input, "permit"))
5840 else if (unformat (input, "%d", &tmp))
5849 *miss_next_indexp = next_index;
5854 unformat_policer_precolor (unformat_input_t * input, va_list * args)
5856 u32 *r = va_arg (*args, u32 *);
5858 if (unformat (input, "conform-color"))
5859 *r = POLICE_CONFORM;
5860 else if (unformat (input, "exceed-color"))
5868 #if VPP_API_TEST_BUILTIN == 0
5870 unformat_l4_match (unformat_input_t * input, va_list * args)
5872 u8 **matchp = va_arg (*args, u8 **);
5874 u8 *proto_header = 0;
5880 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5882 if (unformat (input, "src_port %d", &src_port))
5884 else if (unformat (input, "dst_port %d", &dst_port))
5890 h.src_port = clib_host_to_net_u16 (src_port);
5891 h.dst_port = clib_host_to_net_u16 (dst_port);
5892 vec_validate (proto_header, sizeof (h) - 1);
5893 memcpy (proto_header, &h, sizeof (h));
5895 *matchp = proto_header;
5901 unformat_ip4_match (unformat_input_t * input, va_list * args)
5903 u8 **matchp = va_arg (*args, u8 **);
5910 int src = 0, dst = 0;
5911 ip4_address_t src_val, dst_val;
5918 int fragment_id = 0;
5919 u32 fragment_id_val;
5925 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5927 if (unformat (input, "version %d", &version_val))
5929 else if (unformat (input, "hdr_length %d", &hdr_length_val))
5931 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
5933 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
5935 else if (unformat (input, "proto %d", &proto_val))
5937 else if (unformat (input, "tos %d", &tos_val))
5939 else if (unformat (input, "length %d", &length_val))
5941 else if (unformat (input, "fragment_id %d", &fragment_id_val))
5943 else if (unformat (input, "ttl %d", &ttl_val))
5945 else if (unformat (input, "checksum %d", &checksum_val))
5951 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
5952 + ttl + checksum == 0)
5956 * Aligned because we use the real comparison functions
5958 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
5960 ip = (ip4_header_t *) match;
5962 /* These are realistically matched in practice */
5964 ip->src_address.as_u32 = src_val.as_u32;
5967 ip->dst_address.as_u32 = dst_val.as_u32;
5970 ip->protocol = proto_val;
5973 /* These are not, but they're included for completeness */
5975 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
5978 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
5984 ip->length = clib_host_to_net_u16 (length_val);
5990 ip->checksum = clib_host_to_net_u16 (checksum_val);
5997 unformat_ip6_match (unformat_input_t * input, va_list * args)
5999 u8 **matchp = va_arg (*args, u8 **);
6004 u8 traffic_class = 0;
6005 u32 traffic_class_val = 0;
6008 int src = 0, dst = 0;
6009 ip6_address_t src_val, dst_val;
6012 int payload_length = 0;
6013 u32 payload_length_val;
6016 u32 ip_version_traffic_class_and_flow_label;
6018 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6020 if (unformat (input, "version %d", &version_val))
6022 else if (unformat (input, "traffic_class %d", &traffic_class_val))
6024 else if (unformat (input, "flow_label %d", &flow_label_val))
6026 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
6028 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
6030 else if (unformat (input, "proto %d", &proto_val))
6032 else if (unformat (input, "payload_length %d", &payload_length_val))
6034 else if (unformat (input, "hop_limit %d", &hop_limit_val))
6040 if (version + traffic_class + flow_label + src + dst + proto +
6041 payload_length + hop_limit == 0)
6045 * Aligned because we use the real comparison functions
6047 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
6049 ip = (ip6_header_t *) match;
6052 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
6055 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
6058 ip->protocol = proto_val;
6060 ip_version_traffic_class_and_flow_label = 0;
6063 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
6066 ip_version_traffic_class_and_flow_label |=
6067 (traffic_class_val & 0xFF) << 20;
6070 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
6072 ip->ip_version_traffic_class_and_flow_label =
6073 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6076 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
6079 ip->hop_limit = hop_limit_val;
6086 unformat_l3_match (unformat_input_t * input, va_list * args)
6088 u8 **matchp = va_arg (*args, u8 **);
6090 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6092 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
6094 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
6103 unformat_vlan_tag (unformat_input_t * input, va_list * args)
6105 u8 *tagp = va_arg (*args, u8 *);
6108 if (unformat (input, "%d", &tag))
6110 tagp[0] = (tag >> 8) & 0x0F;
6111 tagp[1] = tag & 0xFF;
6119 unformat_l2_match (unformat_input_t * input, va_list * args)
6121 u8 **matchp = va_arg (*args, u8 **);
6141 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6143 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
6146 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
6148 else if (unformat (input, "proto %U",
6149 unformat_ethernet_type_host_byte_order, &proto_val))
6151 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
6153 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
6155 else if (unformat (input, "ignore-tag1"))
6157 else if (unformat (input, "ignore-tag2"))
6159 else if (unformat (input, "cos1 %d", &cos1_val))
6161 else if (unformat (input, "cos2 %d", &cos2_val))
6166 if ((src + dst + proto + tag1 + tag2 +
6167 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6170 if (tag1 || ignore_tag1 || cos1)
6172 if (tag2 || ignore_tag2 || cos2)
6175 vec_validate_aligned (match, len - 1, sizeof (u32x4));
6178 clib_memcpy (match, dst_val, 6);
6181 clib_memcpy (match + 6, src_val, 6);
6185 /* inner vlan tag */
6186 match[19] = tag2_val[1];
6187 match[18] = tag2_val[0];
6189 match[18] |= (cos2_val & 0x7) << 5;
6192 match[21] = proto_val & 0xff;
6193 match[20] = proto_val >> 8;
6197 match[15] = tag1_val[1];
6198 match[14] = tag1_val[0];
6201 match[14] |= (cos1_val & 0x7) << 5;
6207 match[15] = tag1_val[1];
6208 match[14] = tag1_val[0];
6211 match[17] = proto_val & 0xff;
6212 match[16] = proto_val >> 8;
6215 match[14] |= (cos1_val & 0x7) << 5;
6221 match[18] |= (cos2_val & 0x7) << 5;
6223 match[14] |= (cos1_val & 0x7) << 5;
6226 match[13] = proto_val & 0xff;
6227 match[12] = proto_val >> 8;
6235 unformat_qos_source (unformat_input_t * input, va_list * args)
6237 int *qs = va_arg (*args, int *);
6239 if (unformat (input, "ip"))
6240 *qs = QOS_SOURCE_IP;
6241 else if (unformat (input, "mpls"))
6242 *qs = QOS_SOURCE_MPLS;
6243 else if (unformat (input, "ext"))
6244 *qs = QOS_SOURCE_EXT;
6245 else if (unformat (input, "vlan"))
6246 *qs = QOS_SOURCE_VLAN;
6255 api_unformat_classify_match (unformat_input_t * input, va_list * args)
6257 u8 **matchp = va_arg (*args, u8 **);
6258 u32 skip_n_vectors = va_arg (*args, u32);
6259 u32 match_n_vectors = va_arg (*args, u32);
6266 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6268 if (unformat (input, "hex %U", unformat_hex_string, &match))
6270 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
6272 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
6274 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
6288 if (match || l2 || l3 || l4)
6292 /* "Win a free Ethernet header in every packet" */
6294 vec_validate_aligned (l2, 13, sizeof (u32x4));
6298 vec_append_aligned (match, l3, sizeof (u32x4));
6303 vec_append_aligned (match, l4, sizeof (u32x4));
6308 /* Make sure the vector is big enough even if key is all 0's */
6309 vec_validate_aligned
6310 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
6313 /* Set size, include skipped vectors */
6314 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
6325 api_get_node_index (vat_main_t * vam)
6327 unformat_input_t *i = vam->input;
6328 vl_api_get_node_index_t *mp;
6332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6334 if (unformat (i, "node %s", &name))
6341 errmsg ("node name required");
6344 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
6346 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6350 M (GET_NODE_INDEX, mp);
6351 clib_memcpy (mp->node_name, name, vec_len (name));
6360 api_get_next_index (vat_main_t * vam)
6362 unformat_input_t *i = vam->input;
6363 vl_api_get_next_index_t *mp;
6364 u8 *node_name = 0, *next_node_name = 0;
6367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6369 if (unformat (i, "node-name %s", &node_name))
6371 else if (unformat (i, "next-node-name %s", &next_node_name))
6377 errmsg ("node name required");
6380 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
6382 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6386 if (next_node_name == 0)
6388 errmsg ("next node name required");
6391 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
6393 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
6397 M (GET_NEXT_INDEX, mp);
6398 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
6399 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
6400 vec_free (node_name);
6401 vec_free (next_node_name);
6409 api_add_node_next (vat_main_t * vam)
6411 unformat_input_t *i = vam->input;
6412 vl_api_add_node_next_t *mp;
6417 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6419 if (unformat (i, "node %s", &name))
6421 else if (unformat (i, "next %s", &next))
6428 errmsg ("node name required");
6431 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
6433 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6438 errmsg ("next node required");
6441 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
6443 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
6447 M (ADD_NODE_NEXT, mp);
6448 clib_memcpy (mp->node_name, name, vec_len (name));
6449 clib_memcpy (mp->next_name, next, vec_len (next));
6458 static void vl_api_sw_interface_virtio_pci_details_t_handler
6459 (vl_api_sw_interface_virtio_pci_details_t * mp)
6461 vat_main_t *vam = &vat_main;
6476 addr.domain = ntohs (mp->pci_addr.domain);
6477 addr.bus = mp->pci_addr.bus;
6478 addr.slot = mp->pci_addr.slot;
6479 addr.function = mp->pci_addr.function;
6481 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
6482 addr.slot, addr.function);
6485 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
6486 pci_addr, ntohl (mp->sw_if_index),
6487 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
6488 format_ethernet_address, mp->mac_addr,
6489 clib_net_to_host_u64 (mp->features));
6490 vec_free (pci_addr);
6493 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
6494 (vl_api_sw_interface_virtio_pci_details_t * mp)
6496 vat_main_t *vam = &vat_main;
6497 vat_json_node_t *node = NULL;
6498 vlib_pci_addr_t pci_addr;
6500 if (VAT_JSON_ARRAY != vam->json_tree.type)
6502 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6503 vat_json_init_array (&vam->json_tree);
6505 node = vat_json_array_add (&vam->json_tree);
6507 pci_addr.domain = ntohs (mp->pci_addr.domain);
6508 pci_addr.bus = mp->pci_addr.bus;
6509 pci_addr.slot = mp->pci_addr.slot;
6510 pci_addr.function = mp->pci_addr.function;
6512 vat_json_init_object (node);
6513 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
6514 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6515 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
6516 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
6517 vat_json_object_add_uint (node, "features",
6518 clib_net_to_host_u64 (mp->features));
6519 vat_json_object_add_string_copy (node, "mac_addr",
6520 format (0, "%U", format_ethernet_address,
6525 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
6527 vl_api_sw_interface_virtio_pci_dump_t *mp;
6528 vl_api_control_ping_t *mp_ping;
6532 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
6533 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
6534 "mac_addr", "features");
6536 /* Get list of tap interfaces */
6537 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
6540 /* Use a control ping for synchronization */
6541 MPING (CONTROL_PING, mp_ping);
6549 api_l2_fib_clear_table (vat_main_t * vam)
6551 // unformat_input_t * i = vam->input;
6552 vl_api_l2_fib_clear_table_t *mp;
6555 M (L2_FIB_CLEAR_TABLE, mp);
6563 api_l2_interface_efp_filter (vat_main_t * vam)
6565 unformat_input_t *i = vam->input;
6566 vl_api_l2_interface_efp_filter_t *mp;
6569 u8 sw_if_index_set = 0;
6572 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6574 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6575 sw_if_index_set = 1;
6576 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6577 sw_if_index_set = 1;
6578 else if (unformat (i, "enable"))
6580 else if (unformat (i, "disable"))
6584 clib_warning ("parse error '%U'", format_unformat_error, i);
6589 if (sw_if_index_set == 0)
6591 errmsg ("missing sw_if_index");
6595 M (L2_INTERFACE_EFP_FILTER, mp);
6597 mp->sw_if_index = ntohl (sw_if_index);
6598 mp->enable_disable = enable;
6605 #define foreach_vtr_op \
6606 _("disable", L2_VTR_DISABLED) \
6607 _("push-1", L2_VTR_PUSH_1) \
6608 _("push-2", L2_VTR_PUSH_2) \
6609 _("pop-1", L2_VTR_POP_1) \
6610 _("pop-2", L2_VTR_POP_2) \
6611 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
6612 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
6613 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
6614 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
6617 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
6619 unformat_input_t *i = vam->input;
6620 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
6622 u8 sw_if_index_set = 0;
6630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6632 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6633 sw_if_index_set = 1;
6634 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6635 sw_if_index_set = 1;
6636 else if (unformat (i, "vtr_op %d", &vtr_op))
6638 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
6641 else if (unformat (i, "push_dot1q %d", &push_dot1q))
6643 else if (unformat (i, "tag1 %d", &tag1))
6645 else if (unformat (i, "tag2 %d", &tag2))
6649 clib_warning ("parse error '%U'", format_unformat_error, i);
6654 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
6656 errmsg ("missing vtr operation or sw_if_index");
6660 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
6661 mp->sw_if_index = ntohl (sw_if_index);
6662 mp->vtr_op = ntohl (vtr_op);
6663 mp->push_dot1q = ntohl (push_dot1q);
6664 mp->tag1 = ntohl (tag1);
6665 mp->tag2 = ntohl (tag2);
6673 api_create_vhost_user_if (vat_main_t * vam)
6675 unformat_input_t *i = vam->input;
6676 vl_api_create_vhost_user_if_t *mp;
6679 u8 file_name_set = 0;
6680 u32 custom_dev_instance = ~0;
6682 u8 use_custom_mac = 0;
6683 u8 disable_mrg_rxbuf = 0;
6684 u8 disable_indirect_desc = 0;
6687 u8 enable_packed = 0;
6690 /* Shut up coverity */
6691 clib_memset (hwaddr, 0, sizeof (hwaddr));
6693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6695 if (unformat (i, "socket %s", &file_name))
6699 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
6701 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
6703 else if (unformat (i, "server"))
6705 else if (unformat (i, "disable_mrg_rxbuf"))
6706 disable_mrg_rxbuf = 1;
6707 else if (unformat (i, "disable_indirect_desc"))
6708 disable_indirect_desc = 1;
6709 else if (unformat (i, "gso"))
6711 else if (unformat (i, "packed"))
6713 else if (unformat (i, "tag %s", &tag))
6719 if (file_name_set == 0)
6721 errmsg ("missing socket file name");
6725 if (vec_len (file_name) > 255)
6727 errmsg ("socket file name too long");
6730 vec_add1 (file_name, 0);
6732 M (CREATE_VHOST_USER_IF, mp);
6734 mp->is_server = is_server;
6735 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
6736 mp->disable_indirect_desc = disable_indirect_desc;
6737 mp->enable_gso = enable_gso;
6738 mp->enable_packed = enable_packed;
6739 mp->custom_dev_instance = ntohl (custom_dev_instance);
6740 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
6741 vec_free (file_name);
6742 if (custom_dev_instance != ~0)
6745 mp->use_custom_mac = use_custom_mac;
6746 clib_memcpy (mp->mac_address, hwaddr, 6);
6748 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
6757 api_modify_vhost_user_if (vat_main_t * vam)
6759 unformat_input_t *i = vam->input;
6760 vl_api_modify_vhost_user_if_t *mp;
6763 u8 file_name_set = 0;
6764 u32 custom_dev_instance = ~0;
6765 u8 sw_if_index_set = 0;
6766 u32 sw_if_index = (u32) ~ 0;
6768 u8 enable_packed = 0;
6771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6773 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6774 sw_if_index_set = 1;
6775 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6776 sw_if_index_set = 1;
6777 else if (unformat (i, "socket %s", &file_name))
6781 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
6783 else if (unformat (i, "server"))
6785 else if (unformat (i, "gso"))
6787 else if (unformat (i, "packed"))
6793 if (sw_if_index_set == 0)
6795 errmsg ("missing sw_if_index or interface name");
6799 if (file_name_set == 0)
6801 errmsg ("missing socket file name");
6805 if (vec_len (file_name) > 255)
6807 errmsg ("socket file name too long");
6810 vec_add1 (file_name, 0);
6812 M (MODIFY_VHOST_USER_IF, mp);
6814 mp->sw_if_index = ntohl (sw_if_index);
6815 mp->is_server = is_server;
6816 mp->enable_gso = enable_gso;
6817 mp->enable_packed = enable_packed;
6818 mp->custom_dev_instance = ntohl (custom_dev_instance);
6819 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
6820 vec_free (file_name);
6821 if (custom_dev_instance != ~0)
6830 api_create_vhost_user_if_v2 (vat_main_t * vam)
6832 unformat_input_t *i = vam->input;
6833 vl_api_create_vhost_user_if_v2_t *mp;
6836 u8 file_name_set = 0;
6837 u32 custom_dev_instance = ~0;
6839 u8 use_custom_mac = 0;
6840 u8 disable_mrg_rxbuf = 0;
6841 u8 disable_indirect_desc = 0;
6844 u8 enable_packed = 0;
6845 u8 enable_event_idx = 0;
6848 /* Shut up coverity */
6849 clib_memset (hwaddr, 0, sizeof (hwaddr));
6851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6853 if (unformat (i, "socket %s", &file_name))
6857 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
6859 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
6861 else if (unformat (i, "server"))
6863 else if (unformat (i, "disable_mrg_rxbuf"))
6864 disable_mrg_rxbuf = 1;
6865 else if (unformat (i, "disable_indirect_desc"))
6866 disable_indirect_desc = 1;
6867 else if (unformat (i, "gso"))
6869 else if (unformat (i, "packed"))
6871 else if (unformat (i, "event-idx"))
6872 enable_event_idx = 1;
6873 else if (unformat (i, "tag %s", &tag))
6879 if (file_name_set == 0)
6881 errmsg ("missing socket file name");
6885 if (vec_len (file_name) > 255)
6887 errmsg ("socket file name too long");
6890 vec_add1 (file_name, 0);
6892 M (CREATE_VHOST_USER_IF_V2, mp);
6894 mp->is_server = is_server;
6895 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
6896 mp->disable_indirect_desc = disable_indirect_desc;
6897 mp->enable_gso = enable_gso;
6898 mp->enable_packed = enable_packed;
6899 mp->enable_event_idx = enable_event_idx;
6900 mp->custom_dev_instance = ntohl (custom_dev_instance);
6901 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
6902 vec_free (file_name);
6903 if (custom_dev_instance != ~0)
6906 mp->use_custom_mac = use_custom_mac;
6907 clib_memcpy (mp->mac_address, hwaddr, 6);
6909 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
6918 api_modify_vhost_user_if_v2 (vat_main_t * vam)
6920 unformat_input_t *i = vam->input;
6921 vl_api_modify_vhost_user_if_v2_t *mp;
6924 u8 file_name_set = 0;
6925 u32 custom_dev_instance = ~0;
6926 u8 sw_if_index_set = 0;
6927 u32 sw_if_index = (u32) ~ 0;
6929 u8 enable_packed = 0;
6930 u8 enable_event_idx = 0;
6933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6935 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6936 sw_if_index_set = 1;
6937 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6938 sw_if_index_set = 1;
6939 else if (unformat (i, "socket %s", &file_name))
6943 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
6945 else if (unformat (i, "server"))
6947 else if (unformat (i, "gso"))
6949 else if (unformat (i, "packed"))
6951 else if (unformat (i, "event-idx"))
6952 enable_event_idx = 1;
6957 if (sw_if_index_set == 0)
6959 errmsg ("missing sw_if_index or interface name");
6963 if (file_name_set == 0)
6965 errmsg ("missing socket file name");
6969 if (vec_len (file_name) > 255)
6971 errmsg ("socket file name too long");
6974 vec_add1 (file_name, 0);
6976 M (MODIFY_VHOST_USER_IF_V2, mp);
6978 mp->sw_if_index = ntohl (sw_if_index);
6979 mp->is_server = is_server;
6980 mp->enable_gso = enable_gso;
6981 mp->enable_packed = enable_packed;
6982 mp->enable_event_idx = enable_event_idx;
6983 mp->custom_dev_instance = ntohl (custom_dev_instance);
6984 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
6985 vec_free (file_name);
6986 if (custom_dev_instance != ~0)
6995 api_delete_vhost_user_if (vat_main_t * vam)
6997 unformat_input_t *i = vam->input;
6998 vl_api_delete_vhost_user_if_t *mp;
6999 u32 sw_if_index = ~0;
7000 u8 sw_if_index_set = 0;
7003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7005 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7006 sw_if_index_set = 1;
7007 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7008 sw_if_index_set = 1;
7013 if (sw_if_index_set == 0)
7015 errmsg ("missing sw_if_index or interface name");
7020 M (DELETE_VHOST_USER_IF, mp);
7022 mp->sw_if_index = ntohl (sw_if_index);
7029 static void vl_api_sw_interface_vhost_user_details_t_handler
7030 (vl_api_sw_interface_vhost_user_details_t * mp)
7032 vat_main_t *vam = &vat_main;
7036 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
7037 clib_net_to_host_u32
7038 (mp->features_last_32) <<
7041 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %16llx %6d %7d %s",
7042 (char *) mp->interface_name, ntohl (mp->sw_if_index),
7043 ntohl (mp->virtio_net_hdr_sz), features, mp->is_server,
7044 ntohl (mp->num_regions), (char *) mp->sock_filename);
7045 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
7048 static void vl_api_sw_interface_vhost_user_details_t_handler_json
7049 (vl_api_sw_interface_vhost_user_details_t * mp)
7051 vat_main_t *vam = &vat_main;
7052 vat_json_node_t *node = NULL;
7054 if (VAT_JSON_ARRAY != vam->json_tree.type)
7056 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7057 vat_json_init_array (&vam->json_tree);
7059 node = vat_json_array_add (&vam->json_tree);
7061 vat_json_init_object (node);
7062 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
7063 vat_json_object_add_string_copy (node, "interface_name",
7064 mp->interface_name);
7065 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
7066 ntohl (mp->virtio_net_hdr_sz));
7067 vat_json_object_add_uint (node, "features_first_32",
7068 clib_net_to_host_u32 (mp->features_first_32));
7069 vat_json_object_add_uint (node, "features_last_32",
7070 clib_net_to_host_u32 (mp->features_last_32));
7071 vat_json_object_add_uint (node, "is_server", mp->is_server);
7072 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
7073 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
7074 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
7078 api_sw_interface_vhost_user_dump (vat_main_t * vam)
7080 unformat_input_t *i = vam->input;
7081 vl_api_sw_interface_vhost_user_dump_t *mp;
7082 vl_api_control_ping_t *mp_ping;
7084 u32 sw_if_index = ~0;
7086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7096 print (vam->ofp, "Interface name idx hdr_sz features "
7097 "server regions filename");
7099 /* Get list of vhost-user interfaces */
7100 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
7101 mp->sw_if_index = ntohl (sw_if_index);
7104 /* Use a control ping for synchronization */
7105 MPING (CONTROL_PING, mp_ping);
7113 api_show_version (vat_main_t * vam)
7115 vl_api_show_version_t *mp;
7118 M (SHOW_VERSION, mp);
7125 static void vl_api_l2_fib_table_details_t_handler
7126 (vl_api_l2_fib_table_details_t * mp)
7128 vat_main_t *vam = &vat_main;
7130 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
7132 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
7133 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
7137 static void vl_api_l2_fib_table_details_t_handler_json
7138 (vl_api_l2_fib_table_details_t * mp)
7140 vat_main_t *vam = &vat_main;
7141 vat_json_node_t *node = NULL;
7143 if (VAT_JSON_ARRAY != vam->json_tree.type)
7145 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7146 vat_json_init_array (&vam->json_tree);
7148 node = vat_json_array_add (&vam->json_tree);
7150 vat_json_init_object (node);
7151 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7152 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
7153 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
7154 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
7155 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
7156 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
7160 api_l2_fib_table_dump (vat_main_t * vam)
7162 unformat_input_t *i = vam->input;
7163 vl_api_l2_fib_table_dump_t *mp;
7164 vl_api_control_ping_t *mp_ping;
7169 /* Parse args required to build the message */
7170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 if (unformat (i, "bd_id %d", &bd_id))
7180 errmsg ("missing bridge domain");
7184 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
7186 /* Get list of l2 fib entries */
7187 M (L2_FIB_TABLE_DUMP, mp);
7189 mp->bd_id = ntohl (bd_id);
7192 /* Use a control ping for synchronization */
7193 MPING (CONTROL_PING, mp_ping);
7202 api_interface_name_renumber (vat_main_t * vam)
7204 unformat_input_t *line_input = vam->input;
7205 vl_api_interface_name_renumber_t *mp;
7206 u32 sw_if_index = ~0;
7207 u32 new_show_dev_instance = ~0;
7210 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
7212 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
7215 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
7217 else if (unformat (line_input, "new_show_dev_instance %d",
7218 &new_show_dev_instance))
7224 if (sw_if_index == ~0)
7226 errmsg ("missing interface name or sw_if_index");
7230 if (new_show_dev_instance == ~0)
7232 errmsg ("missing new_show_dev_instance");
7236 M (INTERFACE_NAME_RENUMBER, mp);
7238 mp->sw_if_index = ntohl (sw_if_index);
7239 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
7247 api_want_l2_macs_events (vat_main_t * vam)
7249 unformat_input_t *line_input = vam->input;
7250 vl_api_want_l2_macs_events_t *mp;
7251 u8 enable_disable = 1;
7253 u32 max_macs_in_event = 0;
7254 u32 learn_limit = 0;
7257 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
7259 if (unformat (line_input, "learn-limit %d", &learn_limit))
7261 else if (unformat (line_input, "scan-delay %d", &scan_delay))
7263 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
7265 else if (unformat (line_input, "disable"))
7271 M (WANT_L2_MACS_EVENTS, mp);
7272 mp->enable_disable = enable_disable;
7273 mp->pid = htonl (getpid ());
7274 mp->learn_limit = htonl (learn_limit);
7275 mp->scan_delay = (u8) scan_delay;
7276 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
7283 api_ip_address_dump (vat_main_t * vam)
7285 unformat_input_t *i = vam->input;
7286 vl_api_ip_address_dump_t *mp;
7287 vl_api_control_ping_t *mp_ping;
7288 u32 sw_if_index = ~0;
7289 u8 sw_if_index_set = 0;
7294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7296 if (unformat (i, "sw_if_index %d", &sw_if_index))
7297 sw_if_index_set = 1;
7299 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7300 sw_if_index_set = 1;
7301 else if (unformat (i, "ipv4"))
7303 else if (unformat (i, "ipv6"))
7309 if (ipv4_set && ipv6_set)
7311 errmsg ("ipv4 and ipv6 flags cannot be both set");
7315 if ((!ipv4_set) && (!ipv6_set))
7317 errmsg ("no ipv4 nor ipv6 flag set");
7321 if (sw_if_index_set == 0)
7323 errmsg ("missing interface name or sw_if_index");
7327 vam->current_sw_if_index = sw_if_index;
7328 vam->is_ipv6 = ipv6_set;
7330 M (IP_ADDRESS_DUMP, mp);
7331 mp->sw_if_index = ntohl (sw_if_index);
7332 mp->is_ipv6 = ipv6_set;
7335 /* Use a control ping for synchronization */
7336 MPING (CONTROL_PING, mp_ping);
7344 api_ip_dump (vat_main_t * vam)
7346 vl_api_ip_dump_t *mp;
7347 vl_api_control_ping_t *mp_ping;
7348 unformat_input_t *in = vam->input;
7355 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
7357 if (unformat (in, "ipv4"))
7359 else if (unformat (in, "ipv6"))
7365 if (ipv4_set && ipv6_set)
7367 errmsg ("ipv4 and ipv6 flags cannot be both set");
7371 if ((!ipv4_set) && (!ipv6_set))
7373 errmsg ("no ipv4 nor ipv6 flag set");
7378 vam->is_ipv6 = is_ipv6;
7381 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
7383 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
7385 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
7388 mp->is_ipv6 = ipv6_set;
7391 /* Use a control ping for synchronization */
7392 MPING (CONTROL_PING, mp_ping);
7400 api_get_first_msg_id (vat_main_t * vam)
7402 vl_api_get_first_msg_id_t *mp;
7403 unformat_input_t *i = vam->input;
7408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7410 if (unformat (i, "client %s", &name))
7418 errmsg ("missing client name");
7423 if (vec_len (name) > 63)
7425 errmsg ("client name too long");
7429 M (GET_FIRST_MSG_ID, mp);
7430 clib_memcpy (mp->name, name, vec_len (name));
7437 api_get_node_graph (vat_main_t * vam)
7439 vl_api_get_node_graph_t *mp;
7442 M (GET_NODE_GRAPH, mp);
7446 /* Wait for the reply */
7452 format_fib_api_path_nh_proto (u8 * s, va_list * args)
7454 vl_api_fib_path_nh_proto_t proto =
7455 va_arg (*args, vl_api_fib_path_nh_proto_t);
7459 case FIB_API_PATH_NH_PROTO_IP4:
7460 s = format (s, "ip4");
7462 case FIB_API_PATH_NH_PROTO_IP6:
7463 s = format (s, "ip6");
7465 case FIB_API_PATH_NH_PROTO_MPLS:
7466 s = format (s, "mpls");
7468 case FIB_API_PATH_NH_PROTO_BIER:
7469 s = format (s, "bier");
7471 case FIB_API_PATH_NH_PROTO_ETHERNET:
7472 s = format (s, "ethernet");
7480 format_vl_api_ip_address_union (u8 * s, va_list * args)
7482 vl_api_address_family_t af = va_arg (*args, int);
7483 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
7488 s = format (s, "%U", format_ip4_address, u->ip4);
7491 s = format (s, "%U", format_ip6_address, u->ip6);
7498 format_vl_api_fib_path_type (u8 * s, va_list * args)
7500 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
7504 case FIB_API_PATH_TYPE_NORMAL:
7505 s = format (s, "normal");
7507 case FIB_API_PATH_TYPE_LOCAL:
7508 s = format (s, "local");
7510 case FIB_API_PATH_TYPE_DROP:
7511 s = format (s, "drop");
7513 case FIB_API_PATH_TYPE_UDP_ENCAP:
7514 s = format (s, "udp-encap");
7516 case FIB_API_PATH_TYPE_BIER_IMP:
7517 s = format (s, "bier-imp");
7519 case FIB_API_PATH_TYPE_ICMP_UNREACH:
7520 s = format (s, "unreach");
7522 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
7523 s = format (s, "prohibit");
7525 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
7526 s = format (s, "src-lookup");
7528 case FIB_API_PATH_TYPE_DVR:
7529 s = format (s, "dvr");
7531 case FIB_API_PATH_TYPE_INTERFACE_RX:
7532 s = format (s, "interface-rx");
7534 case FIB_API_PATH_TYPE_CLASSIFY:
7535 s = format (s, "classify");
7543 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
7546 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
7547 ntohl (fp->weight), ntohl (fp->sw_if_index),
7548 format_vl_api_fib_path_type, fp->type,
7549 format_fib_api_path_nh_proto, fp->proto,
7550 format_vl_api_ip_address_union, &fp->nh.address);
7554 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
7555 vl_api_fib_path_t * fp)
7558 struct in6_addr ip6;
7560 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
7561 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
7562 vat_json_object_add_uint (node, "type", fp->type);
7563 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
7564 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
7566 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
7567 vat_json_object_add_ip4 (node, "next_hop", ip4);
7569 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
7571 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
7572 vat_json_object_add_ip6 (node, "next_hop", ip6);
7577 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
7579 vat_main_t *vam = &vat_main;
7580 int count = ntohl (mp->mt_tunnel.mt_n_paths);
7581 vl_api_fib_path_t *fp;
7584 print (vam->ofp, "sw_if_index %d via:",
7585 ntohl (mp->mt_tunnel.mt_sw_if_index));
7586 fp = mp->mt_tunnel.mt_paths;
7587 for (i = 0; i < count; i++)
7589 vl_api_fib_path_print (vam, fp);
7593 print (vam->ofp, "");
7596 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
7597 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
7600 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
7602 vat_main_t *vam = &vat_main;
7603 vat_json_node_t *node = NULL;
7604 int count = ntohl (mp->mt_tunnel.mt_n_paths);
7605 vl_api_fib_path_t *fp;
7608 if (VAT_JSON_ARRAY != vam->json_tree.type)
7610 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7611 vat_json_init_array (&vam->json_tree);
7613 node = vat_json_array_add (&vam->json_tree);
7615 vat_json_init_object (node);
7616 vat_json_object_add_uint (node, "sw_if_index",
7617 ntohl (mp->mt_tunnel.mt_sw_if_index));
7619 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
7621 fp = mp->mt_tunnel.mt_paths;
7622 for (i = 0; i < count; i++)
7624 vl_api_mpls_fib_path_json_print (node, fp);
7630 api_mpls_tunnel_dump (vat_main_t * vam)
7632 vl_api_mpls_tunnel_dump_t *mp;
7633 vl_api_control_ping_t *mp_ping;
7636 M (MPLS_TUNNEL_DUMP, mp);
7640 /* Use a control ping for synchronization */
7641 MPING (CONTROL_PING, mp_ping);
7648 #define vl_api_mpls_table_details_t_endian vl_noop_handler
7649 #define vl_api_mpls_table_details_t_print vl_noop_handler
7653 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
7655 vat_main_t *vam = &vat_main;
7657 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
7660 static void vl_api_mpls_table_details_t_handler_json
7661 (vl_api_mpls_table_details_t * mp)
7663 vat_main_t *vam = &vat_main;
7664 vat_json_node_t *node = NULL;
7666 if (VAT_JSON_ARRAY != vam->json_tree.type)
7668 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7669 vat_json_init_array (&vam->json_tree);
7671 node = vat_json_array_add (&vam->json_tree);
7673 vat_json_init_object (node);
7674 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
7678 api_mpls_table_dump (vat_main_t * vam)
7680 vl_api_mpls_table_dump_t *mp;
7681 vl_api_control_ping_t *mp_ping;
7684 M (MPLS_TABLE_DUMP, mp);
7687 /* Use a control ping for synchronization */
7688 MPING (CONTROL_PING, mp_ping);
7695 #define vl_api_mpls_route_details_t_endian vl_noop_handler
7696 #define vl_api_mpls_route_details_t_print vl_noop_handler
7699 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
7701 vat_main_t *vam = &vat_main;
7702 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
7703 vl_api_fib_path_t *fp;
7707 "table-id %d, label %u, ess_bit %u",
7708 ntohl (mp->mr_route.mr_table_id),
7709 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
7710 fp = mp->mr_route.mr_paths;
7711 for (i = 0; i < count; i++)
7713 vl_api_fib_path_print (vam, fp);
7718 static void vl_api_mpls_route_details_t_handler_json
7719 (vl_api_mpls_route_details_t * mp)
7721 vat_main_t *vam = &vat_main;
7722 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
7723 vat_json_node_t *node = NULL;
7724 vl_api_fib_path_t *fp;
7727 if (VAT_JSON_ARRAY != vam->json_tree.type)
7729 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7730 vat_json_init_array (&vam->json_tree);
7732 node = vat_json_array_add (&vam->json_tree);
7734 vat_json_init_object (node);
7735 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
7736 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
7737 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
7738 vat_json_object_add_uint (node, "path_count", count);
7739 fp = mp->mr_route.mr_paths;
7740 for (i = 0; i < count; i++)
7742 vl_api_mpls_fib_path_json_print (node, fp);
7748 api_mpls_route_dump (vat_main_t * vam)
7750 unformat_input_t *input = vam->input;
7751 vl_api_mpls_route_dump_t *mp;
7752 vl_api_control_ping_t *mp_ping;
7756 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7758 if (unformat (input, "table_id %d", &table_id))
7765 errmsg ("missing table id");
7769 M (MPLS_ROUTE_DUMP, mp);
7771 mp->table.mt_table_id = ntohl (table_id);
7774 /* Use a control ping for synchronization */
7775 MPING (CONTROL_PING, mp_ping);
7782 #define vl_api_ip_table_details_t_endian vl_noop_handler
7783 #define vl_api_ip_table_details_t_print vl_noop_handler
7786 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
7788 vat_main_t *vam = &vat_main;
7791 "%s; table-id %d, prefix %U/%d",
7792 mp->table.name, ntohl (mp->table.table_id));
7796 static void vl_api_ip_table_details_t_handler_json
7797 (vl_api_ip_table_details_t * mp)
7799 vat_main_t *vam = &vat_main;
7800 vat_json_node_t *node = NULL;
7802 if (VAT_JSON_ARRAY != vam->json_tree.type)
7804 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7805 vat_json_init_array (&vam->json_tree);
7807 node = vat_json_array_add (&vam->json_tree);
7809 vat_json_init_object (node);
7810 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
7814 api_ip_table_dump (vat_main_t * vam)
7816 vl_api_ip_table_dump_t *mp;
7817 vl_api_control_ping_t *mp_ping;
7820 M (IP_TABLE_DUMP, mp);
7823 /* Use a control ping for synchronization */
7824 MPING (CONTROL_PING, mp_ping);
7832 api_ip_mtable_dump (vat_main_t * vam)
7834 vl_api_ip_mtable_dump_t *mp;
7835 vl_api_control_ping_t *mp_ping;
7838 M (IP_MTABLE_DUMP, mp);
7841 /* Use a control ping for synchronization */
7842 MPING (CONTROL_PING, mp_ping);
7850 api_ip_mroute_dump (vat_main_t * vam)
7852 unformat_input_t *input = vam->input;
7853 vl_api_control_ping_t *mp_ping;
7854 vl_api_ip_mroute_dump_t *mp;
7859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7861 if (unformat (input, "table_id %d", &table_id))
7863 else if (unformat (input, "ip6"))
7865 else if (unformat (input, "ip4"))
7872 errmsg ("missing table id");
7876 M (IP_MROUTE_DUMP, mp);
7877 mp->table.table_id = table_id;
7878 mp->table.is_ip6 = is_ip6;
7881 /* Use a control ping for synchronization */
7882 MPING (CONTROL_PING, mp_ping);
7889 #define vl_api_ip_route_details_t_endian vl_noop_handler
7890 #define vl_api_ip_route_details_t_print vl_noop_handler
7893 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
7895 vat_main_t *vam = &vat_main;
7896 u8 count = mp->route.n_paths;
7897 vl_api_fib_path_t *fp;
7901 "table-id %d, prefix %U/%d",
7902 ntohl (mp->route.table_id),
7903 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
7904 for (i = 0; i < count; i++)
7906 fp = &mp->route.paths[i];
7908 vl_api_fib_path_print (vam, fp);
7913 static void vl_api_ip_route_details_t_handler_json
7914 (vl_api_ip_route_details_t * mp)
7916 vat_main_t *vam = &vat_main;
7917 u8 count = mp->route.n_paths;
7918 vat_json_node_t *node = NULL;
7920 struct in6_addr ip6;
7921 vl_api_fib_path_t *fp;
7924 if (VAT_JSON_ARRAY != vam->json_tree.type)
7926 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7927 vat_json_init_array (&vam->json_tree);
7929 node = vat_json_array_add (&vam->json_tree);
7931 vat_json_init_object (node);
7932 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
7933 if (ADDRESS_IP6 == mp->route.prefix.address.af)
7935 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
7936 vat_json_object_add_ip6 (node, "prefix", ip6);
7940 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
7941 vat_json_object_add_ip4 (node, "prefix", ip4);
7943 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
7944 vat_json_object_add_uint (node, "path_count", count);
7945 for (i = 0; i < count; i++)
7947 fp = &mp->route.paths[i];
7948 vl_api_mpls_fib_path_json_print (node, fp);
7953 api_ip_route_dump (vat_main_t * vam)
7955 unformat_input_t *input = vam->input;
7956 vl_api_ip_route_dump_t *mp;
7957 vl_api_control_ping_t *mp_ping;
7963 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7965 if (unformat (input, "table_id %d", &table_id))
7967 else if (unformat (input, "ip6"))
7969 else if (unformat (input, "ip4"))
7976 errmsg ("missing table id");
7980 M (IP_ROUTE_DUMP, mp);
7982 mp->table.table_id = table_id;
7983 mp->table.is_ip6 = is_ip6;
7987 /* Use a control ping for synchronization */
7988 MPING (CONTROL_PING, mp_ping);
7996 api_sw_interface_span_enable_disable (vat_main_t * vam)
7998 unformat_input_t *i = vam->input;
7999 vl_api_sw_interface_span_enable_disable_t *mp;
8000 u32 src_sw_if_index = ~0;
8001 u32 dst_sw_if_index = ~0;
8006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8009 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
8011 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
8015 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
8017 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
8019 else if (unformat (i, "disable"))
8021 else if (unformat (i, "rx"))
8023 else if (unformat (i, "tx"))
8025 else if (unformat (i, "both"))
8027 else if (unformat (i, "l2"))
8033 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
8035 mp->sw_if_index_from = htonl (src_sw_if_index);
8036 mp->sw_if_index_to = htonl (dst_sw_if_index);
8046 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
8049 vat_main_t *vam = &vat_main;
8050 u8 *sw_if_from_name = 0;
8051 u8 *sw_if_to_name = 0;
8052 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
8053 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
8054 char *states[] = { "none", "rx", "tx", "both" };
8058 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
8060 if ((u32) p->value[0] == sw_if_index_from)
8062 sw_if_from_name = (u8 *)(p->key);
8066 if ((u32) p->value[0] == sw_if_index_to)
8068 sw_if_to_name = (u8 *)(p->key);
8069 if (sw_if_from_name)
8074 print (vam->ofp, "%20s => %20s (%s) %s",
8075 sw_if_from_name, sw_if_to_name, states[mp->state],
8076 mp->is_l2 ? "l2" : "device");
8080 vl_api_sw_interface_span_details_t_handler_json
8081 (vl_api_sw_interface_span_details_t * mp)
8083 vat_main_t *vam = &vat_main;
8084 vat_json_node_t *node = NULL;
8085 u8 *sw_if_from_name = 0;
8086 u8 *sw_if_to_name = 0;
8087 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
8088 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
8092 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
8094 if ((u32) p->value[0] == sw_if_index_from)
8096 sw_if_from_name = (u8 *)(p->key);
8100 if ((u32) p->value[0] == sw_if_index_to)
8102 sw_if_to_name = (u8 *)(p->key);
8103 if (sw_if_from_name)
8109 if (VAT_JSON_ARRAY != vam->json_tree.type)
8111 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8112 vat_json_init_array (&vam->json_tree);
8114 node = vat_json_array_add (&vam->json_tree);
8116 vat_json_init_object (node);
8117 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
8118 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
8119 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
8120 if (0 != sw_if_to_name)
8122 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
8124 vat_json_object_add_uint (node, "state", mp->state);
8125 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
8129 api_sw_interface_span_dump (vat_main_t * vam)
8131 unformat_input_t *input = vam->input;
8132 vl_api_sw_interface_span_dump_t *mp;
8133 vl_api_control_ping_t *mp_ping;
8137 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8139 if (unformat (input, "l2"))
8145 M (SW_INTERFACE_SPAN_DUMP, mp);
8149 /* Use a control ping for synchronization */
8150 MPING (CONTROL_PING, mp_ping);
8158 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
8160 unformat_input_t *input = vam->input;
8161 vl_api_ip_source_and_port_range_check_add_del_t *mp;
8164 u16 *high_ports = 0;
8167 vl_api_prefix_t prefix;
8174 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8176 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
8178 else if (unformat (input, "vrf %d", &vrf_id))
8180 else if (unformat (input, "del"))
8182 else if (unformat (input, "port %d", &tmp))
8184 if (tmp == 0 || tmp > 65535)
8186 errmsg ("port %d out of range", tmp);
8190 this_hi = this_low + 1;
8191 vec_add1 (low_ports, this_low);
8192 vec_add1 (high_ports, this_hi);
8194 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
8196 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
8198 errmsg ("incorrect range parameters");
8202 /* Note: in debug CLI +1 is added to high before
8203 passing to real fn that does "the work"
8204 (ip_source_and_port_range_check_add_del).
8205 This fn is a wrapper around the binary API fn a
8206 control plane will call, which expects this increment
8207 to have occurred. Hence letting the binary API control
8208 plane fn do the increment for consistency between VAT
8209 and other control planes.
8212 vec_add1 (low_ports, this_low);
8213 vec_add1 (high_ports, this_hi);
8219 if (prefix_set == 0)
8221 errmsg ("<address>/<mask> not specified");
8227 errmsg ("VRF ID required, not specified");
8234 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
8238 if (vec_len (low_ports) == 0)
8240 errmsg ("At least one port or port range required");
8244 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
8246 mp->is_add = is_add;
8248 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
8250 mp->number_of_ranges = vec_len (low_ports);
8252 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
8253 vec_free (low_ports);
8255 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
8256 vec_free (high_ports);
8258 mp->vrf_id = ntohl (vrf_id);
8266 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
8268 unformat_input_t *input = vam->input;
8269 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
8270 u32 sw_if_index = ~0;
8272 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
8273 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
8277 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8279 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8281 else if (unformat (input, "sw_if_index %d", &sw_if_index))
8283 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
8285 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
8287 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
8289 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
8291 else if (unformat (input, "del"))
8297 if (sw_if_index == ~0)
8299 errmsg ("Interface required but not specified");
8305 errmsg ("VRF ID required but not specified");
8309 if (tcp_out_vrf_id == 0
8310 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
8313 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
8317 /* Construct the API message */
8318 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
8320 mp->sw_if_index = ntohl (sw_if_index);
8321 mp->is_add = is_add;
8322 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
8323 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
8324 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
8325 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
8330 /* Wait for a reply... */
8336 api_set_punt (vat_main_t * vam)
8338 unformat_input_t *i = vam->input;
8339 vl_api_address_family_t af;
8340 vl_api_set_punt_t *mp;
8346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8348 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
8350 else if (unformat (i, "protocol %d", &protocol))
8352 else if (unformat (i, "port %d", &port))
8354 else if (unformat (i, "del"))
8358 clib_warning ("parse error '%U'", format_unformat_error, i);
8365 mp->is_add = (u8) is_add;
8366 mp->punt.type = PUNT_API_TYPE_L4;
8367 mp->punt.punt.l4.af = af;
8368 mp->punt.punt.l4.protocol = (u8) protocol;
8369 mp->punt.punt.l4.port = htons ((u16) port);
8377 api_delete_subif (vat_main_t * vam)
8379 unformat_input_t *i = vam->input;
8380 vl_api_delete_subif_t *mp;
8381 u32 sw_if_index = ~0;
8384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8386 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8388 if (unformat (i, "sw_if_index %d", &sw_if_index))
8394 if (sw_if_index == ~0)
8396 errmsg ("missing sw_if_index");
8400 /* Construct the API message */
8401 M (DELETE_SUBIF, mp);
8402 mp->sw_if_index = ntohl (sw_if_index);
8409 #define foreach_pbb_vtr_op \
8410 _("disable", L2_VTR_DISABLED) \
8411 _("pop", L2_VTR_POP_2) \
8412 _("push", L2_VTR_PUSH_2)
8415 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
8417 unformat_input_t *i = vam->input;
8418 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
8419 u32 sw_if_index = ~0, vtr_op = ~0;
8421 u8 dmac[6], smac[6];
8422 u8 dmac_set = 0, smac_set = 0;
8428 /* Shut up coverity */
8429 clib_memset (dmac, 0, sizeof (dmac));
8430 clib_memset (smac, 0, sizeof (smac));
8432 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8434 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8436 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8438 else if (unformat (i, "vtr_op %d", &vtr_op))
8440 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
8443 else if (unformat (i, "translate_pbb_stag"))
8445 if (unformat (i, "%d", &tmp))
8447 vtr_op = L2_VTR_TRANSLATE_2_1;
8453 ("translate_pbb_stag operation requires outer tag definition");
8457 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
8459 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
8461 else if (unformat (i, "sid %d", &sid))
8463 else if (unformat (i, "vlanid %d", &tmp))
8467 clib_warning ("parse error '%U'", format_unformat_error, i);
8472 if ((sw_if_index == ~0) || (vtr_op == ~0))
8474 errmsg ("missing sw_if_index or vtr operation");
8477 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
8478 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
8481 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
8485 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
8486 mp->sw_if_index = ntohl (sw_if_index);
8487 mp->vtr_op = ntohl (vtr_op);
8488 mp->outer_tag = ntohs (outer_tag);
8489 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
8490 clib_memcpy (mp->b_smac, smac, sizeof (smac));
8491 mp->b_vlanid = ntohs (vlanid);
8492 mp->i_sid = ntohl (sid);
8500 api_sw_interface_tag_add_del (vat_main_t * vam)
8502 unformat_input_t *i = vam->input;
8503 vl_api_sw_interface_tag_add_del_t *mp;
8504 u32 sw_if_index = ~0;
8509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8511 if (unformat (i, "tag %s", &tag))
8513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8515 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8517 else if (unformat (i, "del"))
8523 if (sw_if_index == ~0)
8525 errmsg ("missing interface name or sw_if_index");
8529 if (enable && (tag == 0))
8531 errmsg ("no tag specified");
8535 /* Construct the API message */
8536 M (SW_INTERFACE_TAG_ADD_DEL, mp);
8537 mp->sw_if_index = ntohl (sw_if_index);
8538 mp->is_add = enable;
8540 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
8549 api_sw_interface_add_del_mac_address (vat_main_t * vam)
8551 unformat_input_t *i = vam->input;
8552 vl_api_mac_address_t mac = { 0 };
8553 vl_api_sw_interface_add_del_mac_address_t *mp;
8554 u32 sw_if_index = ~0;
8559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8561 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8563 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8565 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
8567 else if (unformat (i, "del"))
8573 if (sw_if_index == ~0)
8575 errmsg ("missing interface name or sw_if_index");
8581 errmsg ("missing MAC address");
8585 /* Construct the API message */
8586 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
8587 mp->sw_if_index = ntohl (sw_if_index);
8588 mp->is_add = is_add;
8589 clib_memcpy (&mp->addr, &mac, sizeof (mac));
8596 static void vl_api_l2_xconnect_details_t_handler
8597 (vl_api_l2_xconnect_details_t * mp)
8599 vat_main_t *vam = &vat_main;
8601 print (vam->ofp, "%15d%15d",
8602 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
8605 static void vl_api_l2_xconnect_details_t_handler_json
8606 (vl_api_l2_xconnect_details_t * mp)
8608 vat_main_t *vam = &vat_main;
8609 vat_json_node_t *node = NULL;
8611 if (VAT_JSON_ARRAY != vam->json_tree.type)
8613 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8614 vat_json_init_array (&vam->json_tree);
8616 node = vat_json_array_add (&vam->json_tree);
8618 vat_json_init_object (node);
8619 vat_json_object_add_uint (node, "rx_sw_if_index",
8620 ntohl (mp->rx_sw_if_index));
8621 vat_json_object_add_uint (node, "tx_sw_if_index",
8622 ntohl (mp->tx_sw_if_index));
8626 api_l2_xconnect_dump (vat_main_t * vam)
8628 vl_api_l2_xconnect_dump_t *mp;
8629 vl_api_control_ping_t *mp_ping;
8632 if (!vam->json_output)
8634 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
8637 M (L2_XCONNECT_DUMP, mp);
8641 /* Use a control ping for synchronization */
8642 MPING (CONTROL_PING, mp_ping);
8650 api_hw_interface_set_mtu (vat_main_t * vam)
8652 unformat_input_t *i = vam->input;
8653 vl_api_hw_interface_set_mtu_t *mp;
8654 u32 sw_if_index = ~0;
8658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8660 if (unformat (i, "mtu %d", &mtu))
8662 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8664 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8670 if (sw_if_index == ~0)
8672 errmsg ("missing interface name or sw_if_index");
8678 errmsg ("no mtu specified");
8682 /* Construct the API message */
8683 M (HW_INTERFACE_SET_MTU, mp);
8684 mp->sw_if_index = ntohl (sw_if_index);
8685 mp->mtu = ntohs ((u16) mtu);
8693 api_tcp_configure_src_addresses (vat_main_t * vam)
8695 vl_api_tcp_configure_src_addresses_t *mp;
8696 unformat_input_t *i = vam->input;
8697 vl_api_address_t first, last;
8702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8704 if (unformat (i, "%U - %U",
8705 unformat_vl_api_address, &first,
8706 unformat_vl_api_address, &last))
8710 errmsg ("one range per message (range already set)");
8715 else if (unformat (i, "vrf %d", &vrf_id))
8723 errmsg ("address range not set");
8727 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
8729 mp->vrf_id = ntohl (vrf_id);
8730 clib_memcpy (&mp->first_address, &first, sizeof (first));
8731 clib_memcpy (&mp->last_address, &last, sizeof (last));
8738 static void vl_api_app_namespace_add_del_reply_t_handler
8739 (vl_api_app_namespace_add_del_reply_t * mp)
8741 vat_main_t *vam = &vat_main;
8742 i32 retval = ntohl (mp->retval);
8743 if (vam->async_mode)
8745 vam->async_errors += (retval < 0);
8749 vam->retval = retval;
8751 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
8752 vam->result_ready = 1;
8756 static void vl_api_app_namespace_add_del_reply_t_handler_json
8757 (vl_api_app_namespace_add_del_reply_t * mp)
8759 vat_main_t *vam = &vat_main;
8760 vat_json_node_t node;
8762 vat_json_init_object (&node);
8763 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
8764 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
8766 vat_json_print (vam->ofp, &node);
8767 vat_json_free (&node);
8769 vam->retval = ntohl (mp->retval);
8770 vam->result_ready = 1;
8774 api_app_namespace_add_del (vat_main_t * vam)
8776 vl_api_app_namespace_add_del_t *mp;
8777 unformat_input_t *i = vam->input;
8778 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
8779 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
8783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8785 if (unformat (i, "id %_%v%_", &ns_id))
8787 else if (unformat (i, "secret %lu", &secret))
8789 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8790 sw_if_index_set = 1;
8791 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
8793 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
8798 if (!ns_id || !secret_set || !sw_if_index_set)
8800 errmsg ("namespace id, secret and sw_if_index must be set");
8803 if (vec_len (ns_id) > 64)
8805 errmsg ("namespace id too long");
8808 M (APP_NAMESPACE_ADD_DEL, mp);
8810 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
8811 mp->secret = clib_host_to_net_u64 (secret);
8812 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
8813 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
8814 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
8822 api_sock_init_shm (vat_main_t * vam)
8824 #if VPP_API_TEST_BUILTIN == 0
8825 unformat_input_t *i = vam->input;
8826 vl_api_shm_elem_config_t *config = 0;
8827 u64 size = 64 << 20;
8830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8832 if (unformat (i, "size %U", unformat_memory_size, &size))
8839 * Canned custom ring allocator config.
8840 * Should probably parse all of this
8842 vec_validate (config, 6);
8843 config[0].type = VL_API_VLIB_RING;
8844 config[0].size = 256;
8845 config[0].count = 32;
8847 config[1].type = VL_API_VLIB_RING;
8848 config[1].size = 1024;
8849 config[1].count = 16;
8851 config[2].type = VL_API_VLIB_RING;
8852 config[2].size = 4096;
8853 config[2].count = 2;
8855 config[3].type = VL_API_CLIENT_RING;
8856 config[3].size = 256;
8857 config[3].count = 32;
8859 config[4].type = VL_API_CLIENT_RING;
8860 config[4].size = 1024;
8861 config[4].count = 16;
8863 config[5].type = VL_API_CLIENT_RING;
8864 config[5].size = 4096;
8865 config[5].count = 2;
8867 config[6].type = VL_API_QUEUE;
8868 config[6].count = 128;
8869 config[6].size = sizeof (uword);
8871 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
8873 vam->client_index_invalid = 1;
8881 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
8883 vat_main_t *vam = &vat_main;
8884 fib_prefix_t lcl, rmt;
8886 ip_prefix_decode (&mp->lcl, &lcl);
8887 ip_prefix_decode (&mp->rmt, &rmt);
8889 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
8892 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
8893 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
8894 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
8895 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
8896 &rmt.fp_addr.ip4, rmt.fp_len,
8897 clib_net_to_host_u16 (mp->rmt_port),
8898 clib_net_to_host_u32 (mp->action_index), mp->tag);
8903 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
8904 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
8905 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
8906 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
8907 &rmt.fp_addr.ip6, rmt.fp_len,
8908 clib_net_to_host_u16 (mp->rmt_port),
8909 clib_net_to_host_u32 (mp->action_index), mp->tag);
8914 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
8917 vat_main_t *vam = &vat_main;
8918 vat_json_node_t *node = NULL;
8919 struct in6_addr ip6;
8922 fib_prefix_t lcl, rmt;
8924 ip_prefix_decode (&mp->lcl, &lcl);
8925 ip_prefix_decode (&mp->rmt, &rmt);
8927 if (VAT_JSON_ARRAY != vam->json_tree.type)
8929 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8930 vat_json_init_array (&vam->json_tree);
8932 node = vat_json_array_add (&vam->json_tree);
8933 vat_json_init_object (node);
8935 vat_json_object_add_uint (node, "appns_index",
8936 clib_net_to_host_u32 (mp->appns_index));
8937 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
8938 vat_json_object_add_uint (node, "scope", mp->scope);
8939 vat_json_object_add_uint (node, "action_index",
8940 clib_net_to_host_u32 (mp->action_index));
8941 vat_json_object_add_uint (node, "lcl_port",
8942 clib_net_to_host_u16 (mp->lcl_port));
8943 vat_json_object_add_uint (node, "rmt_port",
8944 clib_net_to_host_u16 (mp->rmt_port));
8945 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
8946 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
8947 vat_json_object_add_string_copy (node, "tag", mp->tag);
8948 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
8950 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
8951 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
8952 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
8953 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
8957 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
8958 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
8959 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
8960 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
8965 api_session_rule_add_del (vat_main_t * vam)
8967 vl_api_session_rule_add_del_t *mp;
8968 unformat_input_t *i = vam->input;
8969 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
8970 u32 appns_index = 0, scope = 0;
8971 ip4_address_t lcl_ip4, rmt_ip4;
8972 ip6_address_t lcl_ip6, rmt_ip6;
8973 u8 is_ip4 = 1, conn_set = 0;
8974 u8 is_add = 1, *tag = 0;
8976 fib_prefix_t lcl, rmt;
8978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8980 if (unformat (i, "del"))
8982 else if (unformat (i, "add"))
8984 else if (unformat (i, "proto tcp"))
8986 else if (unformat (i, "proto udp"))
8988 else if (unformat (i, "appns %d", &appns_index))
8990 else if (unformat (i, "scope %d", &scope))
8992 else if (unformat (i, "tag %_%v%_", &tag))
8996 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
8997 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
9005 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
9006 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
9012 else if (unformat (i, "action %d", &action))
9017 if (proto == ~0 || !conn_set || action == ~0)
9019 errmsg ("transport proto, connection and action must be set");
9025 errmsg ("scope should be 0-3");
9029 M (SESSION_RULE_ADD_DEL, mp);
9031 clib_memset (&lcl, 0, sizeof (lcl));
9032 clib_memset (&rmt, 0, sizeof (rmt));
9035 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
9036 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
9037 lcl.fp_len = lcl_plen;
9038 rmt.fp_len = rmt_plen;
9042 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
9043 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
9044 lcl.fp_len = lcl_plen;
9045 rmt.fp_len = rmt_plen;
9049 ip_prefix_encode (&lcl, &mp->lcl);
9050 ip_prefix_encode (&rmt, &mp->rmt);
9051 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
9052 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
9053 mp->transport_proto =
9054 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
9055 mp->action_index = clib_host_to_net_u32 (action);
9056 mp->appns_index = clib_host_to_net_u32 (appns_index);
9058 mp->is_add = is_add;
9061 clib_memcpy (mp->tag, tag, vec_len (tag));
9071 api_session_rules_dump (vat_main_t * vam)
9073 vl_api_session_rules_dump_t *mp;
9074 vl_api_control_ping_t *mp_ping;
9077 if (!vam->json_output)
9079 print (vam->ofp, "%=20s", "Session Rules");
9082 M (SESSION_RULES_DUMP, mp);
9086 /* Use a control ping for synchronization */
9087 MPING (CONTROL_PING, mp_ping);
9090 /* Wait for a reply... */
9096 api_ip_container_proxy_add_del (vat_main_t * vam)
9098 vl_api_ip_container_proxy_add_del_t *mp;
9099 unformat_input_t *i = vam->input;
9100 u32 sw_if_index = ~0;
9101 vl_api_prefix_t pfx = { };
9105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9107 if (unformat (i, "del"))
9109 else if (unformat (i, "add"))
9111 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9113 else if (unformat (i, "sw_if_index %u", &sw_if_index))
9118 if (sw_if_index == ~0 || pfx.len == 0)
9120 errmsg ("address and sw_if_index must be set");
9124 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
9126 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
9127 mp->is_add = is_add;
9128 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
9136 q_or_quit (vat_main_t * vam)
9138 #if VPP_API_TEST_BUILTIN == 0
9139 longjmp (vam->jump_buf, 1);
9141 return 0; /* not so much */
9145 q (vat_main_t * vam)
9147 return q_or_quit (vam);
9151 quit (vat_main_t * vam)
9153 return q_or_quit (vam);
9157 comment (vat_main_t * vam)
9163 elog_save (vat_main_t * vam)
9165 #if VPP_API_TEST_BUILTIN == 0
9166 elog_main_t *em = &vam->elog_main;
9167 unformat_input_t *i = vam->input;
9168 char *file, *chroot_file;
9169 clib_error_t *error;
9171 if (!unformat (i, "%s", &file))
9173 errmsg ("expected file name, got `%U'", format_unformat_error, i);
9177 /* It's fairly hard to get "../oopsie" through unformat; just in case */
9178 if (strstr (file, "..") || index (file, '/'))
9180 errmsg ("illegal characters in filename '%s'", file);
9184 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
9188 errmsg ("Saving %wd of %wd events to %s",
9189 elog_n_events_in_buffer (em),
9190 elog_buffer_capacity (em), chroot_file);
9192 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
9193 vec_free (chroot_file);
9196 clib_error_report (error);
9198 errmsg ("Use the vpp event loger...");
9205 elog_setup (vat_main_t * vam)
9207 #if VPP_API_TEST_BUILTIN == 0
9208 elog_main_t *em = &vam->elog_main;
9209 unformat_input_t *i = vam->input;
9210 u32 nevents = 128 << 10;
9212 (void) unformat (i, "nevents %d", &nevents);
9214 elog_init (em, nevents);
9215 vl_api_set_elog_main (em);
9216 vl_api_set_elog_trace_api_messages (1);
9217 errmsg ("Event logger initialized with %u events", nevents);
9219 errmsg ("Use the vpp event loger...");
9225 elog_enable (vat_main_t * vam)
9227 #if VPP_API_TEST_BUILTIN == 0
9228 elog_main_t *em = &vam->elog_main;
9230 elog_enable_disable (em, 1 /* enable */ );
9231 vl_api_set_elog_trace_api_messages (1);
9232 errmsg ("Event logger enabled...");
9234 errmsg ("Use the vpp event loger...");
9240 elog_disable (vat_main_t * vam)
9242 #if VPP_API_TEST_BUILTIN == 0
9243 elog_main_t *em = &vam->elog_main;
9245 elog_enable_disable (em, 0 /* enable */ );
9246 vl_api_set_elog_trace_api_messages (1);
9247 errmsg ("Event logger disabled...");
9249 errmsg ("Use the vpp event loger...");
9255 statseg (vat_main_t * vam)
9257 ssvm_private_t *ssvmp = &vam->stat_segment;
9258 ssvm_shared_header_t *shared_header = ssvmp->sh;
9259 vlib_counter_t **counters;
9260 u64 thread0_index1_packets;
9261 u64 thread0_index1_bytes;
9262 f64 vector_rate, input_rate;
9265 uword *counter_vector_by_name;
9266 if (vam->stat_segment_lockp == 0)
9268 errmsg ("Stat segment not mapped...");
9272 /* look up "/if/rx for sw_if_index 1 as a test */
9274 clib_spinlock_lock (vam->stat_segment_lockp);
9276 counter_vector_by_name = (uword *) shared_header->opaque[1];
9278 p = hash_get_mem (counter_vector_by_name, "/if/rx");
9281 clib_spinlock_unlock (vam->stat_segment_lockp);
9282 errmsg ("/if/tx not found?");
9286 /* Fish per-thread vector of combined counters from shared memory */
9287 counters = (vlib_counter_t **) p[0];
9289 if (vec_len (counters[0]) < 2)
9291 clib_spinlock_unlock (vam->stat_segment_lockp);
9292 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
9296 /* Read thread 0 sw_if_index 1 counter */
9297 thread0_index1_packets = counters[0][1].packets;
9298 thread0_index1_bytes = counters[0][1].bytes;
9300 p = hash_get_mem (counter_vector_by_name, "vector_rate");
9303 clib_spinlock_unlock (vam->stat_segment_lockp);
9304 errmsg ("vector_rate not found?");
9308 vector_rate = *(f64 *) (p[0]);
9309 p = hash_get_mem (counter_vector_by_name, "input_rate");
9312 clib_spinlock_unlock (vam->stat_segment_lockp);
9313 errmsg ("input_rate not found?");
9316 input_rate = *(f64 *) (p[0]);
9318 clib_spinlock_unlock (vam->stat_segment_lockp);
9320 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
9321 vector_rate, input_rate);
9322 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
9323 thread0_index1_packets, thread0_index1_bytes);
9329 cmd_cmp (void *a1, void *a2)
9334 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
9338 help (vat_main_t * vam)
9343 unformat_input_t *i = vam->input;
9346 if (unformat (i, "%s", &name))
9352 hs = hash_get_mem (vam->help_by_name, name);
9354 print (vam->ofp, "usage: %s %s", name, hs[0]);
9356 print (vam->ofp, "No such msg / command '%s'", name);
9361 print (vam->ofp, "Help is available for the following:");
9364 hash_foreach_pair (p, vam->function_by_name,
9366 vec_add1 (cmds, (u8 *)(p->key));
9370 vec_sort_with_function (cmds, cmd_cmp);
9372 for (j = 0; j < vec_len (cmds); j++)
9373 print (vam->ofp, "%s", cmds[j]);
9380 set (vat_main_t * vam)
9382 u8 *name = 0, *value = 0;
9383 unformat_input_t *i = vam->input;
9385 if (unformat (i, "%s", &name))
9387 /* The input buffer is a vector, not a string. */
9388 value = vec_dup (i->buffer);
9389 vec_delete (value, i->index, 0);
9390 /* Almost certainly has a trailing newline */
9391 if (value[vec_len (value) - 1] == '\n')
9392 value[vec_len (value) - 1] = 0;
9393 /* Make sure it's a proper string, one way or the other */
9394 vec_add1 (value, 0);
9395 (void) clib_macro_set_value (&vam->macro_main,
9396 (char *) name, (char *) value);
9399 errmsg ("usage: set <name> <value>");
9407 unset (vat_main_t * vam)
9411 if (unformat (vam->input, "%s", &name))
9412 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
9413 errmsg ("unset: %s wasn't set", name);
9426 macro_sort_cmp (void *a1, void *a2)
9428 macro_sort_t *s1 = a1;
9429 macro_sort_t *s2 = a2;
9431 return strcmp ((char *) (s1->name), (char *) (s2->name));
9435 dump_macro_table (vat_main_t * vam)
9437 macro_sort_t *sort_me = 0, *sm;
9442 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
9444 vec_add2 (sort_me, sm, 1);
9445 sm->name = (u8 *)(p->key);
9446 sm->value = (u8 *) (p->value[0]);
9450 vec_sort_with_function (sort_me, macro_sort_cmp);
9452 if (vec_len (sort_me))
9453 print (vam->ofp, "%-15s%s", "Name", "Value");
9455 print (vam->ofp, "The macro table is empty...");
9457 for (i = 0; i < vec_len (sort_me); i++)
9458 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
9463 dump_node_table (vat_main_t * vam)
9466 vlib_node_t *node, *next_node;
9468 if (vec_len (vam->graph_nodes) == 0)
9470 print (vam->ofp, "Node table empty, issue get_node_graph...");
9474 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
9476 node = vam->graph_nodes[0][i];
9477 print (vam->ofp, "[%d] %s", i, node->name);
9478 for (j = 0; j < vec_len (node->next_nodes); j++)
9480 if (node->next_nodes[j] != ~0)
9482 next_node = vam->graph_nodes[0][node->next_nodes[j]];
9483 print (vam->ofp, " [%d] %s", j, next_node->name);
9491 value_sort_cmp (void *a1, void *a2)
9493 name_sort_t *n1 = a1;
9494 name_sort_t *n2 = a2;
9496 if (n1->value < n2->value)
9498 if (n1->value > n2->value)
9505 dump_msg_api_table (vat_main_t * vam)
9507 api_main_t *am = vlibapi_get_main ();
9508 name_sort_t *nses = 0, *ns;
9513 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
9515 vec_add2 (nses, ns, 1);
9516 ns->name = (u8 *)(hp->key);
9517 ns->value = (u32) hp->value[0];
9521 vec_sort_with_function (nses, value_sort_cmp);
9523 for (i = 0; i < vec_len (nses); i++)
9524 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
9530 get_msg_id (vat_main_t * vam)
9535 if (unformat (vam->input, "%s", &name_and_crc))
9537 message_index = vl_msg_api_get_msg_index (name_and_crc);
9538 if (message_index == ~0)
9540 print (vam->ofp, " '%s' not found", name_and_crc);
9543 print (vam->ofp, " '%s' has message index %d",
9544 name_and_crc, message_index);
9547 errmsg ("name_and_crc required...");
9552 search_node_table (vat_main_t * vam)
9554 unformat_input_t *line_input = vam->input;
9557 vlib_node_t *node, *next_node;
9560 if (vam->graph_node_index_by_name == 0)
9562 print (vam->ofp, "Node table empty, issue get_node_graph...");
9566 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9568 if (unformat (line_input, "%s", &node_to_find))
9570 vec_add1 (node_to_find, 0);
9571 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
9574 print (vam->ofp, "%s not found...", node_to_find);
9577 node = vam->graph_nodes[0][p[0]];
9578 print (vam->ofp, "[%d] %s", p[0], node->name);
9579 for (j = 0; j < vec_len (node->next_nodes); j++)
9581 if (node->next_nodes[j] != ~0)
9583 next_node = vam->graph_nodes[0][node->next_nodes[j]];
9584 print (vam->ofp, " [%d] %s", j, next_node->name);
9591 clib_warning ("parse error '%U'", format_unformat_error,
9597 vec_free (node_to_find);
9606 script (vat_main_t * vam)
9608 #if (VPP_API_TEST_BUILTIN==0)
9610 char *save_current_file;
9611 unformat_input_t save_input;
9612 jmp_buf save_jump_buf;
9613 u32 save_line_number;
9615 FILE *new_fp, *save_ifp;
9617 if (unformat (vam->input, "%s", &s))
9619 new_fp = fopen ((char *) s, "r");
9622 errmsg ("Couldn't open script file %s", s);
9629 errmsg ("Missing script name");
9633 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
9634 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
9635 save_ifp = vam->ifp;
9636 save_line_number = vam->input_line_number;
9637 save_current_file = (char *) vam->current_file;
9639 vam->input_line_number = 0;
9641 vam->current_file = s;
9644 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
9645 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
9646 vam->ifp = save_ifp;
9647 vam->input_line_number = save_line_number;
9648 vam->current_file = (u8 *) save_current_file;
9653 clib_warning ("use the exec command...");
9659 echo (vat_main_t * vam)
9661 print (vam->ofp, "%v", vam->input->buffer);
9665 /* List of API message constructors, CLI names map to api_xxx */
9666 #define foreach_vpe_api_msg \
9667 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
9668 _(sw_interface_dump,"") \
9669 _(sw_interface_set_flags, \
9670 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
9671 _(sw_interface_add_del_address, \
9672 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
9673 _(sw_interface_set_rx_mode, \
9674 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
9675 _(sw_interface_set_rx_placement, \
9676 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
9677 _(sw_interface_rx_placement_dump, \
9678 "[<intfc> | sw_if_index <id>]") \
9679 _(sw_interface_set_table, \
9680 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
9681 _(sw_interface_set_mpls_enable, \
9682 "<intfc> | sw_if_index [disable | dis]") \
9683 _(sw_interface_set_vpath, \
9684 "<intfc> | sw_if_index <id> enable | disable") \
9685 _(sw_interface_set_l2_xconnect, \
9686 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
9687 "enable | disable") \
9688 _(sw_interface_set_l2_bridge, \
9689 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
9690 "[shg <split-horizon-group>] [bvi]\n" \
9691 "enable | disable") \
9692 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
9693 _(bridge_domain_add_del, \
9694 "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") \
9695 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
9697 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
9698 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
9699 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
9701 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
9703 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
9704 _(virtio_pci_create_v2, \
9705 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled [gro-coalesce] | csum-offload-enabled] [packed] [in-order] [buffering]") \
9706 _(virtio_pci_delete, \
9707 "<vpp-if-name> | sw_if_index <id>") \
9708 _(sw_interface_virtio_pci_dump, "") \
9709 _(ip_table_add_del, \
9710 "table <n> [ipv6] [add | del]\n") \
9711 _(ip_route_add_del, \
9712 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
9713 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
9714 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
9715 "[multipath] [count <n>] [del]") \
9716 _(ip_mroute_add_del, \
9717 "<src> <grp>/<mask> [table-id <n>]\n" \
9718 "[<intfc> | sw_if_index <id>] [local] [del]") \
9719 _(mpls_table_add_del, \
9720 "table <n> [add | del]\n") \
9721 _(mpls_route_add_del, \
9722 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
9723 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
9724 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
9725 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
9726 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
9727 "[count <n>] [del]") \
9728 _(mpls_ip_bind_unbind, \
9729 "<label> <addr/len>") \
9730 _(mpls_tunnel_add_del, \
9731 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
9732 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
9733 "[l2-only] [out-label <n>]") \
9734 _(sw_interface_set_unnumbered, \
9735 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
9736 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
9737 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
9738 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
9739 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
9740 "[outer_vlan_id_any][inner_vlan_id_any]") \
9741 _(ip_table_replace_begin, "table <n> [ipv6]") \
9742 _(ip_table_flush, "table <n> [ipv6]") \
9743 _(ip_table_replace_end, "table <n> [ipv6]") \
9744 _(set_ip_flow_hash, \
9745 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
9746 _(sw_interface_ip6_enable_disable, \
9747 "<intfc> | sw_if_index <id> enable | disable") \
9748 _(l2_patch_add_del, \
9749 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
9750 "enable | disable") \
9751 _(get_node_index, "node <node-name") \
9752 _(add_node_next, "node <node-name> next <next-node-name>") \
9753 _(l2_fib_clear_table, "") \
9754 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
9755 _(l2_interface_vlan_tag_rewrite, \
9756 "<intfc> | sw_if_index <nn> \n" \
9757 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
9758 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
9759 _(create_vhost_user_if, \
9760 "socket <filename> [server] [renumber <dev_instance>] " \
9761 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
9762 "[mac <mac_address>] [packed]") \
9763 _(modify_vhost_user_if, \
9764 "<intfc> | sw_if_index <nn> socket <filename>\n" \
9765 "[server] [renumber <dev_instance>] [gso] [packed]") \
9766 _(create_vhost_user_if_v2, \
9767 "socket <filename> [server] [renumber <dev_instance>] " \
9768 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
9769 "[mac <mac_address>] [packed] [event-idx]") \
9770 _(modify_vhost_user_if_v2, \
9771 "<intfc> | sw_if_index <nn> socket <filename>\n" \
9772 "[server] [renumber <dev_instance>] [gso] [packed] [event-idx]")\
9773 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
9774 _(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
9775 _(show_version, "") \
9776 _(show_threads, "") \
9777 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
9778 _(interface_name_renumber, \
9779 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
9780 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
9781 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
9782 _(ip_dump, "ipv4 | ipv6") \
9783 _(delete_loopback,"sw_if_index <nn>") \
9784 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
9785 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
9786 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
9787 _(want_interface_events, "enable|disable") \
9788 _(get_first_msg_id, "client <name>") \
9789 _(get_node_graph, " ") \
9790 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
9791 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
9792 _(ioam_disable, "") \
9793 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
9794 _(mpls_table_dump, "") \
9795 _(mpls_route_dump, "table-id <ID>") \
9796 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
9797 _(sw_interface_span_dump, "[l2]") \
9798 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
9799 _(ip_source_and_port_range_check_add_del, \
9800 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
9801 _(ip_source_and_port_range_check_interface_add_del, \
9802 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
9803 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
9804 _(delete_subif,"<intfc> | sw_if_index <nn>") \
9805 _(l2_interface_pbb_tag_rewrite, \
9806 "<intfc> | sw_if_index <nn> \n" \
9807 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
9808 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
9809 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
9810 _(ip_table_dump, "") \
9811 _(ip_route_dump, "table-id [ip4|ip6]") \
9812 _(ip_mtable_dump, "") \
9813 _(ip_mroute_dump, "table-id [ip4|ip6]") \
9814 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
9816 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
9817 "mac <mac-address> [del]") \
9818 _(l2_xconnect_dump, "") \
9819 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
9820 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
9821 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
9822 _(sock_init_shm, "size <nnn>") \
9823 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
9824 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
9825 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
9826 _(session_rules_dump, "") \
9827 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
9829 /* List of command functions, CLI names map directly to functions */
9830 #define foreach_cli_function \
9831 _(comment, "usage: comment <ignore-rest-of-line>") \
9832 _(dump_interface_table, "usage: dump_interface_table") \
9833 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
9834 _(dump_ipv4_table, "usage: dump_ipv4_table") \
9835 _(dump_ipv6_table, "usage: dump_ipv6_table") \
9836 _(dump_macro_table, "usage: dump_macro_table ") \
9837 _(dump_node_table, "usage: dump_node_table") \
9838 _(dump_msg_api_table, "usage: dump_msg_api_table") \
9839 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
9840 _(elog_disable, "usage: elog_disable") \
9841 _(elog_enable, "usage: elog_enable") \
9842 _(elog_save, "usage: elog_save <filename>") \
9843 _(get_msg_id, "usage: get_msg_id name_and_crc") \
9844 _(echo, "usage: echo <message>") \
9845 _(exec, "usage: exec <vpe-debug-CLI-command>") \
9846 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
9847 _(help, "usage: help") \
9848 _(q, "usage: quit") \
9849 _(quit, "usage: quit") \
9850 _(search_node_table, "usage: search_node_table <name>...") \
9851 _(set, "usage: set <variable-name> <value>") \
9852 _(script, "usage: script <file-name>") \
9853 _(statseg, "usage: statseg") \
9854 _(unset, "usage: unset <variable-name>")
9857 static void vl_api_##n##_t_handler_uni \
9858 (vl_api_##n##_t * mp) \
9860 vat_main_t * vam = &vat_main; \
9861 if (vam->json_output) { \
9862 vl_api_##n##_t_handler_json(mp); \
9864 vl_api_##n##_t_handler(mp); \
9867 foreach_vpe_api_reply_msg;
9868 #if VPP_API_TEST_BUILTIN == 0
9869 foreach_standalone_reply_msg;
9874 vat_api_hookup (vat_main_t * vam)
9877 vl_msg_api_set_handlers(VL_API_##N, #n, \
9878 vl_api_##n##_t_handler_uni, \
9880 vl_api_##n##_t_endian, \
9881 vl_api_##n##_t_print, \
9882 sizeof(vl_api_##n##_t), 1);
9883 foreach_vpe_api_reply_msg;
9884 #if VPP_API_TEST_BUILTIN == 0
9885 foreach_standalone_reply_msg;
9889 #if (VPP_API_TEST_BUILTIN==0)
9890 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
9892 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
9894 vam->function_by_name = hash_create_string (0, sizeof (uword));
9896 vam->help_by_name = hash_create_string (0, sizeof (uword));
9899 /* API messages we can send */
9900 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
9901 foreach_vpe_api_msg;
9905 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
9906 foreach_vpe_api_msg;
9910 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
9911 foreach_cli_function;
9915 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
9916 foreach_cli_function;
9920 #if VPP_API_TEST_BUILTIN
9921 static clib_error_t *
9922 vat_api_hookup_shim (vlib_main_t * vm)
9924 vat_api_hookup (&vat_main);
9928 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
9932 * fd.io coding-style-patch-verification: ON
9935 * eval: (c-set-style "gnu")