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;
1481 static void vl_api_ip_address_details_t_handler
1482 (vl_api_ip_address_details_t * mp)
1484 vat_main_t *vam = &vat_main;
1485 static ip_address_details_t empty_ip_address_details = { {0} };
1486 ip_address_details_t *address = NULL;
1487 ip_details_t *current_ip_details = NULL;
1488 ip_details_t *details = NULL;
1490 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1492 if (!details || vam->current_sw_if_index >= vec_len (details)
1493 || !details[vam->current_sw_if_index].present)
1495 errmsg ("ip address details arrived but not stored");
1496 errmsg ("ip_dump should be called first");
1500 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1502 #define addresses (current_ip_details->addr)
1504 vec_validate_init_empty (addresses, vec_len (addresses),
1505 empty_ip_address_details);
1507 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1509 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
1510 address->prefix_length = mp->prefix.len;
1514 static void vl_api_ip_address_details_t_handler_json
1515 (vl_api_ip_address_details_t * mp)
1517 vat_main_t *vam = &vat_main;
1518 vat_json_node_t *node = NULL;
1520 if (VAT_JSON_ARRAY != vam->json_tree.type)
1522 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1523 vat_json_init_array (&vam->json_tree);
1525 node = vat_json_array_add (&vam->json_tree);
1527 vat_json_init_object (node);
1528 vat_json_object_add_prefix (node, &mp->prefix);
1532 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1534 vat_main_t *vam = &vat_main;
1535 static ip_details_t empty_ip_details = { 0 };
1536 ip_details_t *ip = NULL;
1537 u32 sw_if_index = ~0;
1539 sw_if_index = ntohl (mp->sw_if_index);
1541 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1542 sw_if_index, empty_ip_details);
1544 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1551 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1553 vat_main_t *vam = &vat_main;
1555 if (VAT_JSON_ARRAY != vam->json_tree.type)
1557 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1558 vat_json_init_array (&vam->json_tree);
1560 vat_json_array_add_uint (&vam->json_tree,
1561 clib_net_to_host_u32 (mp->sw_if_index));
1564 static void vl_api_get_first_msg_id_reply_t_handler
1565 (vl_api_get_first_msg_id_reply_t * mp)
1567 vat_main_t *vam = &vat_main;
1568 i32 retval = ntohl (mp->retval);
1570 if (vam->async_mode)
1572 vam->async_errors += (retval < 0);
1576 vam->retval = retval;
1577 vam->result_ready = 1;
1581 errmsg ("first message id %d", ntohs (mp->first_msg_id));
1585 static void vl_api_get_first_msg_id_reply_t_handler_json
1586 (vl_api_get_first_msg_id_reply_t * mp)
1588 vat_main_t *vam = &vat_main;
1589 vat_json_node_t node;
1591 vat_json_init_object (&node);
1592 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1593 vat_json_object_add_uint (&node, "first_msg_id",
1594 (uint) ntohs (mp->first_msg_id));
1596 vat_json_print (vam->ofp, &node);
1597 vat_json_free (&node);
1599 vam->retval = ntohl (mp->retval);
1600 vam->result_ready = 1;
1603 static void vl_api_get_node_graph_reply_t_handler
1604 (vl_api_get_node_graph_reply_t * mp)
1606 vat_main_t *vam = &vat_main;
1607 i32 retval = ntohl (mp->retval);
1608 u8 *pvt_copy, *reply;
1613 if (vam->async_mode)
1615 vam->async_errors += (retval < 0);
1619 vam->retval = retval;
1620 vam->result_ready = 1;
1623 /* "Should never happen..." */
1627 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1628 pvt_copy = vec_dup (reply);
1630 /* Toss the shared-memory original... */
1631 oldheap = vl_msg_push_heap ();
1635 vl_msg_pop_heap (oldheap);
1637 if (vam->graph_nodes)
1639 hash_free (vam->graph_node_index_by_name);
1641 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1643 node = vam->graph_nodes[0][i];
1644 vec_free (node->name);
1645 vec_free (node->next_nodes);
1648 vec_free (vam->graph_nodes[0]);
1649 vec_free (vam->graph_nodes);
1652 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
1653 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
1654 vec_free (pvt_copy);
1656 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1658 node = vam->graph_nodes[0][i];
1659 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
1663 static void vl_api_get_node_graph_reply_t_handler_json
1664 (vl_api_get_node_graph_reply_t * mp)
1666 vat_main_t *vam = &vat_main;
1668 vat_json_node_t node;
1671 /* $$$$ make this real? */
1672 vat_json_init_object (&node);
1673 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1674 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
1676 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1678 /* Toss the shared-memory original... */
1679 oldheap = vl_msg_push_heap ();
1683 vl_msg_pop_heap (oldheap);
1685 vat_json_print (vam->ofp, &node);
1686 vat_json_free (&node);
1688 vam->retval = ntohl (mp->retval);
1689 vam->result_ready = 1;
1692 /* Format hex dump. */
1694 format_hex_bytes (u8 * s, va_list * va)
1696 u8 *bytes = va_arg (*va, u8 *);
1697 int n_bytes = va_arg (*va, int);
1700 /* Print short or long form depending on byte count. */
1701 uword short_form = n_bytes <= 32;
1702 u32 indent = format_get_indent (s);
1707 for (i = 0; i < n_bytes; i++)
1709 if (!short_form && (i % 32) == 0)
1710 s = format (s, "%08x: ", i);
1711 s = format (s, "%02x", bytes[i]);
1712 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
1713 s = format (s, "\n%U", format_white_space, indent);
1720 * Generate boilerplate reply handlers, which
1721 * dig the return value out of the xxx_reply_t API message,
1722 * stick it into vam->retval, and set vam->result_ready
1724 * Could also do this by pointing N message decode slots at
1725 * a single function, but that could break in subtle ways.
1728 #define foreach_standard_reply_retval_handler \
1729 _(sw_interface_set_flags_reply) \
1730 _(sw_interface_add_del_address_reply) \
1731 _(sw_interface_set_rx_mode_reply) \
1732 _(sw_interface_set_rx_placement_reply) \
1733 _(sw_interface_set_table_reply) \
1734 _(sw_interface_set_vpath_reply) \
1735 _(sw_interface_set_l2_bridge_reply) \
1736 _(bridge_domain_add_del_reply) \
1737 _(sw_interface_set_l2_xconnect_reply) \
1738 _(l2fib_add_del_reply) \
1739 _(l2fib_flush_int_reply) \
1740 _(l2fib_flush_bd_reply) \
1741 _(ip_route_add_del_reply) \
1742 _(ip_table_add_del_reply) \
1743 _(ip_table_replace_begin_reply) \
1744 _(ip_table_flush_reply) \
1745 _(ip_table_replace_end_reply) \
1746 _(ip_mroute_add_del_reply) \
1747 _(sw_interface_set_unnumbered_reply) \
1748 _(set_ip_flow_hash_reply) \
1749 _(sw_interface_ip6_enable_disable_reply) \
1750 _(l2_patch_add_del_reply) \
1751 _(l2_fib_clear_table_reply) \
1752 _(l2_interface_efp_filter_reply) \
1753 _(l2_interface_vlan_tag_rewrite_reply) \
1754 _(want_l2_macs_events_reply) \
1755 _(delete_loopback_reply) \
1756 _(bd_ip_mac_add_del_reply) \
1757 _(bd_ip_mac_flush_reply) \
1758 _(want_interface_events_reply) \
1759 _(sw_interface_clear_stats_reply) \
1760 _(ioam_enable_reply) \
1761 _(ioam_disable_reply) \
1762 _(ip_source_and_port_range_check_add_del_reply) \
1763 _(ip_source_and_port_range_check_interface_add_del_reply)\
1764 _(delete_subif_reply) \
1765 _(l2_interface_pbb_tag_rewrite_reply) \
1766 _(sw_interface_tag_add_del_reply) \
1767 _(sw_interface_add_del_mac_address_reply) \
1768 _(hw_interface_set_mtu_reply) \
1769 _(session_rule_add_del_reply) \
1770 _(ip_container_proxy_add_del_reply) \
1773 static void vl_api_##n##_t_handler \
1774 (vl_api_##n##_t * mp) \
1776 vat_main_t * vam = &vat_main; \
1777 i32 retval = ntohl(mp->retval); \
1778 if (vam->async_mode) { \
1779 vam->async_errors += (retval < 0); \
1781 vam->retval = retval; \
1782 vam->result_ready = 1; \
1785 foreach_standard_reply_retval_handler;
1789 static void vl_api_##n##_t_handler_json \
1790 (vl_api_##n##_t * mp) \
1792 vat_main_t * vam = &vat_main; \
1793 vat_json_node_t node; \
1794 vat_json_init_object(&node); \
1795 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
1796 vat_json_print(vam->ofp, &node); \
1797 vam->retval = ntohl(mp->retval); \
1798 vam->result_ready = 1; \
1800 foreach_standard_reply_retval_handler;
1804 * Table of message reply handlers, must include boilerplate handlers
1808 #define foreach_vpe_api_reply_msg \
1809 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
1810 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
1811 _(SW_INTERFACE_DETAILS, sw_interface_details) \
1812 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
1813 _(CONTROL_PING_REPLY, control_ping_reply) \
1814 _(CLI_REPLY, cli_reply) \
1815 _(CLI_INBAND_REPLY, cli_inband_reply) \
1816 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
1817 sw_interface_add_del_address_reply) \
1818 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
1819 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
1820 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
1821 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
1822 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
1823 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
1824 sw_interface_set_l2_xconnect_reply) \
1825 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
1826 sw_interface_set_l2_bridge_reply) \
1827 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
1828 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
1829 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
1830 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
1831 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
1832 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
1833 _(L2_FLAGS_REPLY, l2_flags_reply) \
1834 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
1835 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
1836 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
1837 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
1838 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
1839 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
1840 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
1841 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
1842 sw_interface_set_unnumbered_reply) \
1843 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
1844 _(CREATE_SUBIF_REPLY, create_subif_reply) \
1845 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
1846 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
1847 sw_interface_ip6_enable_disable_reply) \
1848 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
1849 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
1850 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
1851 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
1852 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
1853 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
1854 _(SHOW_VERSION_REPLY, show_version_reply) \
1855 _(SHOW_THREADS_REPLY, show_threads_reply) \
1856 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
1857 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
1858 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
1859 _(L2_MACS_EVENT, l2_macs_event) \
1860 _(IP_ADDRESS_DETAILS, ip_address_details) \
1861 _(IP_DETAILS, ip_details) \
1862 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
1863 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
1864 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
1865 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
1866 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
1867 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
1868 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
1869 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
1870 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
1871 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
1872 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
1873 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
1874 ip_source_and_port_range_check_add_del_reply) \
1875 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
1876 ip_source_and_port_range_check_interface_add_del_reply) \
1877 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
1878 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
1879 _(IP_TABLE_DETAILS, ip_table_details) \
1880 _(IP_ROUTE_DETAILS, ip_route_details) \
1881 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
1882 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
1883 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
1884 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
1885 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
1886 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
1887 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
1888 _(SESSION_RULES_DETAILS, session_rules_details) \
1889 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
1891 #define foreach_standalone_reply_msg \
1892 _(SW_INTERFACE_EVENT, sw_interface_event)
1900 #define STR_VTR_OP_CASE(op) \
1901 case L2_VTR_ ## op: \
1905 str_vtr_op (u32 vtr_op)
1909 STR_VTR_OP_CASE (DISABLED);
1910 STR_VTR_OP_CASE (PUSH_1);
1911 STR_VTR_OP_CASE (PUSH_2);
1912 STR_VTR_OP_CASE (POP_1);
1913 STR_VTR_OP_CASE (POP_2);
1914 STR_VTR_OP_CASE (TRANSLATE_1_1);
1915 STR_VTR_OP_CASE (TRANSLATE_1_2);
1916 STR_VTR_OP_CASE (TRANSLATE_2_1);
1917 STR_VTR_OP_CASE (TRANSLATE_2_2);
1924 dump_sub_interface_table (vat_main_t * vam)
1926 const sw_interface_subif_t *sub = NULL;
1928 if (vam->json_output)
1931 ("JSON output supported only for VPE API calls and dump_stats_table");
1936 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
1937 "Interface", "sw_if_index",
1938 "sub id", "dot1ad", "tags", "outer id",
1939 "inner id", "exact", "default", "outer any", "inner any");
1941 vec_foreach (sub, vam->sw_if_subif_table)
1944 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
1945 sub->interface_name,
1947 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
1948 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
1949 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
1950 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
1951 if (sub->vtr_op != L2_VTR_DISABLED)
1954 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
1955 "tag1: %d tag2: %d ]",
1956 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
1957 sub->vtr_tag1, sub->vtr_tag2);
1965 name_sort_cmp (void *a1, void *a2)
1967 name_sort_t *n1 = a1;
1968 name_sort_t *n2 = a2;
1970 return strcmp ((char *) n1->name, (char *) n2->name);
1974 dump_interface_table (vat_main_t * vam)
1977 name_sort_t *nses = 0, *ns;
1979 if (vam->json_output)
1982 ("JSON output supported only for VPE API calls and dump_stats_table");
1987 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1989 vec_add2 (nses, ns, 1);
1990 ns->name = (u8 *)(p->key);
1991 ns->value = (u32) p->value[0];
1995 vec_sort_with_function (nses, name_sort_cmp);
1997 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
1998 vec_foreach (ns, nses)
2000 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
2007 dump_ip_table (vat_main_t * vam, int is_ipv6)
2009 const ip_details_t *det = NULL;
2010 const ip_address_details_t *address = NULL;
2013 print (vam->ofp, "%-12s", "sw_if_index");
2015 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
2022 print (vam->ofp, "%-12d", i);
2023 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
2028 vec_foreach (address, det->addr)
2032 is_ipv6 ? format_ip6_address : format_ip4_address,
2033 address->ip, address->prefix_length);
2041 dump_ipv4_table (vat_main_t * vam)
2043 if (vam->json_output)
2046 ("JSON output supported only for VPE API calls and dump_stats_table");
2050 return dump_ip_table (vam, 0);
2054 dump_ipv6_table (vat_main_t * vam)
2056 if (vam->json_output)
2059 ("JSON output supported only for VPE API calls and dump_stats_table");
2063 return dump_ip_table (vam, 1);
2067 * Pass CLI buffers directly in the CLI_INBAND API message,
2068 * instead of an additional shared memory area.
2071 exec_inband (vat_main_t * vam)
2073 vl_api_cli_inband_t *mp;
2074 unformat_input_t *i = vam->input;
2077 if (vec_len (i->buffer) == 0)
2080 if (vam->exec_mode == 0 && unformat (i, "mode"))
2085 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
2092 * In order for the CLI command to work, it
2093 * must be a vector ending in \n, not a C-string ending
2096 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
2097 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
2101 /* json responses may or may not include a useful reply... */
2102 if (vec_len (vam->cmd_reply))
2103 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
2108 exec (vat_main_t * vam)
2110 return exec_inband (vam);
2114 api_create_loopback (vat_main_t * vam)
2116 unformat_input_t *i = vam->input;
2117 vl_api_create_loopback_t *mp;
2118 vl_api_create_loopback_instance_t *mp_lbi;
2121 u8 is_specified = 0;
2122 u32 user_instance = 0;
2125 clib_memset (mac_address, 0, sizeof (mac_address));
2127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2129 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
2131 if (unformat (i, "instance %d", &user_instance))
2139 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
2140 mp_lbi->is_specified = is_specified;
2142 mp_lbi->user_instance = htonl (user_instance);
2144 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
2149 /* Construct the API message */
2150 M (CREATE_LOOPBACK, mp);
2152 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
2161 api_delete_loopback (vat_main_t * vam)
2163 unformat_input_t *i = vam->input;
2164 vl_api_delete_loopback_t *mp;
2165 u32 sw_if_index = ~0;
2168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2170 if (unformat (i, "sw_if_index %d", &sw_if_index))
2176 if (sw_if_index == ~0)
2178 errmsg ("missing sw_if_index");
2182 /* Construct the API message */
2183 M (DELETE_LOOPBACK, mp);
2184 mp->sw_if_index = ntohl (sw_if_index);
2192 api_want_interface_events (vat_main_t * vam)
2194 unformat_input_t *i = vam->input;
2195 vl_api_want_interface_events_t *mp;
2199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2201 if (unformat (i, "enable"))
2203 else if (unformat (i, "disable"))
2211 errmsg ("missing enable|disable");
2215 M (WANT_INTERFACE_EVENTS, mp);
2216 mp->enable_disable = enable;
2218 vam->interface_event_display = enable;
2226 /* Note: non-static, called once to set up the initial intfc table */
2228 api_sw_interface_dump (vat_main_t * vam)
2230 vl_api_sw_interface_dump_t *mp;
2231 vl_api_control_ping_t *mp_ping;
2233 name_sort_t *nses = 0, *ns;
2234 sw_interface_subif_t *sub = NULL;
2237 /* Toss the old name table */
2239 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2241 vec_add2 (nses, ns, 1);
2242 ns->name = (u8 *)(p->key);
2243 ns->value = (u32) p->value[0];
2247 hash_free (vam->sw_if_index_by_interface_name);
2249 vec_foreach (ns, nses) vec_free (ns->name);
2253 vec_foreach (sub, vam->sw_if_subif_table)
2255 vec_free (sub->interface_name);
2257 vec_free (vam->sw_if_subif_table);
2259 /* recreate the interface name hash table */
2260 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
2263 * Ask for all interface names. Otherwise, the epic catalog of
2264 * name filters becomes ridiculously long, and vat ends up needing
2265 * to be taught about new interface types.
2267 M (SW_INTERFACE_DUMP, mp);
2270 /* Use a control ping for synchronization */
2271 MPING (CONTROL_PING, mp_ping);
2279 api_sw_interface_set_flags (vat_main_t * vam)
2281 unformat_input_t *i = vam->input;
2282 vl_api_sw_interface_set_flags_t *mp;
2284 u8 sw_if_index_set = 0;
2288 /* Parse args required to build the message */
2289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2291 if (unformat (i, "admin-up"))
2293 else if (unformat (i, "admin-down"))
2296 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2297 sw_if_index_set = 1;
2298 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2299 sw_if_index_set = 1;
2304 if (sw_if_index_set == 0)
2306 errmsg ("missing interface name or sw_if_index");
2310 /* Construct the API message */
2311 M (SW_INTERFACE_SET_FLAGS, mp);
2312 mp->sw_if_index = ntohl (sw_if_index);
2313 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
2318 /* Wait for a reply, return the good/bad news... */
2324 api_sw_interface_set_rx_mode (vat_main_t * vam)
2326 unformat_input_t *i = vam->input;
2327 vl_api_sw_interface_set_rx_mode_t *mp;
2329 u8 sw_if_index_set = 0;
2331 u8 queue_id_valid = 0;
2333 vnet_hw_if_rx_mode mode = VNET_HW_IF_RX_MODE_UNKNOWN;
2335 /* Parse args required to build the message */
2336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2338 if (unformat (i, "queue %d", &queue_id))
2340 else if (unformat (i, "polling"))
2341 mode = VNET_HW_IF_RX_MODE_POLLING;
2342 else if (unformat (i, "interrupt"))
2343 mode = VNET_HW_IF_RX_MODE_INTERRUPT;
2344 else if (unformat (i, "adaptive"))
2345 mode = VNET_HW_IF_RX_MODE_ADAPTIVE;
2347 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2348 sw_if_index_set = 1;
2349 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2350 sw_if_index_set = 1;
2355 if (sw_if_index_set == 0)
2357 errmsg ("missing interface name or sw_if_index");
2360 if (mode == VNET_HW_IF_RX_MODE_UNKNOWN)
2362 errmsg ("missing rx-mode");
2366 /* Construct the API message */
2367 M (SW_INTERFACE_SET_RX_MODE, mp);
2368 mp->sw_if_index = ntohl (sw_if_index);
2369 mp->mode = (vl_api_rx_mode_t) mode;
2370 mp->queue_id_valid = queue_id_valid;
2371 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
2376 /* Wait for a reply, return the good/bad news... */
2382 api_sw_interface_set_rx_placement (vat_main_t * vam)
2384 unformat_input_t *i = vam->input;
2385 vl_api_sw_interface_set_rx_placement_t *mp;
2387 u8 sw_if_index_set = 0;
2390 u32 queue_id, thread_index;
2392 /* Parse args required to build the message */
2393 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2395 if (unformat (i, "queue %d", &queue_id))
2397 else if (unformat (i, "main"))
2399 else if (unformat (i, "worker %d", &thread_index))
2402 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2403 sw_if_index_set = 1;
2404 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2405 sw_if_index_set = 1;
2410 if (sw_if_index_set == 0)
2412 errmsg ("missing interface name or sw_if_index");
2418 /* Construct the API message */
2419 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
2420 mp->sw_if_index = ntohl (sw_if_index);
2421 mp->worker_id = ntohl (thread_index);
2422 mp->queue_id = ntohl (queue_id);
2423 mp->is_main = is_main;
2427 /* Wait for a reply, return the good/bad news... */
2432 static void vl_api_sw_interface_rx_placement_details_t_handler
2433 (vl_api_sw_interface_rx_placement_details_t * mp)
2435 vat_main_t *vam = &vat_main;
2436 u32 worker_id = ntohl (mp->worker_id);
2439 "\n%-11d %-11s %-6d %-5d %-9s",
2440 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
2441 worker_id, ntohl (mp->queue_id),
2443 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
2446 static void vl_api_sw_interface_rx_placement_details_t_handler_json
2447 (vl_api_sw_interface_rx_placement_details_t * mp)
2449 vat_main_t *vam = &vat_main;
2450 vat_json_node_t *node = NULL;
2452 if (VAT_JSON_ARRAY != vam->json_tree.type)
2454 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2455 vat_json_init_array (&vam->json_tree);
2457 node = vat_json_array_add (&vam->json_tree);
2459 vat_json_init_object (node);
2460 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2461 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
2462 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
2463 vat_json_object_add_uint (node, "mode", mp->mode);
2467 api_sw_interface_rx_placement_dump (vat_main_t * vam)
2469 unformat_input_t *i = vam->input;
2470 vl_api_sw_interface_rx_placement_dump_t *mp;
2471 vl_api_control_ping_t *mp_ping;
2474 u8 sw_if_index_set = 0;
2476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2478 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2480 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2487 "\n%-11s %-11s %-6s %-5s %-4s",
2488 "sw_if_index", "main/worker", "thread", "queue", "mode");
2490 /* Dump Interface rx placement */
2491 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
2493 if (sw_if_index_set)
2494 mp->sw_if_index = htonl (sw_if_index);
2496 mp->sw_if_index = ~0;
2500 /* Use a control ping for synchronization */
2501 MPING (CONTROL_PING, mp_ping);
2509 api_sw_interface_clear_stats (vat_main_t * vam)
2511 unformat_input_t *i = vam->input;
2512 vl_api_sw_interface_clear_stats_t *mp;
2514 u8 sw_if_index_set = 0;
2517 /* Parse args required to build the message */
2518 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2520 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2521 sw_if_index_set = 1;
2522 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2523 sw_if_index_set = 1;
2528 /* Construct the API message */
2529 M (SW_INTERFACE_CLEAR_STATS, mp);
2531 if (sw_if_index_set == 1)
2532 mp->sw_if_index = ntohl (sw_if_index);
2534 mp->sw_if_index = ~0;
2539 /* Wait for a reply, return the good/bad news... */
2545 api_sw_interface_add_del_address (vat_main_t * vam)
2547 unformat_input_t *i = vam->input;
2548 vl_api_sw_interface_add_del_address_t *mp;
2550 u8 sw_if_index_set = 0;
2551 u8 is_add = 1, del_all = 0;
2552 u32 address_length = 0;
2553 u8 v4_address_set = 0;
2554 u8 v6_address_set = 0;
2555 ip4_address_t v4address;
2556 ip6_address_t v6address;
2559 /* Parse args required to build the message */
2560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2562 if (unformat (i, "del-all"))
2564 else if (unformat (i, "del"))
2567 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2568 sw_if_index_set = 1;
2569 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2570 sw_if_index_set = 1;
2571 else if (unformat (i, "%U/%d",
2572 unformat_ip4_address, &v4address, &address_length))
2574 else if (unformat (i, "%U/%d",
2575 unformat_ip6_address, &v6address, &address_length))
2581 if (sw_if_index_set == 0)
2583 errmsg ("missing interface name or sw_if_index");
2586 if (v4_address_set && v6_address_set)
2588 errmsg ("both v4 and v6 addresses set");
2591 if (!v4_address_set && !v6_address_set && !del_all)
2593 errmsg ("no addresses set");
2597 /* Construct the API message */
2598 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
2600 mp->sw_if_index = ntohl (sw_if_index);
2601 mp->is_add = is_add;
2602 mp->del_all = del_all;
2605 mp->prefix.address.af = ADDRESS_IP6;
2606 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
2610 mp->prefix.address.af = ADDRESS_IP4;
2611 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
2613 mp->prefix.len = address_length;
2618 /* Wait for a reply, return good/bad news */
2624 api_sw_interface_set_table (vat_main_t * vam)
2626 unformat_input_t *i = vam->input;
2627 vl_api_sw_interface_set_table_t *mp;
2628 u32 sw_if_index, vrf_id = 0;
2629 u8 sw_if_index_set = 0;
2633 /* Parse args required to build the message */
2634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2636 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2637 sw_if_index_set = 1;
2638 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2639 sw_if_index_set = 1;
2640 else if (unformat (i, "vrf %d", &vrf_id))
2642 else if (unformat (i, "ipv6"))
2648 if (sw_if_index_set == 0)
2650 errmsg ("missing interface name or sw_if_index");
2654 /* Construct the API message */
2655 M (SW_INTERFACE_SET_TABLE, mp);
2657 mp->sw_if_index = ntohl (sw_if_index);
2658 mp->is_ipv6 = is_ipv6;
2659 mp->vrf_id = ntohl (vrf_id);
2664 /* Wait for a reply... */
2669 static void vl_api_sw_interface_get_table_reply_t_handler
2670 (vl_api_sw_interface_get_table_reply_t * mp)
2672 vat_main_t *vam = &vat_main;
2674 print (vam->ofp, "%d", ntohl (mp->vrf_id));
2676 vam->retval = ntohl (mp->retval);
2677 vam->result_ready = 1;
2681 static void vl_api_sw_interface_get_table_reply_t_handler_json
2682 (vl_api_sw_interface_get_table_reply_t * mp)
2684 vat_main_t *vam = &vat_main;
2685 vat_json_node_t node;
2687 vat_json_init_object (&node);
2688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2689 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
2691 vat_json_print (vam->ofp, &node);
2692 vat_json_free (&node);
2694 vam->retval = ntohl (mp->retval);
2695 vam->result_ready = 1;
2699 api_sw_interface_get_table (vat_main_t * vam)
2701 unformat_input_t *i = vam->input;
2702 vl_api_sw_interface_get_table_t *mp;
2704 u8 sw_if_index_set = 0;
2708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2710 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2711 sw_if_index_set = 1;
2712 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2713 sw_if_index_set = 1;
2714 else if (unformat (i, "ipv6"))
2720 if (sw_if_index_set == 0)
2722 errmsg ("missing interface name or sw_if_index");
2726 M (SW_INTERFACE_GET_TABLE, mp);
2727 mp->sw_if_index = htonl (sw_if_index);
2728 mp->is_ipv6 = is_ipv6;
2736 api_sw_interface_set_vpath (vat_main_t * vam)
2738 unformat_input_t *i = vam->input;
2739 vl_api_sw_interface_set_vpath_t *mp;
2740 u32 sw_if_index = 0;
2741 u8 sw_if_index_set = 0;
2745 /* Parse args required to build the message */
2746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2748 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2749 sw_if_index_set = 1;
2750 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2751 sw_if_index_set = 1;
2752 else if (unformat (i, "enable"))
2754 else if (unformat (i, "disable"))
2760 if (sw_if_index_set == 0)
2762 errmsg ("missing interface name or sw_if_index");
2766 /* Construct the API message */
2767 M (SW_INTERFACE_SET_VPATH, mp);
2769 mp->sw_if_index = ntohl (sw_if_index);
2770 mp->enable = is_enable;
2775 /* Wait for a reply... */
2781 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
2783 unformat_input_t *i = vam->input;
2784 vl_api_sw_interface_set_l2_xconnect_t *mp;
2786 u8 rx_sw_if_index_set = 0;
2788 u8 tx_sw_if_index_set = 0;
2792 /* Parse args required to build the message */
2793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2795 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
2796 rx_sw_if_index_set = 1;
2797 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
2798 tx_sw_if_index_set = 1;
2799 else if (unformat (i, "rx"))
2801 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2803 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
2805 rx_sw_if_index_set = 1;
2810 else if (unformat (i, "tx"))
2812 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2814 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
2816 tx_sw_if_index_set = 1;
2821 else if (unformat (i, "enable"))
2823 else if (unformat (i, "disable"))
2829 if (rx_sw_if_index_set == 0)
2831 errmsg ("missing rx interface name or rx_sw_if_index");
2835 if (enable && (tx_sw_if_index_set == 0))
2837 errmsg ("missing tx interface name or tx_sw_if_index");
2841 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
2843 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
2844 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
2845 mp->enable = enable;
2853 api_sw_interface_set_l2_bridge (vat_main_t * vam)
2855 unformat_input_t *i = vam->input;
2856 vl_api_sw_interface_set_l2_bridge_t *mp;
2857 vl_api_l2_port_type_t port_type;
2859 u8 rx_sw_if_index_set = 0;
2866 port_type = L2_API_PORT_TYPE_NORMAL;
2868 /* Parse args required to build the message */
2869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2871 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
2872 rx_sw_if_index_set = 1;
2873 else if (unformat (i, "bd_id %d", &bd_id))
2877 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
2878 rx_sw_if_index_set = 1;
2879 else if (unformat (i, "shg %d", &shg))
2881 else if (unformat (i, "bvi"))
2882 port_type = L2_API_PORT_TYPE_BVI;
2883 else if (unformat (i, "uu-fwd"))
2884 port_type = L2_API_PORT_TYPE_UU_FWD;
2885 else if (unformat (i, "enable"))
2887 else if (unformat (i, "disable"))
2893 if (rx_sw_if_index_set == 0)
2895 errmsg ("missing rx interface name or sw_if_index");
2899 if (enable && (bd_id_set == 0))
2901 errmsg ("missing bridge domain");
2905 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
2907 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
2908 mp->bd_id = ntohl (bd_id);
2910 mp->port_type = ntohl (port_type);
2911 mp->enable = enable;
2919 api_bridge_domain_dump (vat_main_t * vam)
2921 unformat_input_t *i = vam->input;
2922 vl_api_bridge_domain_dump_t *mp;
2923 vl_api_control_ping_t *mp_ping;
2927 /* Parse args required to build the message */
2928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2930 if (unformat (i, "bd_id %d", &bd_id))
2936 M (BRIDGE_DOMAIN_DUMP, mp);
2937 mp->bd_id = ntohl (bd_id);
2940 /* Use a control ping for synchronization */
2941 MPING (CONTROL_PING, mp_ping);
2949 api_bridge_domain_add_del (vat_main_t * vam)
2951 unformat_input_t *i = vam->input;
2952 vl_api_bridge_domain_add_del_t *mp;
2955 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
2960 /* Parse args required to build the message */
2961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2963 if (unformat (i, "bd_id %d", &bd_id))
2965 else if (unformat (i, "flood %d", &flood))
2967 else if (unformat (i, "uu-flood %d", &uu_flood))
2969 else if (unformat (i, "forward %d", &forward))
2971 else if (unformat (i, "learn %d", &learn))
2973 else if (unformat (i, "arp-term %d", &arp_term))
2975 else if (unformat (i, "mac-age %d", &mac_age))
2977 else if (unformat (i, "bd-tag %s", &bd_tag))
2979 else if (unformat (i, "del"))
2982 flood = uu_flood = forward = learn = 0;
2990 errmsg ("missing bridge domain");
2997 errmsg ("mac age must be less than 256 ");
3002 if ((bd_tag) && (vec_len (bd_tag) > 63))
3004 errmsg ("bd-tag cannot be longer than 63");
3009 M (BRIDGE_DOMAIN_ADD_DEL, mp);
3011 mp->bd_id = ntohl (bd_id);
3013 mp->uu_flood = uu_flood;
3014 mp->forward = forward;
3016 mp->arp_term = arp_term;
3017 mp->is_add = is_add;
3018 mp->mac_age = (u8) mac_age;
3021 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
3022 mp->bd_tag[vec_len (bd_tag)] = 0;
3033 api_l2fib_flush_bd (vat_main_t * vam)
3035 unformat_input_t *i = vam->input;
3036 vl_api_l2fib_flush_bd_t *mp;
3040 /* Parse args required to build the message */
3041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3043 if (unformat (i, "bd_id %d", &bd_id));
3050 errmsg ("missing bridge domain");
3054 M (L2FIB_FLUSH_BD, mp);
3056 mp->bd_id = htonl (bd_id);
3064 api_l2fib_flush_int (vat_main_t * vam)
3066 unformat_input_t *i = vam->input;
3067 vl_api_l2fib_flush_int_t *mp;
3068 u32 sw_if_index = ~0;
3071 /* Parse args required to build the message */
3072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3074 if (unformat (i, "sw_if_index %d", &sw_if_index));
3076 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
3081 if (sw_if_index == ~0)
3083 errmsg ("missing interface name or sw_if_index");
3087 M (L2FIB_FLUSH_INT, mp);
3089 mp->sw_if_index = ntohl (sw_if_index);
3097 api_l2fib_add_del (vat_main_t * vam)
3099 unformat_input_t *i = vam->input;
3100 vl_api_l2fib_add_del_t *mp;
3106 u32 sw_if_index = 0;
3107 u8 sw_if_index_set = 0;
3116 /* Parse args required to build the message */
3117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3119 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
3121 else if (unformat (i, "bd_id %d", &bd_id))
3123 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3124 sw_if_index_set = 1;
3125 else if (unformat (i, "sw_if"))
3127 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3130 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3131 sw_if_index_set = 1;
3136 else if (unformat (i, "static"))
3138 else if (unformat (i, "filter"))
3143 else if (unformat (i, "bvi"))
3148 else if (unformat (i, "del"))
3150 else if (unformat (i, "count %d", &count))
3158 errmsg ("missing mac address");
3164 errmsg ("missing bridge domain");
3168 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
3170 errmsg ("missing interface name or sw_if_index");
3176 /* Turn on async mode */
3177 vam->async_mode = 1;
3178 vam->async_errors = 0;
3179 before = vat_time_now (vam);
3182 for (j = 0; j < count; j++)
3184 M (L2FIB_ADD_DEL, mp);
3186 clib_memcpy (mp->mac, mac, 6);
3187 mp->bd_id = ntohl (bd_id);
3188 mp->is_add = is_add;
3189 mp->sw_if_index = ntohl (sw_if_index);
3193 mp->static_mac = static_mac;
3194 mp->filter_mac = filter_mac;
3195 mp->bvi_mac = bvi_mac;
3197 increment_mac_address (mac);
3204 vl_api_control_ping_t *mp_ping;
3207 /* Shut off async mode */
3208 vam->async_mode = 0;
3210 MPING (CONTROL_PING, mp_ping);
3213 timeout = vat_time_now (vam) + 1.0;
3214 while (vat_time_now (vam) < timeout)
3215 if (vam->result_ready == 1)
3220 if (vam->retval == -99)
3223 if (vam->async_errors > 0)
3225 errmsg ("%d asynchronous errors", vam->async_errors);
3228 vam->async_errors = 0;
3229 after = vat_time_now (vam);
3231 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
3232 count, after - before, count / (after - before));
3238 /* Wait for a reply... */
3242 /* Return the good/bad news */
3243 return (vam->retval);
3247 api_bridge_domain_set_mac_age (vat_main_t * vam)
3249 unformat_input_t *i = vam->input;
3250 vl_api_bridge_domain_set_mac_age_t *mp;
3255 /* Parse args required to build the message */
3256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3258 if (unformat (i, "bd_id %d", &bd_id));
3259 else if (unformat (i, "mac-age %d", &mac_age));
3266 errmsg ("missing bridge domain");
3272 errmsg ("mac age must be less than 256 ");
3276 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
3278 mp->bd_id = htonl (bd_id);
3279 mp->mac_age = (u8) mac_age;
3287 api_l2_flags (vat_main_t * vam)
3289 unformat_input_t *i = vam->input;
3290 vl_api_l2_flags_t *mp;
3293 u8 sw_if_index_set = 0;
3297 /* Parse args required to build the message */
3298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3300 if (unformat (i, "sw_if_index %d", &sw_if_index))
3301 sw_if_index_set = 1;
3302 else if (unformat (i, "sw_if"))
3304 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3307 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3308 sw_if_index_set = 1;
3313 else if (unformat (i, "learn"))
3315 else if (unformat (i, "forward"))
3317 else if (unformat (i, "flood"))
3319 else if (unformat (i, "uu-flood"))
3320 flags |= L2_UU_FLOOD;
3321 else if (unformat (i, "arp-term"))
3322 flags |= L2_ARP_TERM;
3323 else if (unformat (i, "off"))
3325 else if (unformat (i, "disable"))
3331 if (sw_if_index_set == 0)
3333 errmsg ("missing interface name or sw_if_index");
3339 mp->sw_if_index = ntohl (sw_if_index);
3340 mp->feature_bitmap = ntohl (flags);
3341 mp->is_set = is_set;
3349 api_bridge_flags (vat_main_t * vam)
3351 unformat_input_t *i = vam->input;
3352 vl_api_bridge_flags_t *mp;
3356 bd_flags_t flags = 0;
3359 /* Parse args required to build the message */
3360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3362 if (unformat (i, "bd_id %d", &bd_id))
3364 else if (unformat (i, "learn"))
3365 flags |= BRIDGE_API_FLAG_LEARN;
3366 else if (unformat (i, "forward"))
3367 flags |= BRIDGE_API_FLAG_FWD;
3368 else if (unformat (i, "flood"))
3369 flags |= BRIDGE_API_FLAG_FLOOD;
3370 else if (unformat (i, "uu-flood"))
3371 flags |= BRIDGE_API_FLAG_UU_FLOOD;
3372 else if (unformat (i, "arp-term"))
3373 flags |= BRIDGE_API_FLAG_ARP_TERM;
3374 else if (unformat (i, "off"))
3376 else if (unformat (i, "disable"))
3384 errmsg ("missing bridge domain");
3388 M (BRIDGE_FLAGS, mp);
3390 mp->bd_id = ntohl (bd_id);
3391 mp->flags = ntohl (flags);
3392 mp->is_set = is_set;
3400 api_bd_ip_mac_add_del (vat_main_t * vam)
3402 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
3403 vl_api_mac_address_t mac = { 0 };
3404 unformat_input_t *i = vam->input;
3405 vl_api_bd_ip_mac_add_del_t *mp;
3414 /* Parse args required to build the message */
3415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3417 if (unformat (i, "bd_id %d", &bd_id))
3421 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
3425 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
3429 else if (unformat (i, "del"))
3437 errmsg ("missing bridge domain");
3440 else if (ip_set == 0)
3442 errmsg ("missing IP address");
3445 else if (mac_set == 0)
3447 errmsg ("missing MAC address");
3451 M (BD_IP_MAC_ADD_DEL, mp);
3453 mp->entry.bd_id = ntohl (bd_id);
3454 mp->is_add = is_add;
3456 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
3457 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
3465 api_bd_ip_mac_flush (vat_main_t * vam)
3467 unformat_input_t *i = vam->input;
3468 vl_api_bd_ip_mac_flush_t *mp;
3473 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3475 if (unformat (i, "bd_id %d", &bd_id))
3485 errmsg ("missing bridge domain");
3489 M (BD_IP_MAC_FLUSH, mp);
3491 mp->bd_id = ntohl (bd_id);
3498 static void vl_api_bd_ip_mac_details_t_handler
3499 (vl_api_bd_ip_mac_details_t * mp)
3501 vat_main_t *vam = &vat_main;
3505 ntohl (mp->entry.bd_id),
3506 format_vl_api_mac_address, mp->entry.mac,
3507 format_vl_api_address, &mp->entry.ip);
3510 static void vl_api_bd_ip_mac_details_t_handler_json
3511 (vl_api_bd_ip_mac_details_t * mp)
3513 vat_main_t *vam = &vat_main;
3514 vat_json_node_t *node = NULL;
3516 if (VAT_JSON_ARRAY != vam->json_tree.type)
3518 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3519 vat_json_init_array (&vam->json_tree);
3521 node = vat_json_array_add (&vam->json_tree);
3523 vat_json_init_object (node);
3524 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
3525 vat_json_object_add_string_copy (node, "mac_address",
3526 format (0, "%U", format_vl_api_mac_address,
3530 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
3531 vat_json_object_add_string_copy (node, "ip_address", ip);
3536 api_bd_ip_mac_dump (vat_main_t * vam)
3538 unformat_input_t *i = vam->input;
3539 vl_api_bd_ip_mac_dump_t *mp;
3540 vl_api_control_ping_t *mp_ping;
3545 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3547 if (unformat (i, "bd_id %d", &bd_id))
3556 "\n%-5s %-7s %-20s %-30s",
3557 "bd_id", "is_ipv6", "mac_address", "ip_address");
3559 /* Dump Bridge Domain Ip to Mac entries */
3560 M (BD_IP_MAC_DUMP, mp);
3563 mp->bd_id = htonl (bd_id);
3569 /* Use a control ping for synchronization */
3570 MPING (CONTROL_PING, mp_ping);
3578 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
3580 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
3583 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
3586 addr->domain = x[0];
3589 addr->function = x[3];
3595 api_ip_table_add_del (vat_main_t * vam)
3597 unformat_input_t *i = vam->input;
3598 vl_api_ip_table_add_del_t *mp;
3604 /* Parse args required to build the message */
3605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3607 if (unformat (i, "ipv6"))
3609 else if (unformat (i, "del"))
3611 else if (unformat (i, "add"))
3613 else if (unformat (i, "table %d", &table_id))
3617 clib_warning ("parse error '%U'", format_unformat_error, i);
3624 errmsg ("missing table-ID");
3628 /* Construct the API message */
3629 M (IP_TABLE_ADD_DEL, mp);
3631 mp->table.table_id = ntohl (table_id);
3632 mp->table.is_ip6 = is_ipv6;
3633 mp->is_add = is_add;
3638 /* Wait for a reply... */
3645 unformat_fib_path (unformat_input_t * input, va_list * args)
3647 vat_main_t *vam = va_arg (*args, vat_main_t *);
3648 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
3649 u32 weight, preference;
3650 mpls_label_t out_label;
3652 clib_memset (path, 0, sizeof (*path));
3654 path->sw_if_index = ~0;
3658 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3660 if (unformat (input, "%U %U",
3661 unformat_vl_api_ip4_address,
3662 &path->nh.address.ip4,
3663 api_unformat_sw_if_index, vam, &path->sw_if_index))
3665 path->proto = FIB_API_PATH_NH_PROTO_IP4;
3667 else if (unformat (input, "%U %U",
3668 unformat_vl_api_ip6_address,
3669 &path->nh.address.ip6,
3670 api_unformat_sw_if_index, vam, &path->sw_if_index))
3672 path->proto = FIB_API_PATH_NH_PROTO_IP6;
3674 else if (unformat (input, "weight %u", &weight))
3676 path->weight = weight;
3678 else if (unformat (input, "preference %u", &preference))
3680 path->preference = preference;
3682 else if (unformat (input, "%U next-hop-table %d",
3683 unformat_vl_api_ip4_address,
3684 &path->nh.address.ip4, &path->table_id))
3686 path->proto = FIB_API_PATH_NH_PROTO_IP4;
3688 else if (unformat (input, "%U next-hop-table %d",
3689 unformat_vl_api_ip6_address,
3690 &path->nh.address.ip6, &path->table_id))
3692 path->proto = FIB_API_PATH_NH_PROTO_IP6;
3694 else if (unformat (input, "%U",
3695 unformat_vl_api_ip4_address, &path->nh.address.ip4))
3698 * the recursive next-hops are by default in the default table
3701 path->sw_if_index = ~0;
3702 path->proto = FIB_API_PATH_NH_PROTO_IP4;
3704 else if (unformat (input, "%U",
3705 unformat_vl_api_ip6_address, &path->nh.address.ip6))
3708 * the recursive next-hops are by default in the default table
3711 path->sw_if_index = ~0;
3712 path->proto = FIB_API_PATH_NH_PROTO_IP6;
3714 else if (unformat (input, "resolve-via-host"))
3716 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
3718 else if (unformat (input, "resolve-via-attached"))
3720 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
3722 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
3724 path->type = FIB_API_PATH_TYPE_LOCAL;
3725 path->sw_if_index = ~0;
3726 path->proto = FIB_API_PATH_NH_PROTO_IP4;
3728 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
3730 path->type = FIB_API_PATH_TYPE_LOCAL;
3731 path->sw_if_index = ~0;
3732 path->proto = FIB_API_PATH_NH_PROTO_IP6;
3734 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
3736 else if (unformat (input, "via-label %d", &path->nh.via_label))
3738 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
3739 path->sw_if_index = ~0;
3741 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
3743 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
3744 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
3746 else if (unformat (input, "local"))
3748 path->type = FIB_API_PATH_TYPE_LOCAL;
3750 else if (unformat (input, "out-labels"))
3752 while (unformat (input, "%d", &out_label))
3754 path->label_stack[path->n_labels].label = out_label;
3755 path->label_stack[path->n_labels].is_uniform = 0;
3756 path->label_stack[path->n_labels].ttl = 64;
3760 else if (unformat (input, "via"))
3762 /* new path, back up and return */
3763 unformat_put_input (input);
3764 unformat_put_input (input);
3765 unformat_put_input (input);
3766 unformat_put_input (input);
3775 path->proto = ntohl (path->proto);
3776 path->type = ntohl (path->type);
3777 path->flags = ntohl (path->flags);
3778 path->table_id = ntohl (path->table_id);
3779 path->sw_if_index = ntohl (path->sw_if_index);
3785 api_ip_route_add_del (vat_main_t * vam)
3787 unformat_input_t *i = vam->input;
3788 vl_api_ip_route_add_del_t *mp;
3791 u8 is_multipath = 0;
3794 vl_api_prefix_t pfx = { };
3795 vl_api_fib_path_t paths[8];
3799 u32 random_add_del = 0;
3800 u32 *random_vector = 0;
3801 u32 random_seed = 0xdeaddabe;
3803 /* Parse args required to build the message */
3804 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3806 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
3808 else if (unformat (i, "del"))
3810 else if (unformat (i, "add"))
3812 else if (unformat (i, "vrf %d", &vrf_id))
3814 else if (unformat (i, "count %d", &count))
3816 else if (unformat (i, "random"))
3818 else if (unformat (i, "multipath"))
3820 else if (unformat (i, "seed %d", &random_seed))
3824 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
3827 if (8 == path_count)
3829 errmsg ("max 8 paths");
3835 clib_warning ("parse error '%U'", format_unformat_error, i);
3842 errmsg ("specify a path; via ...");
3845 if (prefix_set == 0)
3847 errmsg ("missing prefix");
3851 /* Generate a pile of unique, random routes */
3854 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
3855 u32 this_random_address;
3858 random_hash = hash_create (count, sizeof (uword));
3860 hash_set (random_hash, i->as_u32, 1);
3861 for (j = 0; j <= count; j++)
3865 this_random_address = random_u32 (&random_seed);
3866 this_random_address =
3867 clib_host_to_net_u32 (this_random_address);
3869 while (hash_get (random_hash, this_random_address));
3870 vec_add1 (random_vector, this_random_address);
3871 hash_set (random_hash, this_random_address, 1);
3873 hash_free (random_hash);
3874 set_ip4_address (&pfx.address, random_vector[0]);
3879 /* Turn on async mode */
3880 vam->async_mode = 1;
3881 vam->async_errors = 0;
3882 before = vat_time_now (vam);
3885 for (j = 0; j < count; j++)
3887 /* Construct the API message */
3888 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
3890 mp->is_add = is_add;
3891 mp->is_multipath = is_multipath;
3893 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
3894 mp->route.table_id = ntohl (vrf_id);
3895 mp->route.n_paths = path_count;
3897 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
3900 set_ip4_address (&pfx.address, random_vector[j + 1]);
3902 increment_address (&pfx.address);
3905 /* If we receive SIGTERM, stop now... */
3910 /* When testing multiple add/del ops, use a control-ping to sync */
3913 vl_api_control_ping_t *mp_ping;
3917 /* Shut off async mode */
3918 vam->async_mode = 0;
3920 MPING (CONTROL_PING, mp_ping);
3923 timeout = vat_time_now (vam) + 1.0;
3924 while (vat_time_now (vam) < timeout)
3925 if (vam->result_ready == 1)
3930 if (vam->retval == -99)
3933 if (vam->async_errors > 0)
3935 errmsg ("%d asynchronous errors", vam->async_errors);
3938 vam->async_errors = 0;
3939 after = vat_time_now (vam);
3941 /* slim chance, but we might have eaten SIGTERM on the first iteration */
3945 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
3946 count, after - before, count / (after - before));
3952 /* Wait for a reply... */
3957 /* Return the good/bad news */
3958 return (vam->retval);
3962 api_ip_mroute_add_del (vat_main_t * vam)
3964 unformat_input_t *i = vam->input;
3965 u8 path_set = 0, prefix_set = 0, is_add = 1;
3966 vl_api_ip_mroute_add_del_t *mp;
3967 mfib_entry_flags_t eflags = 0;
3968 vl_api_mfib_path_t path;
3969 vl_api_mprefix_t pfx = { };
3973 /* Parse args required to build the message */
3974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3976 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
3979 pfx.grp_address_length = htons (pfx.grp_address_length);
3981 else if (unformat (i, "del"))
3983 else if (unformat (i, "add"))
3985 else if (unformat (i, "vrf %d", &vrf_id))
3987 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
3988 path.itf_flags = htonl (path.itf_flags);
3989 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
3991 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
3995 clib_warning ("parse error '%U'", format_unformat_error, i);
4000 if (prefix_set == 0)
4002 errmsg ("missing addresses\n");
4007 errmsg ("missing path\n");
4011 /* Construct the API message */
4012 M (IP_MROUTE_ADD_DEL, mp);
4014 mp->is_add = is_add;
4015 mp->is_multipath = 1;
4017 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
4018 mp->route.table_id = htonl (vrf_id);
4019 mp->route.n_paths = 1;
4020 mp->route.entry_flags = htonl (eflags);
4022 clib_memcpy (&mp->route.paths, &path, sizeof (path));
4026 /* Wait for a reply... */
4032 api_sw_interface_set_unnumbered (vat_main_t * vam)
4034 unformat_input_t *i = vam->input;
4035 vl_api_sw_interface_set_unnumbered_t *mp;
4037 u32 unnum_sw_index = ~0;
4039 u8 sw_if_index_set = 0;
4042 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4044 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4045 sw_if_index_set = 1;
4046 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4047 sw_if_index_set = 1;
4048 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4050 else if (unformat (i, "del"))
4054 clib_warning ("parse error '%U'", format_unformat_error, i);
4059 if (sw_if_index_set == 0)
4061 errmsg ("missing interface name or sw_if_index");
4065 M (SW_INTERFACE_SET_UNNUMBERED, mp);
4067 mp->sw_if_index = ntohl (sw_if_index);
4068 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
4069 mp->is_add = is_add;
4078 api_create_vlan_subif (vat_main_t * vam)
4080 unformat_input_t *i = vam->input;
4081 vl_api_create_vlan_subif_t *mp;
4083 u8 sw_if_index_set = 0;
4088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4090 if (unformat (i, "sw_if_index %d", &sw_if_index))
4091 sw_if_index_set = 1;
4093 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4094 sw_if_index_set = 1;
4095 else if (unformat (i, "vlan %d", &vlan_id))
4099 clib_warning ("parse error '%U'", format_unformat_error, i);
4104 if (sw_if_index_set == 0)
4106 errmsg ("missing interface name or sw_if_index");
4110 if (vlan_id_set == 0)
4112 errmsg ("missing vlan_id");
4115 M (CREATE_VLAN_SUBIF, mp);
4117 mp->sw_if_index = ntohl (sw_if_index);
4118 mp->vlan_id = ntohl (vlan_id);
4125 #define foreach_create_subif_bit \
4132 _(outer_vlan_id_any) \
4133 _(inner_vlan_id_any)
4135 #define foreach_create_subif_flag \
4140 _(4, "exact_match") \
4141 _(5, "default_sub") \
4142 _(6, "outer_vlan_id_any") \
4143 _(7, "inner_vlan_id_any")
4146 api_create_subif (vat_main_t * vam)
4148 unformat_input_t *i = vam->input;
4149 vl_api_create_subif_t *mp;
4151 u8 sw_if_index_set = 0;
4154 u32 __attribute__ ((unused)) no_tags = 0;
4155 u32 __attribute__ ((unused)) one_tag = 0;
4156 u32 __attribute__ ((unused)) two_tags = 0;
4157 u32 __attribute__ ((unused)) dot1ad = 0;
4158 u32 __attribute__ ((unused)) exact_match = 0;
4159 u32 __attribute__ ((unused)) default_sub = 0;
4160 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
4161 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
4163 u16 outer_vlan_id = 0;
4164 u16 inner_vlan_id = 0;
4167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4169 if (unformat (i, "sw_if_index %d", &sw_if_index))
4170 sw_if_index_set = 1;
4172 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4173 sw_if_index_set = 1;
4174 else if (unformat (i, "sub_id %d", &sub_id))
4176 else if (unformat (i, "outer_vlan_id %d", &tmp))
4177 outer_vlan_id = tmp;
4178 else if (unformat (i, "inner_vlan_id %d", &tmp))
4179 inner_vlan_id = tmp;
4181 #define _(a) else if (unformat (i, #a)) a = 1 ;
4182 foreach_create_subif_bit
4186 clib_warning ("parse error '%U'", format_unformat_error, i);
4191 if (sw_if_index_set == 0)
4193 errmsg ("missing interface name or sw_if_index");
4197 if (sub_id_set == 0)
4199 errmsg ("missing sub_id");
4202 M (CREATE_SUBIF, mp);
4204 mp->sw_if_index = ntohl (sw_if_index);
4205 mp->sub_id = ntohl (sub_id);
4207 #define _(a,b) mp->sub_if_flags |= (1 << a);
4208 foreach_create_subif_flag;
4211 mp->outer_vlan_id = ntohs (outer_vlan_id);
4212 mp->inner_vlan_id = ntohs (inner_vlan_id);
4220 api_ip_table_replace_begin (vat_main_t * vam)
4222 unformat_input_t *i = vam->input;
4223 vl_api_ip_table_replace_begin_t *mp;
4228 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4230 if (unformat (i, "table %d", &table_id))
4232 else if (unformat (i, "ipv6"))
4236 clib_warning ("parse error '%U'", format_unformat_error, i);
4241 M (IP_TABLE_REPLACE_BEGIN, mp);
4243 mp->table.table_id = ntohl (table_id);
4244 mp->table.is_ip6 = is_ipv6;
4252 api_ip_table_flush (vat_main_t * vam)
4254 unformat_input_t *i = vam->input;
4255 vl_api_ip_table_flush_t *mp;
4260 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4262 if (unformat (i, "table %d", &table_id))
4264 else if (unformat (i, "ipv6"))
4268 clib_warning ("parse error '%U'", format_unformat_error, i);
4273 M (IP_TABLE_FLUSH, mp);
4275 mp->table.table_id = ntohl (table_id);
4276 mp->table.is_ip6 = is_ipv6;
4284 api_ip_table_replace_end (vat_main_t * vam)
4286 unformat_input_t *i = vam->input;
4287 vl_api_ip_table_replace_end_t *mp;
4292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4294 if (unformat (i, "table %d", &table_id))
4296 else if (unformat (i, "ipv6"))
4300 clib_warning ("parse error '%U'", format_unformat_error, i);
4305 M (IP_TABLE_REPLACE_END, mp);
4307 mp->table.table_id = ntohl (table_id);
4308 mp->table.is_ip6 = is_ipv6;
4316 api_set_ip_flow_hash (vat_main_t * vam)
4318 unformat_input_t *i = vam->input;
4319 vl_api_set_ip_flow_hash_t *mp;
4331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4333 if (unformat (i, "vrf %d", &vrf_id))
4335 else if (unformat (i, "ipv6"))
4337 else if (unformat (i, "src"))
4339 else if (unformat (i, "dst"))
4341 else if (unformat (i, "sport"))
4343 else if (unformat (i, "dport"))
4345 else if (unformat (i, "proto"))
4347 else if (unformat (i, "reverse"))
4352 clib_warning ("parse error '%U'", format_unformat_error, i);
4357 if (vrf_id_set == 0)
4359 errmsg ("missing vrf id");
4363 M (SET_IP_FLOW_HASH, mp);
4369 mp->reverse = reverse;
4370 mp->vrf_id = ntohl (vrf_id);
4371 mp->is_ipv6 = is_ipv6;
4379 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
4381 unformat_input_t *i = vam->input;
4382 vl_api_sw_interface_ip6_enable_disable_t *mp;
4384 u8 sw_if_index_set = 0;
4388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4390 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4391 sw_if_index_set = 1;
4392 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4393 sw_if_index_set = 1;
4394 else if (unformat (i, "enable"))
4396 else if (unformat (i, "disable"))
4400 clib_warning ("parse error '%U'", format_unformat_error, i);
4405 if (sw_if_index_set == 0)
4407 errmsg ("missing interface name or sw_if_index");
4411 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
4413 mp->sw_if_index = ntohl (sw_if_index);
4414 mp->enable = enable;
4423 api_l2_patch_add_del (vat_main_t * vam)
4425 unformat_input_t *i = vam->input;
4426 vl_api_l2_patch_add_del_t *mp;
4428 u8 rx_sw_if_index_set = 0;
4430 u8 tx_sw_if_index_set = 0;
4434 /* Parse args required to build the message */
4435 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4437 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4438 rx_sw_if_index_set = 1;
4439 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4440 tx_sw_if_index_set = 1;
4441 else if (unformat (i, "rx"))
4443 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4445 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4447 rx_sw_if_index_set = 1;
4452 else if (unformat (i, "tx"))
4454 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4456 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
4458 tx_sw_if_index_set = 1;
4463 else if (unformat (i, "del"))
4469 if (rx_sw_if_index_set == 0)
4471 errmsg ("missing rx interface name or rx_sw_if_index");
4475 if (tx_sw_if_index_set == 0)
4477 errmsg ("missing tx interface name or tx_sw_if_index");
4481 M (L2_PATCH_ADD_DEL, mp);
4483 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4484 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4485 mp->is_add = is_add;
4493 u8 localsid_addr[16];
4502 api_ioam_enable (vat_main_t * vam)
4504 unformat_input_t *input = vam->input;
4505 vl_api_ioam_enable_t *mp;
4507 int has_trace_option = 0;
4508 int has_pot_option = 0;
4509 int has_seqno_option = 0;
4510 int has_analyse_option = 0;
4513 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4515 if (unformat (input, "trace"))
4516 has_trace_option = 1;
4517 else if (unformat (input, "pot"))
4519 else if (unformat (input, "seqno"))
4520 has_seqno_option = 1;
4521 else if (unformat (input, "analyse"))
4522 has_analyse_option = 1;
4526 M (IOAM_ENABLE, mp);
4527 mp->id = htons (id);
4528 mp->seqno = has_seqno_option;
4529 mp->analyse = has_analyse_option;
4530 mp->pot_enable = has_pot_option;
4531 mp->trace_enable = has_trace_option;
4540 api_ioam_disable (vat_main_t * vam)
4542 vl_api_ioam_disable_t *mp;
4545 M (IOAM_DISABLE, mp);
4551 #define foreach_tcp_proto_field \
4555 #define foreach_udp_proto_field \
4559 #define foreach_ip4_proto_field \
4571 u16 src_port, dst_port;
4574 #if VPP_API_TEST_BUILTIN == 0
4576 unformat_tcp_mask (unformat_input_t * input, va_list * args)
4578 u8 **maskp = va_arg (*args, u8 **);
4580 u8 found_something = 0;
4583 #define _(a) u8 a=0;
4584 foreach_tcp_proto_field;
4587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4590 #define _(a) else if (unformat (input, #a)) a=1;
4591 foreach_tcp_proto_field
4597 #define _(a) found_something += a;
4598 foreach_tcp_proto_field;
4601 if (found_something == 0)
4604 vec_validate (mask, sizeof (*tcp) - 1);
4606 tcp = (tcp_header_t *) mask;
4608 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
4609 foreach_tcp_proto_field;
4617 unformat_udp_mask (unformat_input_t * input, va_list * args)
4619 u8 **maskp = va_arg (*args, u8 **);
4621 u8 found_something = 0;
4624 #define _(a) u8 a=0;
4625 foreach_udp_proto_field;
4628 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4631 #define _(a) else if (unformat (input, #a)) a=1;
4632 foreach_udp_proto_field
4638 #define _(a) found_something += a;
4639 foreach_udp_proto_field;
4642 if (found_something == 0)
4645 vec_validate (mask, sizeof (*udp) - 1);
4647 udp = (udp_header_t *) mask;
4649 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
4650 foreach_udp_proto_field;
4658 unformat_l4_mask (unformat_input_t * input, va_list * args)
4660 u8 **maskp = va_arg (*args, u8 **);
4661 u16 src_port = 0, dst_port = 0;
4662 tcpudp_header_t *tcpudp;
4664 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4666 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
4668 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
4670 else if (unformat (input, "src_port"))
4672 else if (unformat (input, "dst_port"))
4678 if (!src_port && !dst_port)
4682 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
4684 tcpudp = (tcpudp_header_t *) mask;
4685 tcpudp->src_port = src_port;
4686 tcpudp->dst_port = dst_port;
4694 unformat_ip4_mask (unformat_input_t * input, va_list * args)
4696 u8 **maskp = va_arg (*args, u8 **);
4698 u8 found_something = 0;
4701 #define _(a) u8 a=0;
4702 foreach_ip4_proto_field;
4708 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4710 if (unformat (input, "version"))
4712 else if (unformat (input, "hdr_length"))
4714 else if (unformat (input, "src"))
4716 else if (unformat (input, "dst"))
4718 else if (unformat (input, "proto"))
4721 #define _(a) else if (unformat (input, #a)) a=1;
4722 foreach_ip4_proto_field
4728 #define _(a) found_something += a;
4729 foreach_ip4_proto_field;
4732 if (found_something == 0)
4735 vec_validate (mask, sizeof (*ip) - 1);
4737 ip = (ip4_header_t *) mask;
4739 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
4740 foreach_ip4_proto_field;
4743 ip->ip_version_and_header_length = 0;
4746 ip->ip_version_and_header_length |= 0xF0;
4749 ip->ip_version_and_header_length |= 0x0F;
4755 #define foreach_ip6_proto_field \
4763 unformat_ip6_mask (unformat_input_t * input, va_list * args)
4765 u8 **maskp = va_arg (*args, u8 **);
4767 u8 found_something = 0;
4769 u32 ip_version_traffic_class_and_flow_label;
4771 #define _(a) u8 a=0;
4772 foreach_ip6_proto_field;
4775 u8 traffic_class = 0;
4778 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4780 if (unformat (input, "version"))
4782 else if (unformat (input, "traffic-class"))
4784 else if (unformat (input, "flow-label"))
4786 else if (unformat (input, "src"))
4788 else if (unformat (input, "dst"))
4790 else if (unformat (input, "proto"))
4793 #define _(a) else if (unformat (input, #a)) a=1;
4794 foreach_ip6_proto_field
4800 #define _(a) found_something += a;
4801 foreach_ip6_proto_field;
4804 if (found_something == 0)
4807 vec_validate (mask, sizeof (*ip) - 1);
4809 ip = (ip6_header_t *) mask;
4811 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
4812 foreach_ip6_proto_field;
4815 ip_version_traffic_class_and_flow_label = 0;
4818 ip_version_traffic_class_and_flow_label |= 0xF0000000;
4821 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
4824 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
4826 ip->ip_version_traffic_class_and_flow_label =
4827 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
4834 unformat_l3_mask (unformat_input_t * input, va_list * args)
4836 u8 **maskp = va_arg (*args, u8 **);
4838 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4840 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
4842 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
4851 unformat_l2_mask (unformat_input_t * input, va_list * args)
4853 u8 **maskp = va_arg (*args, u8 **);
4868 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4870 if (unformat (input, "src"))
4872 else if (unformat (input, "dst"))
4874 else if (unformat (input, "proto"))
4876 else if (unformat (input, "tag1"))
4878 else if (unformat (input, "tag2"))
4880 else if (unformat (input, "ignore-tag1"))
4882 else if (unformat (input, "ignore-tag2"))
4884 else if (unformat (input, "cos1"))
4886 else if (unformat (input, "cos2"))
4888 else if (unformat (input, "dot1q"))
4890 else if (unformat (input, "dot1ad"))
4895 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
4896 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
4899 if (tag1 || ignore_tag1 || cos1 || dot1q)
4901 if (tag2 || ignore_tag2 || cos2 || dot1ad)
4904 vec_validate (mask, len - 1);
4907 clib_memset (mask, 0xff, 6);
4910 clib_memset (mask + 6, 0xff, 6);
4914 /* inner vlan tag */
4923 mask[21] = mask[20] = 0xff;
4944 mask[16] = mask[17] = 0xff;
4954 mask[12] = mask[13] = 0xff;
4961 unformat_classify_mask (unformat_input_t * input, va_list * args)
4963 u8 **maskp = va_arg (*args, u8 **);
4964 u32 *skipp = va_arg (*args, u32 *);
4965 u32 *matchp = va_arg (*args, u32 *);
4973 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
4975 if (unformat (input, "hex %U", unformat_hex_string, &mask))
4977 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
4979 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
4981 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
4995 if (mask || l2 || l3 || l4)
4999 /* "With a free Ethernet header in every package" */
5001 vec_validate (l2, 13);
5005 vec_append (mask, l3);
5010 vec_append (mask, l4);
5015 /* Scan forward looking for the first significant mask octet */
5016 for (i = 0; i < vec_len (mask); i++)
5020 /* compute (skip, match) params */
5021 *skipp = i / sizeof (u32x4);
5022 vec_delete (mask, *skipp * sizeof (u32x4), 0);
5024 /* Pad mask to an even multiple of the vector size */
5025 while (vec_len (mask) % sizeof (u32x4))
5028 match = vec_len (mask) / sizeof (u32x4);
5030 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
5032 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
5033 if (*tmp || *(tmp + 1))
5038 clib_warning ("BUG: match 0");
5040 _vec_len (mask) = match * sizeof (u32x4);
5050 #endif /* VPP_API_TEST_BUILTIN */
5052 #define foreach_l2_next \
5054 _(ethernet, ETHERNET_INPUT) \
5059 unformat_l2_next_index (unformat_input_t * input, va_list * args)
5061 u32 *miss_next_indexp = va_arg (*args, u32 *);
5066 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
5070 if (unformat (input, "%d", &tmp))
5079 *miss_next_indexp = next_index;
5083 #define foreach_ip_next \
5089 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
5091 u32 *miss_next_indexp = va_arg (*args, u32 *);
5096 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
5100 if (unformat (input, "%d", &tmp))
5109 *miss_next_indexp = next_index;
5113 #define foreach_acl_next \
5117 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
5119 u32 *miss_next_indexp = va_arg (*args, u32 *);
5124 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
5128 if (unformat (input, "permit"))
5133 else if (unformat (input, "%d", &tmp))
5142 *miss_next_indexp = next_index;
5147 unformat_policer_precolor (unformat_input_t * input, va_list * args)
5149 u32 *r = va_arg (*args, u32 *);
5151 if (unformat (input, "conform-color"))
5152 *r = POLICE_CONFORM;
5153 else if (unformat (input, "exceed-color"))
5161 #if VPP_API_TEST_BUILTIN == 0
5163 unformat_l4_match (unformat_input_t * input, va_list * args)
5165 u8 **matchp = va_arg (*args, u8 **);
5167 u8 *proto_header = 0;
5173 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5175 if (unformat (input, "src_port %d", &src_port))
5177 else if (unformat (input, "dst_port %d", &dst_port))
5183 h.src_port = clib_host_to_net_u16 (src_port);
5184 h.dst_port = clib_host_to_net_u16 (dst_port);
5185 vec_validate (proto_header, sizeof (h) - 1);
5186 memcpy (proto_header, &h, sizeof (h));
5188 *matchp = proto_header;
5194 unformat_ip4_match (unformat_input_t * input, va_list * args)
5196 u8 **matchp = va_arg (*args, u8 **);
5203 int src = 0, dst = 0;
5204 ip4_address_t src_val, dst_val;
5211 int fragment_id = 0;
5212 u32 fragment_id_val;
5218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5220 if (unformat (input, "version %d", &version_val))
5222 else if (unformat (input, "hdr_length %d", &hdr_length_val))
5224 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
5226 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
5228 else if (unformat (input, "proto %d", &proto_val))
5230 else if (unformat (input, "tos %d", &tos_val))
5232 else if (unformat (input, "length %d", &length_val))
5234 else if (unformat (input, "fragment_id %d", &fragment_id_val))
5236 else if (unformat (input, "ttl %d", &ttl_val))
5238 else if (unformat (input, "checksum %d", &checksum_val))
5244 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
5245 + ttl + checksum == 0)
5249 * Aligned because we use the real comparison functions
5251 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
5253 ip = (ip4_header_t *) match;
5255 /* These are realistically matched in practice */
5257 ip->src_address.as_u32 = src_val.as_u32;
5260 ip->dst_address.as_u32 = dst_val.as_u32;
5263 ip->protocol = proto_val;
5266 /* These are not, but they're included for completeness */
5268 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
5271 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
5277 ip->length = clib_host_to_net_u16 (length_val);
5283 ip->checksum = clib_host_to_net_u16 (checksum_val);
5290 unformat_ip6_match (unformat_input_t * input, va_list * args)
5292 u8 **matchp = va_arg (*args, u8 **);
5297 u8 traffic_class = 0;
5298 u32 traffic_class_val = 0;
5301 int src = 0, dst = 0;
5302 ip6_address_t src_val, dst_val;
5305 int payload_length = 0;
5306 u32 payload_length_val;
5309 u32 ip_version_traffic_class_and_flow_label;
5311 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5313 if (unformat (input, "version %d", &version_val))
5315 else if (unformat (input, "traffic_class %d", &traffic_class_val))
5317 else if (unformat (input, "flow_label %d", &flow_label_val))
5319 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
5321 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
5323 else if (unformat (input, "proto %d", &proto_val))
5325 else if (unformat (input, "payload_length %d", &payload_length_val))
5327 else if (unformat (input, "hop_limit %d", &hop_limit_val))
5333 if (version + traffic_class + flow_label + src + dst + proto +
5334 payload_length + hop_limit == 0)
5338 * Aligned because we use the real comparison functions
5340 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
5342 ip = (ip6_header_t *) match;
5345 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
5348 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
5351 ip->protocol = proto_val;
5353 ip_version_traffic_class_and_flow_label = 0;
5356 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
5359 ip_version_traffic_class_and_flow_label |=
5360 (traffic_class_val & 0xFF) << 20;
5363 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
5365 ip->ip_version_traffic_class_and_flow_label =
5366 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
5369 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
5372 ip->hop_limit = hop_limit_val;
5379 unformat_l3_match (unformat_input_t * input, va_list * args)
5381 u8 **matchp = va_arg (*args, u8 **);
5383 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5385 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
5387 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
5396 unformat_vlan_tag (unformat_input_t * input, va_list * args)
5398 u8 *tagp = va_arg (*args, u8 *);
5401 if (unformat (input, "%d", &tag))
5403 tagp[0] = (tag >> 8) & 0x0F;
5404 tagp[1] = tag & 0xFF;
5412 unformat_l2_match (unformat_input_t * input, va_list * args)
5414 u8 **matchp = va_arg (*args, u8 **);
5434 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5436 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
5439 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
5441 else if (unformat (input, "proto %U",
5442 unformat_ethernet_type_host_byte_order, &proto_val))
5444 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
5446 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
5448 else if (unformat (input, "ignore-tag1"))
5450 else if (unformat (input, "ignore-tag2"))
5452 else if (unformat (input, "cos1 %d", &cos1_val))
5454 else if (unformat (input, "cos2 %d", &cos2_val))
5459 if ((src + dst + proto + tag1 + tag2 +
5460 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
5463 if (tag1 || ignore_tag1 || cos1)
5465 if (tag2 || ignore_tag2 || cos2)
5468 vec_validate_aligned (match, len - 1, sizeof (u32x4));
5471 clib_memcpy (match, dst_val, 6);
5474 clib_memcpy (match + 6, src_val, 6);
5478 /* inner vlan tag */
5479 match[19] = tag2_val[1];
5480 match[18] = tag2_val[0];
5482 match[18] |= (cos2_val & 0x7) << 5;
5485 match[21] = proto_val & 0xff;
5486 match[20] = proto_val >> 8;
5490 match[15] = tag1_val[1];
5491 match[14] = tag1_val[0];
5494 match[14] |= (cos1_val & 0x7) << 5;
5500 match[15] = tag1_val[1];
5501 match[14] = tag1_val[0];
5504 match[17] = proto_val & 0xff;
5505 match[16] = proto_val >> 8;
5508 match[14] |= (cos1_val & 0x7) << 5;
5514 match[18] |= (cos2_val & 0x7) << 5;
5516 match[14] |= (cos1_val & 0x7) << 5;
5519 match[13] = proto_val & 0xff;
5520 match[12] = proto_val >> 8;
5528 unformat_qos_source (unformat_input_t * input, va_list * args)
5530 int *qs = va_arg (*args, int *);
5532 if (unformat (input, "ip"))
5533 *qs = QOS_SOURCE_IP;
5534 else if (unformat (input, "mpls"))
5535 *qs = QOS_SOURCE_MPLS;
5536 else if (unformat (input, "ext"))
5537 *qs = QOS_SOURCE_EXT;
5538 else if (unformat (input, "vlan"))
5539 *qs = QOS_SOURCE_VLAN;
5548 api_unformat_classify_match (unformat_input_t * input, va_list * args)
5550 u8 **matchp = va_arg (*args, u8 **);
5551 u32 skip_n_vectors = va_arg (*args, u32);
5552 u32 match_n_vectors = va_arg (*args, u32);
5559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5561 if (unformat (input, "hex %U", unformat_hex_string, &match))
5563 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
5565 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
5567 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
5581 if (match || l2 || l3 || l4)
5585 /* "Win a free Ethernet header in every packet" */
5587 vec_validate_aligned (l2, 13, sizeof (u32x4));
5591 vec_append_aligned (match, l3, sizeof (u32x4));
5596 vec_append_aligned (match, l4, sizeof (u32x4));
5601 /* Make sure the vector is big enough even if key is all 0's */
5602 vec_validate_aligned
5603 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
5606 /* Set size, include skipped vectors */
5607 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
5618 api_get_node_index (vat_main_t * vam)
5620 unformat_input_t *i = vam->input;
5621 vl_api_get_node_index_t *mp;
5625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5627 if (unformat (i, "node %s", &name))
5634 errmsg ("node name required");
5637 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
5639 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
5643 M (GET_NODE_INDEX, mp);
5644 clib_memcpy (mp->node_name, name, vec_len (name));
5653 api_get_next_index (vat_main_t * vam)
5655 unformat_input_t *i = vam->input;
5656 vl_api_get_next_index_t *mp;
5657 u8 *node_name = 0, *next_node_name = 0;
5660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5662 if (unformat (i, "node-name %s", &node_name))
5664 else if (unformat (i, "next-node-name %s", &next_node_name))
5670 errmsg ("node name required");
5673 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
5675 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
5679 if (next_node_name == 0)
5681 errmsg ("next node name required");
5684 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
5686 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
5690 M (GET_NEXT_INDEX, mp);
5691 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
5692 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
5693 vec_free (node_name);
5694 vec_free (next_node_name);
5702 api_add_node_next (vat_main_t * vam)
5704 unformat_input_t *i = vam->input;
5705 vl_api_add_node_next_t *mp;
5710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5712 if (unformat (i, "node %s", &name))
5714 else if (unformat (i, "next %s", &next))
5721 errmsg ("node name required");
5724 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
5726 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
5731 errmsg ("next node required");
5734 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
5736 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
5740 M (ADD_NODE_NEXT, mp);
5741 clib_memcpy (mp->node_name, name, vec_len (name));
5742 clib_memcpy (mp->next_name, next, vec_len (next));
5752 api_l2_fib_clear_table (vat_main_t * vam)
5754 // unformat_input_t * i = vam->input;
5755 vl_api_l2_fib_clear_table_t *mp;
5758 M (L2_FIB_CLEAR_TABLE, mp);
5766 api_l2_interface_efp_filter (vat_main_t * vam)
5768 unformat_input_t *i = vam->input;
5769 vl_api_l2_interface_efp_filter_t *mp;
5772 u8 sw_if_index_set = 0;
5775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5777 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5778 sw_if_index_set = 1;
5779 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5780 sw_if_index_set = 1;
5781 else if (unformat (i, "enable"))
5783 else if (unformat (i, "disable"))
5787 clib_warning ("parse error '%U'", format_unformat_error, i);
5792 if (sw_if_index_set == 0)
5794 errmsg ("missing sw_if_index");
5798 M (L2_INTERFACE_EFP_FILTER, mp);
5800 mp->sw_if_index = ntohl (sw_if_index);
5801 mp->enable_disable = enable;
5808 #define foreach_vtr_op \
5809 _("disable", L2_VTR_DISABLED) \
5810 _("push-1", L2_VTR_PUSH_1) \
5811 _("push-2", L2_VTR_PUSH_2) \
5812 _("pop-1", L2_VTR_POP_1) \
5813 _("pop-2", L2_VTR_POP_2) \
5814 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
5815 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
5816 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
5817 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
5820 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
5822 unformat_input_t *i = vam->input;
5823 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
5825 u8 sw_if_index_set = 0;
5833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5835 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5836 sw_if_index_set = 1;
5837 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5838 sw_if_index_set = 1;
5839 else if (unformat (i, "vtr_op %d", &vtr_op))
5841 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
5844 else if (unformat (i, "push_dot1q %d", &push_dot1q))
5846 else if (unformat (i, "tag1 %d", &tag1))
5848 else if (unformat (i, "tag2 %d", &tag2))
5852 clib_warning ("parse error '%U'", format_unformat_error, i);
5857 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
5859 errmsg ("missing vtr operation or sw_if_index");
5863 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
5864 mp->sw_if_index = ntohl (sw_if_index);
5865 mp->vtr_op = ntohl (vtr_op);
5866 mp->push_dot1q = ntohl (push_dot1q);
5867 mp->tag1 = ntohl (tag1);
5868 mp->tag2 = ntohl (tag2);
5876 api_show_version (vat_main_t *vam)
5878 vl_api_show_version_t *mp;
5881 M (SHOW_VERSION, mp);
5889 vl_api_l2_fib_table_details_t_handler (vl_api_l2_fib_table_details_t *mp)
5891 vat_main_t *vam = &vat_main;
5894 "%3" PRIu32 " %U %3" PRIu32 " %d %d %d",
5895 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
5896 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac, mp->bvi_mac);
5900 vl_api_l2_fib_table_details_t_handler_json (vl_api_l2_fib_table_details_t *mp)
5902 vat_main_t *vam = &vat_main;
5903 vat_json_node_t *node = NULL;
5905 if (VAT_JSON_ARRAY != vam->json_tree.type)
5907 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5908 vat_json_init_array (&vam->json_tree);
5910 node = vat_json_array_add (&vam->json_tree);
5912 vat_json_init_object (node);
5913 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
5914 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
5915 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5916 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
5917 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
5918 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
5922 api_l2_fib_table_dump (vat_main_t *vam)
5924 unformat_input_t *i = vam->input;
5925 vl_api_l2_fib_table_dump_t *mp;
5926 vl_api_control_ping_t *mp_ping;
5931 /* Parse args required to build the message */
5932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5934 if (unformat (i, "bd_id %d", &bd_id))
5942 errmsg ("missing bridge domain");
5946 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
5948 /* Get list of l2 fib entries */
5949 M (L2_FIB_TABLE_DUMP, mp);
5951 mp->bd_id = ntohl (bd_id);
5954 /* Use a control ping for synchronization */
5955 MPING (CONTROL_PING, mp_ping);
5963 api_interface_name_renumber (vat_main_t *vam)
5965 unformat_input_t *line_input = vam->input;
5966 vl_api_interface_name_renumber_t *mp;
5967 u32 sw_if_index = ~0;
5968 u32 new_show_dev_instance = ~0;
5971 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
5973 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
5976 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
5978 else if (unformat (line_input, "new_show_dev_instance %d",
5979 &new_show_dev_instance))
5985 if (sw_if_index == ~0)
5987 errmsg ("missing interface name or sw_if_index");
5991 if (new_show_dev_instance == ~0)
5993 errmsg ("missing new_show_dev_instance");
5997 M (INTERFACE_NAME_RENUMBER, mp);
5999 mp->sw_if_index = ntohl (sw_if_index);
6000 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
6008 api_want_l2_macs_events (vat_main_t *vam)
6010 unformat_input_t *line_input = vam->input;
6011 vl_api_want_l2_macs_events_t *mp;
6012 u8 enable_disable = 1;
6014 u32 max_macs_in_event = 0;
6015 u32 learn_limit = 0;
6018 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
6020 if (unformat (line_input, "learn-limit %d", &learn_limit))
6022 else if (unformat (line_input, "scan-delay %d", &scan_delay))
6024 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
6026 else if (unformat (line_input, "disable"))
6032 M (WANT_L2_MACS_EVENTS, mp);
6033 mp->enable_disable = enable_disable;
6034 mp->pid = htonl (getpid ());
6035 mp->learn_limit = htonl (learn_limit);
6036 mp->scan_delay = (u8) scan_delay;
6037 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
6044 api_ip_address_dump (vat_main_t *vam)
6046 unformat_input_t *i = vam->input;
6047 vl_api_ip_address_dump_t *mp;
6048 vl_api_control_ping_t *mp_ping;
6049 u32 sw_if_index = ~0;
6050 u8 sw_if_index_set = 0;
6055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6057 if (unformat (i, "sw_if_index %d", &sw_if_index))
6058 sw_if_index_set = 1;
6059 else if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6060 sw_if_index_set = 1;
6061 else if (unformat (i, "ipv4"))
6063 else if (unformat (i, "ipv6"))
6069 if (ipv4_set && ipv6_set)
6071 errmsg ("ipv4 and ipv6 flags cannot be both set");
6075 if ((!ipv4_set) && (!ipv6_set))
6077 errmsg ("no ipv4 nor ipv6 flag set");
6081 if (sw_if_index_set == 0)
6083 errmsg ("missing interface name or sw_if_index");
6087 vam->current_sw_if_index = sw_if_index;
6088 vam->is_ipv6 = ipv6_set;
6090 M (IP_ADDRESS_DUMP, mp);
6091 mp->sw_if_index = ntohl (sw_if_index);
6092 mp->is_ipv6 = ipv6_set;
6095 /* Use a control ping for synchronization */
6096 MPING (CONTROL_PING, mp_ping);
6104 api_ip_dump (vat_main_t * vam)
6106 vl_api_ip_dump_t *mp;
6107 vl_api_control_ping_t *mp_ping;
6108 unformat_input_t *in = vam->input;
6115 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
6117 if (unformat (in, "ipv4"))
6119 else if (unformat (in, "ipv6"))
6125 if (ipv4_set && ipv6_set)
6127 errmsg ("ipv4 and ipv6 flags cannot be both set");
6131 if ((!ipv4_set) && (!ipv6_set))
6133 errmsg ("no ipv4 nor ipv6 flag set");
6138 vam->is_ipv6 = is_ipv6;
6141 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
6143 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
6145 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
6148 mp->is_ipv6 = ipv6_set;
6151 /* Use a control ping for synchronization */
6152 MPING (CONTROL_PING, mp_ping);
6160 api_get_first_msg_id (vat_main_t * vam)
6162 vl_api_get_first_msg_id_t *mp;
6163 unformat_input_t *i = vam->input;
6168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6170 if (unformat (i, "client %s", &name))
6178 errmsg ("missing client name");
6183 if (vec_len (name) > 63)
6185 errmsg ("client name too long");
6189 M (GET_FIRST_MSG_ID, mp);
6190 clib_memcpy (mp->name, name, vec_len (name));
6197 api_get_node_graph (vat_main_t * vam)
6199 vl_api_get_node_graph_t *mp;
6202 M (GET_NODE_GRAPH, mp);
6206 /* Wait for the reply */
6212 format_fib_api_path_nh_proto (u8 * s, va_list * args)
6214 vl_api_fib_path_nh_proto_t proto =
6215 va_arg (*args, vl_api_fib_path_nh_proto_t);
6219 case FIB_API_PATH_NH_PROTO_IP4:
6220 s = format (s, "ip4");
6222 case FIB_API_PATH_NH_PROTO_IP6:
6223 s = format (s, "ip6");
6225 case FIB_API_PATH_NH_PROTO_MPLS:
6226 s = format (s, "mpls");
6228 case FIB_API_PATH_NH_PROTO_BIER:
6229 s = format (s, "bier");
6231 case FIB_API_PATH_NH_PROTO_ETHERNET:
6232 s = format (s, "ethernet");
6240 format_vl_api_ip_address_union (u8 * s, va_list * args)
6242 vl_api_address_family_t af = va_arg (*args, int);
6243 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
6248 s = format (s, "%U", format_ip4_address, u->ip4);
6251 s = format (s, "%U", format_ip6_address, u->ip6);
6258 format_vl_api_fib_path_type (u8 * s, va_list * args)
6260 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
6264 case FIB_API_PATH_TYPE_NORMAL:
6265 s = format (s, "normal");
6267 case FIB_API_PATH_TYPE_LOCAL:
6268 s = format (s, "local");
6270 case FIB_API_PATH_TYPE_DROP:
6271 s = format (s, "drop");
6273 case FIB_API_PATH_TYPE_UDP_ENCAP:
6274 s = format (s, "udp-encap");
6276 case FIB_API_PATH_TYPE_BIER_IMP:
6277 s = format (s, "bier-imp");
6279 case FIB_API_PATH_TYPE_ICMP_UNREACH:
6280 s = format (s, "unreach");
6282 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
6283 s = format (s, "prohibit");
6285 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
6286 s = format (s, "src-lookup");
6288 case FIB_API_PATH_TYPE_DVR:
6289 s = format (s, "dvr");
6291 case FIB_API_PATH_TYPE_INTERFACE_RX:
6292 s = format (s, "interface-rx");
6294 case FIB_API_PATH_TYPE_CLASSIFY:
6295 s = format (s, "classify");
6303 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
6306 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
6307 ntohl (fp->weight), ntohl (fp->sw_if_index),
6308 format_vl_api_fib_path_type, fp->type,
6309 format_fib_api_path_nh_proto, fp->proto,
6310 format_vl_api_ip_address_union, &fp->nh.address);
6314 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
6315 vl_api_fib_path_t * fp)
6318 struct in6_addr ip6;
6320 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
6321 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
6322 vat_json_object_add_uint (node, "type", fp->type);
6323 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
6324 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
6326 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
6327 vat_json_object_add_ip4 (node, "next_hop", ip4);
6329 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
6331 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
6332 vat_json_object_add_ip6 (node, "next_hop", ip6);
6336 #define vl_api_ip_table_details_t_endian vl_noop_handler
6337 #define vl_api_ip_table_details_t_print vl_noop_handler
6340 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
6342 vat_main_t *vam = &vat_main;
6345 "%s; table-id %d, prefix %U/%d",
6346 mp->table.name, ntohl (mp->table.table_id));
6350 static void vl_api_ip_table_details_t_handler_json
6351 (vl_api_ip_table_details_t * mp)
6353 vat_main_t *vam = &vat_main;
6354 vat_json_node_t *node = NULL;
6356 if (VAT_JSON_ARRAY != vam->json_tree.type)
6358 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6359 vat_json_init_array (&vam->json_tree);
6361 node = vat_json_array_add (&vam->json_tree);
6363 vat_json_init_object (node);
6364 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
6368 api_ip_table_dump (vat_main_t * vam)
6370 vl_api_ip_table_dump_t *mp;
6371 vl_api_control_ping_t *mp_ping;
6374 M (IP_TABLE_DUMP, mp);
6377 /* Use a control ping for synchronization */
6378 MPING (CONTROL_PING, mp_ping);
6386 api_ip_mtable_dump (vat_main_t * vam)
6388 vl_api_ip_mtable_dump_t *mp;
6389 vl_api_control_ping_t *mp_ping;
6392 M (IP_MTABLE_DUMP, mp);
6395 /* Use a control ping for synchronization */
6396 MPING (CONTROL_PING, mp_ping);
6404 api_ip_mroute_dump (vat_main_t * vam)
6406 unformat_input_t *input = vam->input;
6407 vl_api_control_ping_t *mp_ping;
6408 vl_api_ip_mroute_dump_t *mp;
6413 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6415 if (unformat (input, "table_id %d", &table_id))
6417 else if (unformat (input, "ip6"))
6419 else if (unformat (input, "ip4"))
6426 errmsg ("missing table id");
6430 M (IP_MROUTE_DUMP, mp);
6431 mp->table.table_id = table_id;
6432 mp->table.is_ip6 = is_ip6;
6435 /* Use a control ping for synchronization */
6436 MPING (CONTROL_PING, mp_ping);
6443 #define vl_api_ip_route_details_t_endian vl_noop_handler
6444 #define vl_api_ip_route_details_t_print vl_noop_handler
6447 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
6449 vat_main_t *vam = &vat_main;
6450 u8 count = mp->route.n_paths;
6451 vl_api_fib_path_t *fp;
6455 "table-id %d, prefix %U/%d",
6456 ntohl (mp->route.table_id),
6457 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
6458 for (i = 0; i < count; i++)
6460 fp = &mp->route.paths[i];
6462 vl_api_fib_path_print (vam, fp);
6467 static void vl_api_ip_route_details_t_handler_json
6468 (vl_api_ip_route_details_t * mp)
6470 vat_main_t *vam = &vat_main;
6471 u8 count = mp->route.n_paths;
6472 vat_json_node_t *node = NULL;
6474 struct in6_addr ip6;
6475 vl_api_fib_path_t *fp;
6478 if (VAT_JSON_ARRAY != vam->json_tree.type)
6480 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6481 vat_json_init_array (&vam->json_tree);
6483 node = vat_json_array_add (&vam->json_tree);
6485 vat_json_init_object (node);
6486 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
6487 if (ADDRESS_IP6 == mp->route.prefix.address.af)
6489 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
6490 vat_json_object_add_ip6 (node, "prefix", ip6);
6494 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
6495 vat_json_object_add_ip4 (node, "prefix", ip4);
6497 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
6498 vat_json_object_add_uint (node, "path_count", count);
6499 for (i = 0; i < count; i++)
6501 fp = &mp->route.paths[i];
6502 vl_api_mpls_fib_path_json_print (node, fp);
6507 api_ip_route_dump (vat_main_t * vam)
6509 unformat_input_t *input = vam->input;
6510 vl_api_ip_route_dump_t *mp;
6511 vl_api_control_ping_t *mp_ping;
6517 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6519 if (unformat (input, "table_id %d", &table_id))
6521 else if (unformat (input, "ip6"))
6523 else if (unformat (input, "ip4"))
6530 errmsg ("missing table id");
6534 M (IP_ROUTE_DUMP, mp);
6536 mp->table.table_id = table_id;
6537 mp->table.is_ip6 = is_ip6;
6541 /* Use a control ping for synchronization */
6542 MPING (CONTROL_PING, mp_ping);
6550 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
6552 unformat_input_t *input = vam->input;
6553 vl_api_ip_source_and_port_range_check_add_del_t *mp;
6556 u16 *high_ports = 0;
6559 vl_api_prefix_t prefix;
6566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6568 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
6570 else if (unformat (input, "vrf %d", &vrf_id))
6572 else if (unformat (input, "del"))
6574 else if (unformat (input, "port %d", &tmp))
6576 if (tmp == 0 || tmp > 65535)
6578 errmsg ("port %d out of range", tmp);
6582 this_hi = this_low + 1;
6583 vec_add1 (low_ports, this_low);
6584 vec_add1 (high_ports, this_hi);
6586 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
6588 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
6590 errmsg ("incorrect range parameters");
6594 /* Note: in debug CLI +1 is added to high before
6595 passing to real fn that does "the work"
6596 (ip_source_and_port_range_check_add_del).
6597 This fn is a wrapper around the binary API fn a
6598 control plane will call, which expects this increment
6599 to have occurred. Hence letting the binary API control
6600 plane fn do the increment for consistency between VAT
6601 and other control planes.
6604 vec_add1 (low_ports, this_low);
6605 vec_add1 (high_ports, this_hi);
6611 if (prefix_set == 0)
6613 errmsg ("<address>/<mask> not specified");
6619 errmsg ("VRF ID required, not specified");
6626 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
6630 if (vec_len (low_ports) == 0)
6632 errmsg ("At least one port or port range required");
6636 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
6638 mp->is_add = is_add;
6640 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
6642 mp->number_of_ranges = vec_len (low_ports);
6644 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
6645 vec_free (low_ports);
6647 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
6648 vec_free (high_ports);
6650 mp->vrf_id = ntohl (vrf_id);
6658 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
6660 unformat_input_t *input = vam->input;
6661 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
6662 u32 sw_if_index = ~0;
6664 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
6665 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
6669 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6671 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6673 else if (unformat (input, "sw_if_index %d", &sw_if_index))
6675 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
6677 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
6679 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
6681 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
6683 else if (unformat (input, "del"))
6689 if (sw_if_index == ~0)
6691 errmsg ("Interface required but not specified");
6697 errmsg ("VRF ID required but not specified");
6701 if (tcp_out_vrf_id == 0
6702 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
6705 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
6709 /* Construct the API message */
6710 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
6712 mp->sw_if_index = ntohl (sw_if_index);
6713 mp->is_add = is_add;
6714 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
6715 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
6716 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
6717 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
6722 /* Wait for a reply... */
6728 api_delete_subif (vat_main_t * vam)
6730 unformat_input_t *i = vam->input;
6731 vl_api_delete_subif_t *mp;
6732 u32 sw_if_index = ~0;
6735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6737 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6739 if (unformat (i, "sw_if_index %d", &sw_if_index))
6745 if (sw_if_index == ~0)
6747 errmsg ("missing sw_if_index");
6751 /* Construct the API message */
6752 M (DELETE_SUBIF, mp);
6753 mp->sw_if_index = ntohl (sw_if_index);
6760 #define foreach_pbb_vtr_op \
6761 _("disable", L2_VTR_DISABLED) \
6762 _("pop", L2_VTR_POP_2) \
6763 _("push", L2_VTR_PUSH_2)
6766 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
6768 unformat_input_t *i = vam->input;
6769 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
6770 u32 sw_if_index = ~0, vtr_op = ~0;
6772 u8 dmac[6], smac[6];
6773 u8 dmac_set = 0, smac_set = 0;
6779 /* Shut up coverity */
6780 clib_memset (dmac, 0, sizeof (dmac));
6781 clib_memset (smac, 0, sizeof (smac));
6783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6785 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6787 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6789 else if (unformat (i, "vtr_op %d", &vtr_op))
6791 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
6794 else if (unformat (i, "translate_pbb_stag"))
6796 if (unformat (i, "%d", &tmp))
6798 vtr_op = L2_VTR_TRANSLATE_2_1;
6804 ("translate_pbb_stag operation requires outer tag definition");
6808 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
6810 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
6812 else if (unformat (i, "sid %d", &sid))
6814 else if (unformat (i, "vlanid %d", &tmp))
6818 clib_warning ("parse error '%U'", format_unformat_error, i);
6823 if ((sw_if_index == ~0) || (vtr_op == ~0))
6825 errmsg ("missing sw_if_index or vtr operation");
6828 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
6829 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
6832 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
6836 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
6837 mp->sw_if_index = ntohl (sw_if_index);
6838 mp->vtr_op = ntohl (vtr_op);
6839 mp->outer_tag = ntohs (outer_tag);
6840 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
6841 clib_memcpy (mp->b_smac, smac, sizeof (smac));
6842 mp->b_vlanid = ntohs (vlanid);
6843 mp->i_sid = ntohl (sid);
6851 api_sw_interface_tag_add_del (vat_main_t * vam)
6853 unformat_input_t *i = vam->input;
6854 vl_api_sw_interface_tag_add_del_t *mp;
6855 u32 sw_if_index = ~0;
6860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6862 if (unformat (i, "tag %s", &tag))
6864 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6866 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6868 else if (unformat (i, "del"))
6874 if (sw_if_index == ~0)
6876 errmsg ("missing interface name or sw_if_index");
6880 if (enable && (tag == 0))
6882 errmsg ("no tag specified");
6886 /* Construct the API message */
6887 M (SW_INTERFACE_TAG_ADD_DEL, mp);
6888 mp->sw_if_index = ntohl (sw_if_index);
6889 mp->is_add = enable;
6891 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
6900 api_sw_interface_add_del_mac_address (vat_main_t * vam)
6902 unformat_input_t *i = vam->input;
6903 vl_api_mac_address_t mac = { 0 };
6904 vl_api_sw_interface_add_del_mac_address_t *mp;
6905 u32 sw_if_index = ~0;
6910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6914 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6916 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
6918 else if (unformat (i, "del"))
6924 if (sw_if_index == ~0)
6926 errmsg ("missing interface name or sw_if_index");
6932 errmsg ("missing MAC address");
6936 /* Construct the API message */
6937 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
6938 mp->sw_if_index = ntohl (sw_if_index);
6939 mp->is_add = is_add;
6940 clib_memcpy (&mp->addr, &mac, sizeof (mac));
6947 static void vl_api_l2_xconnect_details_t_handler
6948 (vl_api_l2_xconnect_details_t * mp)
6950 vat_main_t *vam = &vat_main;
6952 print (vam->ofp, "%15d%15d",
6953 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
6956 static void vl_api_l2_xconnect_details_t_handler_json
6957 (vl_api_l2_xconnect_details_t * mp)
6959 vat_main_t *vam = &vat_main;
6960 vat_json_node_t *node = NULL;
6962 if (VAT_JSON_ARRAY != vam->json_tree.type)
6964 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6965 vat_json_init_array (&vam->json_tree);
6967 node = vat_json_array_add (&vam->json_tree);
6969 vat_json_init_object (node);
6970 vat_json_object_add_uint (node, "rx_sw_if_index",
6971 ntohl (mp->rx_sw_if_index));
6972 vat_json_object_add_uint (node, "tx_sw_if_index",
6973 ntohl (mp->tx_sw_if_index));
6977 api_l2_xconnect_dump (vat_main_t * vam)
6979 vl_api_l2_xconnect_dump_t *mp;
6980 vl_api_control_ping_t *mp_ping;
6983 if (!vam->json_output)
6985 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
6988 M (L2_XCONNECT_DUMP, mp);
6992 /* Use a control ping for synchronization */
6993 MPING (CONTROL_PING, mp_ping);
7001 api_hw_interface_set_mtu (vat_main_t * vam)
7003 unformat_input_t *i = vam->input;
7004 vl_api_hw_interface_set_mtu_t *mp;
7005 u32 sw_if_index = ~0;
7009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7011 if (unformat (i, "mtu %d", &mtu))
7013 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7015 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7021 if (sw_if_index == ~0)
7023 errmsg ("missing interface name or sw_if_index");
7029 errmsg ("no mtu specified");
7033 /* Construct the API message */
7034 M (HW_INTERFACE_SET_MTU, mp);
7035 mp->sw_if_index = ntohl (sw_if_index);
7036 mp->mtu = ntohs ((u16) mtu);
7043 static void vl_api_app_namespace_add_del_reply_t_handler
7044 (vl_api_app_namespace_add_del_reply_t * mp)
7046 vat_main_t *vam = &vat_main;
7047 i32 retval = ntohl (mp->retval);
7048 if (vam->async_mode)
7050 vam->async_errors += (retval < 0);
7054 vam->retval = retval;
7056 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
7057 vam->result_ready = 1;
7061 static void vl_api_app_namespace_add_del_reply_t_handler_json
7062 (vl_api_app_namespace_add_del_reply_t * mp)
7064 vat_main_t *vam = &vat_main;
7065 vat_json_node_t node;
7067 vat_json_init_object (&node);
7068 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
7069 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
7071 vat_json_print (vam->ofp, &node);
7072 vat_json_free (&node);
7074 vam->retval = ntohl (mp->retval);
7075 vam->result_ready = 1;
7079 api_app_namespace_add_del (vat_main_t * vam)
7081 vl_api_app_namespace_add_del_t *mp;
7082 unformat_input_t *i = vam->input;
7083 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
7084 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
7088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7090 if (unformat (i, "id %_%v%_", &ns_id))
7092 else if (unformat (i, "secret %lu", &secret))
7094 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7095 sw_if_index_set = 1;
7096 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
7098 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
7103 if (!ns_id || !secret_set || !sw_if_index_set)
7105 errmsg ("namespace id, secret and sw_if_index must be set");
7108 if (vec_len (ns_id) > 64)
7110 errmsg ("namespace id too long");
7113 M (APP_NAMESPACE_ADD_DEL, mp);
7115 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
7116 mp->secret = clib_host_to_net_u64 (secret);
7117 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
7118 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
7119 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
7127 api_sock_init_shm (vat_main_t * vam)
7129 #if VPP_API_TEST_BUILTIN == 0
7130 unformat_input_t *i = vam->input;
7131 vl_api_shm_elem_config_t *config = 0;
7132 u64 size = 64 << 20;
7135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7137 if (unformat (i, "size %U", unformat_memory_size, &size))
7144 * Canned custom ring allocator config.
7145 * Should probably parse all of this
7147 vec_validate (config, 6);
7148 config[0].type = VL_API_VLIB_RING;
7149 config[0].size = 256;
7150 config[0].count = 32;
7152 config[1].type = VL_API_VLIB_RING;
7153 config[1].size = 1024;
7154 config[1].count = 16;
7156 config[2].type = VL_API_VLIB_RING;
7157 config[2].size = 4096;
7158 config[2].count = 2;
7160 config[3].type = VL_API_CLIENT_RING;
7161 config[3].size = 256;
7162 config[3].count = 32;
7164 config[4].type = VL_API_CLIENT_RING;
7165 config[4].size = 1024;
7166 config[4].count = 16;
7168 config[5].type = VL_API_CLIENT_RING;
7169 config[5].size = 4096;
7170 config[5].count = 2;
7172 config[6].type = VL_API_QUEUE;
7173 config[6].count = 128;
7174 config[6].size = sizeof (uword);
7176 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
7178 vam->client_index_invalid = 1;
7186 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
7188 vat_main_t *vam = &vat_main;
7189 fib_prefix_t lcl, rmt;
7191 ip_prefix_decode (&mp->lcl, &lcl);
7192 ip_prefix_decode (&mp->rmt, &rmt);
7194 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
7197 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
7198 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
7199 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
7200 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
7201 &rmt.fp_addr.ip4, rmt.fp_len,
7202 clib_net_to_host_u16 (mp->rmt_port),
7203 clib_net_to_host_u32 (mp->action_index), mp->tag);
7208 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
7209 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
7210 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
7211 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
7212 &rmt.fp_addr.ip6, rmt.fp_len,
7213 clib_net_to_host_u16 (mp->rmt_port),
7214 clib_net_to_host_u32 (mp->action_index), mp->tag);
7219 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
7222 vat_main_t *vam = &vat_main;
7223 vat_json_node_t *node = NULL;
7224 struct in6_addr ip6;
7227 fib_prefix_t lcl, rmt;
7229 ip_prefix_decode (&mp->lcl, &lcl);
7230 ip_prefix_decode (&mp->rmt, &rmt);
7232 if (VAT_JSON_ARRAY != vam->json_tree.type)
7234 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7235 vat_json_init_array (&vam->json_tree);
7237 node = vat_json_array_add (&vam->json_tree);
7238 vat_json_init_object (node);
7240 vat_json_object_add_uint (node, "appns_index",
7241 clib_net_to_host_u32 (mp->appns_index));
7242 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
7243 vat_json_object_add_uint (node, "scope", mp->scope);
7244 vat_json_object_add_uint (node, "action_index",
7245 clib_net_to_host_u32 (mp->action_index));
7246 vat_json_object_add_uint (node, "lcl_port",
7247 clib_net_to_host_u16 (mp->lcl_port));
7248 vat_json_object_add_uint (node, "rmt_port",
7249 clib_net_to_host_u16 (mp->rmt_port));
7250 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
7251 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
7252 vat_json_object_add_string_copy (node, "tag", mp->tag);
7253 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
7255 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
7256 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
7257 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
7258 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
7262 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
7263 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
7264 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
7265 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
7270 api_session_rule_add_del (vat_main_t * vam)
7272 vl_api_session_rule_add_del_t *mp;
7273 unformat_input_t *i = vam->input;
7274 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
7275 u32 appns_index = 0, scope = 0;
7276 ip4_address_t lcl_ip4, rmt_ip4;
7277 ip6_address_t lcl_ip6, rmt_ip6;
7278 u8 is_ip4 = 1, conn_set = 0;
7279 u8 is_add = 1, *tag = 0;
7281 fib_prefix_t lcl, rmt;
7283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7285 if (unformat (i, "del"))
7287 else if (unformat (i, "add"))
7289 else if (unformat (i, "proto tcp"))
7291 else if (unformat (i, "proto udp"))
7293 else if (unformat (i, "appns %d", &appns_index))
7295 else if (unformat (i, "scope %d", &scope))
7297 else if (unformat (i, "tag %_%v%_", &tag))
7301 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
7302 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
7310 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
7311 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
7317 else if (unformat (i, "action %d", &action))
7322 if (proto == ~0 || !conn_set || action == ~0)
7324 errmsg ("transport proto, connection and action must be set");
7330 errmsg ("scope should be 0-3");
7334 M (SESSION_RULE_ADD_DEL, mp);
7336 clib_memset (&lcl, 0, sizeof (lcl));
7337 clib_memset (&rmt, 0, sizeof (rmt));
7340 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
7341 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
7342 lcl.fp_len = lcl_plen;
7343 rmt.fp_len = rmt_plen;
7347 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
7348 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
7349 lcl.fp_len = lcl_plen;
7350 rmt.fp_len = rmt_plen;
7354 ip_prefix_encode (&lcl, &mp->lcl);
7355 ip_prefix_encode (&rmt, &mp->rmt);
7356 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
7357 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
7358 mp->transport_proto =
7359 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
7360 mp->action_index = clib_host_to_net_u32 (action);
7361 mp->appns_index = clib_host_to_net_u32 (appns_index);
7363 mp->is_add = is_add;
7366 clib_memcpy (mp->tag, tag, vec_len (tag));
7376 api_session_rules_dump (vat_main_t * vam)
7378 vl_api_session_rules_dump_t *mp;
7379 vl_api_control_ping_t *mp_ping;
7382 if (!vam->json_output)
7384 print (vam->ofp, "%=20s", "Session Rules");
7387 M (SESSION_RULES_DUMP, mp);
7391 /* Use a control ping for synchronization */
7392 MPING (CONTROL_PING, mp_ping);
7395 /* Wait for a reply... */
7401 api_ip_container_proxy_add_del (vat_main_t * vam)
7403 vl_api_ip_container_proxy_add_del_t *mp;
7404 unformat_input_t *i = vam->input;
7405 u32 sw_if_index = ~0;
7406 vl_api_prefix_t pfx = { };
7410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7412 if (unformat (i, "del"))
7414 else if (unformat (i, "add"))
7416 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
7418 else if (unformat (i, "sw_if_index %u", &sw_if_index))
7423 if (sw_if_index == ~0 || pfx.len == 0)
7425 errmsg ("address and sw_if_index must be set");
7429 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
7431 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
7432 mp->is_add = is_add;
7433 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
7441 q_or_quit (vat_main_t * vam)
7443 #if VPP_API_TEST_BUILTIN == 0
7444 longjmp (vam->jump_buf, 1);
7446 return 0; /* not so much */
7450 q (vat_main_t * vam)
7452 return q_or_quit (vam);
7456 quit (vat_main_t * vam)
7458 return q_or_quit (vam);
7462 comment (vat_main_t * vam)
7468 elog_save (vat_main_t * vam)
7470 #if VPP_API_TEST_BUILTIN == 0
7471 elog_main_t *em = &vam->elog_main;
7472 unformat_input_t *i = vam->input;
7473 char *file, *chroot_file;
7474 clib_error_t *error;
7476 if (!unformat (i, "%s", &file))
7478 errmsg ("expected file name, got `%U'", format_unformat_error, i);
7482 /* It's fairly hard to get "../oopsie" through unformat; just in case */
7483 if (strstr (file, "..") || index (file, '/'))
7485 errmsg ("illegal characters in filename '%s'", file);
7489 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
7493 errmsg ("Saving %wd of %wd events to %s",
7494 elog_n_events_in_buffer (em),
7495 elog_buffer_capacity (em), chroot_file);
7497 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
7498 vec_free (chroot_file);
7501 clib_error_report (error);
7503 errmsg ("Use the vpp event loger...");
7510 elog_setup (vat_main_t * vam)
7512 #if VPP_API_TEST_BUILTIN == 0
7513 elog_main_t *em = &vam->elog_main;
7514 unformat_input_t *i = vam->input;
7515 u32 nevents = 128 << 10;
7517 (void) unformat (i, "nevents %d", &nevents);
7519 elog_init (em, nevents);
7520 vl_api_set_elog_main (em);
7521 vl_api_set_elog_trace_api_messages (1);
7522 errmsg ("Event logger initialized with %u events", nevents);
7524 errmsg ("Use the vpp event loger...");
7530 elog_enable (vat_main_t * vam)
7532 #if VPP_API_TEST_BUILTIN == 0
7533 elog_main_t *em = &vam->elog_main;
7535 elog_enable_disable (em, 1 /* enable */ );
7536 vl_api_set_elog_trace_api_messages (1);
7537 errmsg ("Event logger enabled...");
7539 errmsg ("Use the vpp event loger...");
7545 elog_disable (vat_main_t * vam)
7547 #if VPP_API_TEST_BUILTIN == 0
7548 elog_main_t *em = &vam->elog_main;
7550 elog_enable_disable (em, 0 /* enable */ );
7551 vl_api_set_elog_trace_api_messages (1);
7552 errmsg ("Event logger disabled...");
7554 errmsg ("Use the vpp event loger...");
7560 statseg (vat_main_t * vam)
7562 ssvm_private_t *ssvmp = &vam->stat_segment;
7563 ssvm_shared_header_t *shared_header = ssvmp->sh;
7564 vlib_counter_t **counters;
7565 u64 thread0_index1_packets;
7566 u64 thread0_index1_bytes;
7567 f64 vector_rate, input_rate;
7570 uword *counter_vector_by_name;
7571 if (vam->stat_segment_lockp == 0)
7573 errmsg ("Stat segment not mapped...");
7577 /* look up "/if/rx for sw_if_index 1 as a test */
7579 clib_spinlock_lock (vam->stat_segment_lockp);
7581 counter_vector_by_name = (uword *) shared_header->opaque[1];
7583 p = hash_get_mem (counter_vector_by_name, "/if/rx");
7586 clib_spinlock_unlock (vam->stat_segment_lockp);
7587 errmsg ("/if/tx not found?");
7591 /* Fish per-thread vector of combined counters from shared memory */
7592 counters = (vlib_counter_t **) p[0];
7594 if (vec_len (counters[0]) < 2)
7596 clib_spinlock_unlock (vam->stat_segment_lockp);
7597 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
7601 /* Read thread 0 sw_if_index 1 counter */
7602 thread0_index1_packets = counters[0][1].packets;
7603 thread0_index1_bytes = counters[0][1].bytes;
7605 p = hash_get_mem (counter_vector_by_name, "vector_rate");
7608 clib_spinlock_unlock (vam->stat_segment_lockp);
7609 errmsg ("vector_rate not found?");
7613 vector_rate = *(f64 *) (p[0]);
7614 p = hash_get_mem (counter_vector_by_name, "input_rate");
7617 clib_spinlock_unlock (vam->stat_segment_lockp);
7618 errmsg ("input_rate not found?");
7621 input_rate = *(f64 *) (p[0]);
7623 clib_spinlock_unlock (vam->stat_segment_lockp);
7625 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
7626 vector_rate, input_rate);
7627 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
7628 thread0_index1_packets, thread0_index1_bytes);
7634 cmd_cmp (void *a1, void *a2)
7639 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
7643 help (vat_main_t * vam)
7648 unformat_input_t *i = vam->input;
7651 if (unformat (i, "%s", &name))
7657 hs = hash_get_mem (vam->help_by_name, name);
7659 print (vam->ofp, "usage: %s %s", name, hs[0]);
7661 print (vam->ofp, "No such msg / command '%s'", name);
7666 print (vam->ofp, "Help is available for the following:");
7669 hash_foreach_pair (p, vam->function_by_name,
7671 vec_add1 (cmds, (u8 *)(p->key));
7675 vec_sort_with_function (cmds, cmd_cmp);
7677 for (j = 0; j < vec_len (cmds); j++)
7678 print (vam->ofp, "%s", cmds[j]);
7685 set (vat_main_t * vam)
7687 u8 *name = 0, *value = 0;
7688 unformat_input_t *i = vam->input;
7690 if (unformat (i, "%s", &name))
7692 /* The input buffer is a vector, not a string. */
7693 value = vec_dup (i->buffer);
7694 vec_delete (value, i->index, 0);
7695 /* Almost certainly has a trailing newline */
7696 if (value[vec_len (value) - 1] == '\n')
7697 value[vec_len (value) - 1] = 0;
7698 /* Make sure it's a proper string, one way or the other */
7699 vec_add1 (value, 0);
7700 (void) clib_macro_set_value (&vam->macro_main,
7701 (char *) name, (char *) value);
7704 errmsg ("usage: set <name> <value>");
7712 unset (vat_main_t * vam)
7716 if (unformat (vam->input, "%s", &name))
7717 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
7718 errmsg ("unset: %s wasn't set", name);
7731 macro_sort_cmp (void *a1, void *a2)
7733 macro_sort_t *s1 = a1;
7734 macro_sort_t *s2 = a2;
7736 return strcmp ((char *) (s1->name), (char *) (s2->name));
7740 dump_macro_table (vat_main_t * vam)
7742 macro_sort_t *sort_me = 0, *sm;
7747 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
7749 vec_add2 (sort_me, sm, 1);
7750 sm->name = (u8 *)(p->key);
7751 sm->value = (u8 *) (p->value[0]);
7755 vec_sort_with_function (sort_me, macro_sort_cmp);
7757 if (vec_len (sort_me))
7758 print (vam->ofp, "%-15s%s", "Name", "Value");
7760 print (vam->ofp, "The macro table is empty...");
7762 for (i = 0; i < vec_len (sort_me); i++)
7763 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
7768 dump_node_table (vat_main_t * vam)
7771 vlib_node_t *node, *next_node;
7773 if (vec_len (vam->graph_nodes) == 0)
7775 print (vam->ofp, "Node table empty, issue get_node_graph...");
7779 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
7781 node = vam->graph_nodes[0][i];
7782 print (vam->ofp, "[%d] %s", i, node->name);
7783 for (j = 0; j < vec_len (node->next_nodes); j++)
7785 if (node->next_nodes[j] != ~0)
7787 next_node = vam->graph_nodes[0][node->next_nodes[j]];
7788 print (vam->ofp, " [%d] %s", j, next_node->name);
7796 value_sort_cmp (void *a1, void *a2)
7798 name_sort_t *n1 = a1;
7799 name_sort_t *n2 = a2;
7801 if (n1->value < n2->value)
7803 if (n1->value > n2->value)
7810 dump_msg_api_table (vat_main_t * vam)
7812 api_main_t *am = vlibapi_get_main ();
7813 name_sort_t *nses = 0, *ns;
7818 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
7820 vec_add2 (nses, ns, 1);
7821 ns->name = (u8 *)(hp->key);
7822 ns->value = (u32) hp->value[0];
7826 vec_sort_with_function (nses, value_sort_cmp);
7828 for (i = 0; i < vec_len (nses); i++)
7829 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
7835 get_msg_id (vat_main_t * vam)
7840 if (unformat (vam->input, "%s", &name_and_crc))
7842 message_index = vl_msg_api_get_msg_index (name_and_crc);
7843 if (message_index == ~0)
7845 print (vam->ofp, " '%s' not found", name_and_crc);
7848 print (vam->ofp, " '%s' has message index %d",
7849 name_and_crc, message_index);
7852 errmsg ("name_and_crc required...");
7857 search_node_table (vat_main_t * vam)
7859 unformat_input_t *line_input = vam->input;
7862 vlib_node_t *node, *next_node;
7865 if (vam->graph_node_index_by_name == 0)
7867 print (vam->ofp, "Node table empty, issue get_node_graph...");
7871 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
7873 if (unformat (line_input, "%s", &node_to_find))
7875 vec_add1 (node_to_find, 0);
7876 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
7879 print (vam->ofp, "%s not found...", node_to_find);
7882 node = vam->graph_nodes[0][p[0]];
7883 print (vam->ofp, "[%d] %s", p[0], node->name);
7884 for (j = 0; j < vec_len (node->next_nodes); j++)
7886 if (node->next_nodes[j] != ~0)
7888 next_node = vam->graph_nodes[0][node->next_nodes[j]];
7889 print (vam->ofp, " [%d] %s", j, next_node->name);
7896 clib_warning ("parse error '%U'", format_unformat_error,
7902 vec_free (node_to_find);
7911 script (vat_main_t * vam)
7913 #if (VPP_API_TEST_BUILTIN==0)
7915 char *save_current_file;
7916 unformat_input_t save_input;
7917 jmp_buf save_jump_buf;
7918 u32 save_line_number;
7920 FILE *new_fp, *save_ifp;
7922 if (unformat (vam->input, "%s", &s))
7924 new_fp = fopen ((char *) s, "r");
7927 errmsg ("Couldn't open script file %s", s);
7934 errmsg ("Missing script name");
7938 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
7939 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
7940 save_ifp = vam->ifp;
7941 save_line_number = vam->input_line_number;
7942 save_current_file = (char *) vam->current_file;
7944 vam->input_line_number = 0;
7946 vam->current_file = s;
7949 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
7950 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
7951 vam->ifp = save_ifp;
7952 vam->input_line_number = save_line_number;
7953 vam->current_file = (u8 *) save_current_file;
7958 clib_warning ("use the exec command...");
7964 echo (vat_main_t * vam)
7966 print (vam->ofp, "%v", vam->input->buffer);
7970 /* List of API message constructors, CLI names map to api_xxx */
7971 #define foreach_vpe_api_msg \
7972 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
7973 _(sw_interface_dump,"") \
7974 _(sw_interface_set_flags, \
7975 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
7976 _(sw_interface_add_del_address, \
7977 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
7978 _(sw_interface_set_rx_mode, \
7979 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
7980 _(sw_interface_set_rx_placement, \
7981 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
7982 _(sw_interface_rx_placement_dump, \
7983 "[<intfc> | sw_if_index <id>]") \
7984 _(sw_interface_set_table, \
7985 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
7986 _(sw_interface_set_vpath, \
7987 "<intfc> | sw_if_index <id> enable | disable") \
7988 _(sw_interface_set_l2_xconnect, \
7989 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
7990 "enable | disable") \
7991 _(sw_interface_set_l2_bridge, \
7992 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
7993 "[shg <split-horizon-group>] [bvi]\n" \
7994 "enable | disable") \
7995 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
7996 _(bridge_domain_add_del, \
7997 "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") \
7998 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
8000 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
8001 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
8002 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
8004 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
8006 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
8007 _(ip_table_add_del, \
8008 "table <n> [ipv6] [add | del]\n") \
8009 _(ip_route_add_del, \
8010 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
8011 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
8012 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
8013 "[multipath] [count <n>] [del]") \
8014 _(ip_mroute_add_del, \
8015 "<src> <grp>/<mask> [table-id <n>]\n" \
8016 "[<intfc> | sw_if_index <id>] [local] [del]") \
8017 _(sw_interface_set_unnumbered, \
8018 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
8019 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
8020 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
8021 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
8022 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
8023 "[outer_vlan_id_any][inner_vlan_id_any]") \
8024 _(ip_table_replace_begin, "table <n> [ipv6]") \
8025 _(ip_table_flush, "table <n> [ipv6]") \
8026 _(ip_table_replace_end, "table <n> [ipv6]") \
8027 _(set_ip_flow_hash, \
8028 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
8029 _(sw_interface_ip6_enable_disable, \
8030 "<intfc> | sw_if_index <id> enable | disable") \
8031 _(l2_patch_add_del, \
8032 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
8033 "enable | disable") \
8034 _(get_node_index, "node <node-name") \
8035 _(add_node_next, "node <node-name> next <next-node-name>") \
8036 _(l2_fib_clear_table, "") \
8037 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
8038 _(l2_interface_vlan_tag_rewrite, \
8039 "<intfc> | sw_if_index <nn> \n" \
8040 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
8041 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
8042 _(show_version, "") \
8043 _(show_threads, "") \
8044 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
8045 _(interface_name_renumber, \
8046 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
8047 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
8048 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
8049 _(ip_dump, "ipv4 | ipv6") \
8050 _(delete_loopback,"sw_if_index <nn>") \
8051 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
8052 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
8053 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
8054 _(want_interface_events, "enable|disable") \
8055 _(get_first_msg_id, "client <name>") \
8056 _(get_node_graph, " ") \
8057 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
8058 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
8059 _(ioam_disable, "") \
8060 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
8061 _(ip_source_and_port_range_check_add_del, \
8062 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
8063 _(ip_source_and_port_range_check_interface_add_del, \
8064 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
8065 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
8066 _(delete_subif,"<intfc> | sw_if_index <nn>") \
8067 _(l2_interface_pbb_tag_rewrite, \
8068 "<intfc> | sw_if_index <nn> \n" \
8069 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
8070 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
8071 _(ip_table_dump, "") \
8072 _(ip_route_dump, "table-id [ip4|ip6]") \
8073 _(ip_mtable_dump, "") \
8074 _(ip_mroute_dump, "table-id [ip4|ip6]") \
8075 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
8077 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
8078 "mac <mac-address> [del]") \
8079 _(l2_xconnect_dump, "") \
8080 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
8081 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
8082 _(sock_init_shm, "size <nnn>") \
8083 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
8084 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
8085 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
8086 _(session_rules_dump, "") \
8087 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
8089 /* List of command functions, CLI names map directly to functions */
8090 #define foreach_cli_function \
8091 _(comment, "usage: comment <ignore-rest-of-line>") \
8092 _(dump_interface_table, "usage: dump_interface_table") \
8093 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
8094 _(dump_ipv4_table, "usage: dump_ipv4_table") \
8095 _(dump_ipv6_table, "usage: dump_ipv6_table") \
8096 _(dump_macro_table, "usage: dump_macro_table ") \
8097 _(dump_node_table, "usage: dump_node_table") \
8098 _(dump_msg_api_table, "usage: dump_msg_api_table") \
8099 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
8100 _(elog_disable, "usage: elog_disable") \
8101 _(elog_enable, "usage: elog_enable") \
8102 _(elog_save, "usage: elog_save <filename>") \
8103 _(get_msg_id, "usage: get_msg_id name_and_crc") \
8104 _(echo, "usage: echo <message>") \
8105 _(exec, "usage: exec <vpe-debug-CLI-command>") \
8106 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
8107 _(help, "usage: help") \
8108 _(q, "usage: quit") \
8109 _(quit, "usage: quit") \
8110 _(search_node_table, "usage: search_node_table <name>...") \
8111 _(set, "usage: set <variable-name> <value>") \
8112 _(script, "usage: script <file-name>") \
8113 _(statseg, "usage: statseg") \
8114 _(unset, "usage: unset <variable-name>")
8117 static void vl_api_##n##_t_handler_uni \
8118 (vl_api_##n##_t * mp) \
8120 vat_main_t * vam = &vat_main; \
8121 if (vam->json_output) { \
8122 vl_api_##n##_t_handler_json(mp); \
8124 vl_api_##n##_t_handler(mp); \
8127 foreach_vpe_api_reply_msg;
8128 #if VPP_API_TEST_BUILTIN == 0
8129 foreach_standalone_reply_msg;
8134 vat_api_hookup (vat_main_t * vam)
8137 vl_msg_api_set_handlers(VL_API_##N, #n, \
8138 vl_api_##n##_t_handler_uni, \
8140 vl_api_##n##_t_endian, \
8141 vl_api_##n##_t_print, \
8142 sizeof(vl_api_##n##_t), 1);
8143 foreach_vpe_api_reply_msg;
8144 #if VPP_API_TEST_BUILTIN == 0
8145 foreach_standalone_reply_msg;
8149 #if (VPP_API_TEST_BUILTIN==0)
8150 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
8152 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
8154 vam->function_by_name = hash_create_string (0, sizeof (uword));
8156 vam->help_by_name = hash_create_string (0, sizeof (uword));
8159 /* API messages we can send */
8160 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
8161 foreach_vpe_api_msg;
8165 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
8166 foreach_vpe_api_msg;
8170 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
8171 foreach_cli_function;
8175 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
8176 foreach_cli_function;
8180 #if VPP_API_TEST_BUILTIN
8181 static clib_error_t *
8182 vat_api_hookup_shim (vlib_main_t * vm)
8184 vat_api_hookup (&vat_main);
8188 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
8192 * fd.io coding-style-patch-verification: ON
8195 * eval: (c-set-style "gnu")