2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2020 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/udp/udp_local.h>
32 #include <vpp/api/vpe_msg_enum.h>
33 #include <vnet/l2/l2_classify.h>
34 #include <vnet/l2/l2_vtr.h>
35 #include <vnet/classify/in_out_acl.h>
36 #include <vnet/classify/policer_classify.h>
37 #include <vnet/classify/flow_classify.h>
38 #include <vnet/mpls/mpls.h>
39 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ip/ip6_hop_by_hop.h>
42 #include <vnet/ip/ip_source_and_port_range_check.h>
43 #include <vnet/policer/xlate.h>
44 #include <vnet/span/span.h>
45 #include <vnet/policer/policer.h>
46 #include <vnet/policer/police.h>
47 #include <vnet/mfib/mfib_types.h>
48 #include <vnet/bonding/node.h>
49 #include <vnet/qos/qos_types.h>
50 #include <vnet/ethernet/ethernet_types_api.h>
51 #include <vnet/ip/ip_types_api.h>
52 #include "vat/json_format.h"
53 #include <vnet/ip/ip_types_api.h>
54 #include <vnet/ethernet/ethernet_types_api.h>
59 #define vl_typedefs /* define message structures */
60 #include <vpp/api/vpe_all_api_h.h>
63 /* declare message handlers for each api */
65 #define vl_endianfun /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* instantiate all the print functions we know about */
70 #if VPP_API_TEST_BUILTIN == 0
71 #define vl_print(handle, ...)
73 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
76 #include <vpp/api/vpe_all_api_h.h>
79 #define __plugin_msg_base 0
80 #include <vlibapi/vat_helper_macros.h>
82 void vl_api_set_elog_main (elog_main_t * m);
83 int vl_api_set_elog_trace_api_messages (int enable);
85 #if VPP_API_TEST_BUILTIN == 0
95 vat_socket_connect (vat_main_t * vam)
98 api_main_t *am = vlibapi_get_main ();
99 vam->socket_client_main = &socket_client_main;
100 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
102 0 /* default socket rx, tx buffer */ )))
105 /* vpp expects the client index in network order */
106 vam->my_client_index = htonl (socket_client_main.client_index);
107 am->my_client_index = vam->my_client_index;
110 #else /* vpp built-in case, we don't do sockets... */
112 vat_socket_connect (vat_main_t * vam)
118 vl_socket_client_read (int wait)
124 vl_socket_client_write ()
130 vl_socket_client_msg_alloc (int nbytes)
138 vat_time_now (vat_main_t * vam)
140 #if VPP_API_TEST_BUILTIN
141 return vlib_time_now (vam->vlib_main);
143 return clib_time_now (&vam->clib_time);
148 errmsg (char *fmt, ...)
150 vat_main_t *vam = &vat_main;
155 s = va_format (0, fmt, &va);
160 #if VPP_API_TEST_BUILTIN
161 vlib_cli_output (vam->vlib_main, (char *) s);
164 if (vam->ifp != stdin)
165 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
166 vam->input_line_number);
168 fformat (vam->ofp, "%s\n", (char *) s);
176 #if VPP_API_TEST_BUILTIN == 0
178 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
180 vat_main_t *vam = va_arg (*args, vat_main_t *);
181 u32 *result = va_arg (*args, u32 *);
185 if (!unformat (input, "%s", &if_name))
188 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
195 /* Parse an IP4 address %d.%d.%d.%d. */
197 unformat_ip4_address (unformat_input_t * input, va_list * args)
199 u8 *result = va_arg (*args, u8 *);
202 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
205 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
217 unformat_ethernet_address (unformat_input_t * input, va_list * args)
219 u8 *result = va_arg (*args, u8 *);
222 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
223 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
227 for (i = 0; i < 6; i++)
228 if (a[i] >= (1 << 8))
231 for (i = 0; i < 6; i++)
237 /* Returns ethernet type as an int in host byte order. */
239 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
242 u16 *result = va_arg (*args, u16 *);
246 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
248 if (type >= (1 << 16))
256 /* Parse an IP46 address. */
258 unformat_ip46_address (unformat_input_t * input, va_list * args)
260 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
261 ip46_type_t type = va_arg (*args, ip46_type_t);
262 if ((type != IP46_TYPE_IP6) &&
263 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
265 ip46_address_mask_ip4 (ip46);
268 else if ((type != IP46_TYPE_IP4) &&
269 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
276 /* Parse an IP6 address. */
278 unformat_ip6_address (unformat_input_t * input, va_list * args)
280 ip6_address_t *result = va_arg (*args, ip6_address_t *);
282 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
283 uword c, n_colon, double_colon_index;
285 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
286 double_colon_index = ARRAY_LEN (hex_quads);
287 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
290 if (c >= '0' && c <= '9')
292 else if (c >= 'a' && c <= 'f')
293 hex_digit = c + 10 - 'a';
294 else if (c >= 'A' && c <= 'F')
295 hex_digit = c + 10 - 'A';
296 else if (c == ':' && n_colon < 2)
300 unformat_put_input (input);
304 /* Too many hex quads. */
305 if (n_hex_quads >= ARRAY_LEN (hex_quads))
310 hex_quad = (hex_quad << 4) | hex_digit;
312 /* Hex quad must fit in 16 bits. */
313 if (n_hex_digits >= 4)
320 /* Save position of :: */
323 /* More than one :: ? */
324 if (double_colon_index < ARRAY_LEN (hex_quads))
326 double_colon_index = n_hex_quads;
329 if (n_colon > 0 && n_hex_digits > 0)
331 hex_quads[n_hex_quads++] = hex_quad;
337 if (n_hex_digits > 0)
338 hex_quads[n_hex_quads++] = hex_quad;
343 /* Expand :: to appropriate number of zero hex quads. */
344 if (double_colon_index < ARRAY_LEN (hex_quads))
346 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
348 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
349 hex_quads[n_zero + i] = hex_quads[i];
351 for (i = 0; i < n_zero; i++)
352 hex_quads[double_colon_index + i] = 0;
354 n_hex_quads = ARRAY_LEN (hex_quads);
357 /* Too few hex quads given. */
358 if (n_hex_quads < ARRAY_LEN (hex_quads))
361 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
362 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
369 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
371 u32 *r = va_arg (*args, u32 *);
374 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
375 foreach_ipsec_policy_action
383 format_ipsec_crypto_alg (u8 * s, va_list * args)
385 u32 i = va_arg (*args, u32);
390 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
391 foreach_ipsec_crypto_alg
394 return format (s, "unknown");
396 return format (s, "%s", t);
400 format_ipsec_integ_alg (u8 * s, va_list * args)
402 u32 i = va_arg (*args, u32);
407 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
408 foreach_ipsec_integ_alg
411 return format (s, "unknown");
413 return format (s, "%s", t);
416 #else /* VPP_API_TEST_BUILTIN == 1 */
418 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
420 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
421 vnet_main_t *vnm = vnet_get_main ();
422 u32 *result = va_arg (*args, u32 *);
424 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
427 #endif /* VPP_API_TEST_BUILTIN */
429 #if (VPP_API_TEST_BUILTIN==0)
431 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
432 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
433 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
434 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
437 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
439 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
440 mfib_itf_attribute_t attr;
443 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
445 if (unformat (input, mfib_itf_flag_long_names[attr]))
446 *iflags |= (1 << attr);
448 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
450 if (unformat (input, mfib_itf_flag_names[attr]))
451 *iflags |= (1 << attr);
454 return (old == *iflags ? 0 : 1);
458 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
460 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
461 mfib_entry_attribute_t attr;
464 FOR_EACH_MFIB_ATTRIBUTE (attr)
466 if (unformat (input, mfib_flag_long_names[attr]))
467 *eflags |= (1 << attr);
469 FOR_EACH_MFIB_ATTRIBUTE (attr)
471 if (unformat (input, mfib_flag_names[attr]))
472 *eflags |= (1 << attr);
475 return (old == *eflags ? 0 : 1);
479 format_ip4_address (u8 * s, va_list * args)
481 u8 *a = va_arg (*args, u8 *);
482 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
486 format_ip6_address (u8 * s, va_list * args)
488 ip6_address_t *a = va_arg (*args, ip6_address_t *);
489 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
491 i_max_n_zero = ARRAY_LEN (a->as_u16);
493 i_first_zero = i_max_n_zero;
495 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
497 u32 is_zero = a->as_u16[i] == 0;
498 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
504 if ((!is_zero && n_zeros > max_n_zeros)
505 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
507 i_max_n_zero = i_first_zero;
508 max_n_zeros = n_zeros;
509 i_first_zero = ARRAY_LEN (a->as_u16);
514 last_double_colon = 0;
515 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
517 if (i == i_max_n_zero && max_n_zeros > 1)
519 s = format (s, "::");
520 i += max_n_zeros - 1;
521 last_double_colon = 1;
525 s = format (s, "%s%x",
526 (last_double_colon || i == 0) ? "" : ":",
527 clib_net_to_host_u16 (a->as_u16[i]));
528 last_double_colon = 0;
535 /* Format an IP46 address. */
537 format_ip46_address (u8 * s, va_list * args)
539 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
540 ip46_type_t type = va_arg (*args, ip46_type_t);
546 is_ip4 = ip46_address_is_ip4 (ip46);
557 format (s, "%U", format_ip4_address, &ip46->ip4) :
558 format (s, "%U", format_ip6_address, &ip46->ip6);
562 format_ethernet_address (u8 * s, va_list * args)
564 u8 *a = va_arg (*args, u8 *);
566 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
567 a[0], a[1], a[2], a[3], a[4], a[5]);
572 increment_v4_address (vl_api_ip4_address_t * i)
574 ip4_address_t *a = (ip4_address_t *) i;
577 v = ntohl (a->as_u32) + 1;
578 a->as_u32 = ntohl (v);
582 increment_v6_address (vl_api_ip6_address_t * i)
584 ip6_address_t *a = (ip6_address_t *) i;
587 v0 = clib_net_to_host_u64 (a->as_u64[0]);
588 v1 = clib_net_to_host_u64 (a->as_u64[1]);
593 a->as_u64[0] = clib_net_to_host_u64 (v0);
594 a->as_u64[1] = clib_net_to_host_u64 (v1);
598 increment_address (vl_api_address_t * a)
600 if (a->af == ADDRESS_IP4)
601 increment_v4_address (&a->un.ip4);
602 else if (a->af == ADDRESS_IP6)
603 increment_v6_address (&a->un.ip6);
607 set_ip4_address (vl_api_address_t * a, u32 v)
609 if (a->af == ADDRESS_IP4)
611 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
617 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
620 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
622 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
623 sizeof (ip6_address_t));
627 increment_mac_address (u8 * mac)
629 u64 tmp = *((u64 *) mac);
630 tmp = clib_net_to_host_u64 (tmp);
631 tmp += 1 << 16; /* skip unused (least significant) octets */
632 tmp = clib_host_to_net_u64 (tmp);
634 clib_memcpy (mac, &tmp, 6);
638 vat_json_object_add_address (vat_json_node_t * node,
639 const char *str, const vl_api_address_t * addr)
641 if (ADDRESS_IP6 == addr->af)
645 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
646 vat_json_object_add_ip6 (node, str, ip6);
652 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
653 vat_json_object_add_ip4 (node, str, ip4);
658 vat_json_object_add_prefix (vat_json_node_t * node,
659 const vl_api_prefix_t * prefix)
661 vat_json_object_add_uint (node, "len", prefix->len);
662 vat_json_object_add_address (node, "address", &prefix->address);
665 static void vl_api_create_loopback_reply_t_handler
666 (vl_api_create_loopback_reply_t * mp)
668 vat_main_t *vam = &vat_main;
669 i32 retval = ntohl (mp->retval);
671 vam->retval = retval;
672 vam->regenerate_interface_table = 1;
673 vam->sw_if_index = ntohl (mp->sw_if_index);
674 vam->result_ready = 1;
677 static void vl_api_create_loopback_reply_t_handler_json
678 (vl_api_create_loopback_reply_t * mp)
680 vat_main_t *vam = &vat_main;
681 vat_json_node_t node;
683 vat_json_init_object (&node);
684 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
685 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
687 vat_json_print (vam->ofp, &node);
688 vat_json_free (&node);
689 vam->retval = ntohl (mp->retval);
690 vam->result_ready = 1;
693 static void vl_api_create_loopback_instance_reply_t_handler
694 (vl_api_create_loopback_instance_reply_t * mp)
696 vat_main_t *vam = &vat_main;
697 i32 retval = ntohl (mp->retval);
699 vam->retval = retval;
700 vam->regenerate_interface_table = 1;
701 vam->sw_if_index = ntohl (mp->sw_if_index);
702 vam->result_ready = 1;
705 static void vl_api_create_loopback_instance_reply_t_handler_json
706 (vl_api_create_loopback_instance_reply_t * mp)
708 vat_main_t *vam = &vat_main;
709 vat_json_node_t node;
711 vat_json_init_object (&node);
712 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
713 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
715 vat_json_print (vam->ofp, &node);
716 vat_json_free (&node);
717 vam->retval = ntohl (mp->retval);
718 vam->result_ready = 1;
721 static void vl_api_create_vlan_subif_reply_t_handler
722 (vl_api_create_vlan_subif_reply_t * mp)
724 vat_main_t *vam = &vat_main;
725 i32 retval = ntohl (mp->retval);
727 vam->retval = retval;
728 vam->regenerate_interface_table = 1;
729 vam->sw_if_index = ntohl (mp->sw_if_index);
730 vam->result_ready = 1;
733 static void vl_api_create_vlan_subif_reply_t_handler_json
734 (vl_api_create_vlan_subif_reply_t * mp)
736 vat_main_t *vam = &vat_main;
737 vat_json_node_t node;
739 vat_json_init_object (&node);
740 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
741 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
743 vat_json_print (vam->ofp, &node);
744 vat_json_free (&node);
746 vam->retval = ntohl (mp->retval);
747 vam->result_ready = 1;
750 static void vl_api_create_subif_reply_t_handler
751 (vl_api_create_subif_reply_t * mp)
753 vat_main_t *vam = &vat_main;
754 i32 retval = ntohl (mp->retval);
756 vam->retval = retval;
757 vam->regenerate_interface_table = 1;
758 vam->sw_if_index = ntohl (mp->sw_if_index);
759 vam->result_ready = 1;
762 static void vl_api_create_subif_reply_t_handler_json
763 (vl_api_create_subif_reply_t * mp)
765 vat_main_t *vam = &vat_main;
766 vat_json_node_t node;
768 vat_json_init_object (&node);
769 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
770 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
772 vat_json_print (vam->ofp, &node);
773 vat_json_free (&node);
775 vam->retval = ntohl (mp->retval);
776 vam->result_ready = 1;
779 static void vl_api_interface_name_renumber_reply_t_handler
780 (vl_api_interface_name_renumber_reply_t * mp)
782 vat_main_t *vam = &vat_main;
783 i32 retval = ntohl (mp->retval);
785 vam->retval = retval;
786 vam->regenerate_interface_table = 1;
787 vam->result_ready = 1;
790 static void vl_api_interface_name_renumber_reply_t_handler_json
791 (vl_api_interface_name_renumber_reply_t * mp)
793 vat_main_t *vam = &vat_main;
794 vat_json_node_t node;
796 vat_json_init_object (&node);
797 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
799 vat_json_print (vam->ofp, &node);
800 vat_json_free (&node);
802 vam->retval = ntohl (mp->retval);
803 vam->result_ready = 1;
807 * Special-case: build the interface table, maintain
808 * the next loopback sw_if_index vbl.
810 static void vl_api_sw_interface_details_t_handler
811 (vl_api_sw_interface_details_t * mp)
813 vat_main_t *vam = &vat_main;
814 u8 *s = format (0, "%s%c", mp->interface_name, 0);
816 hash_set_mem (vam->sw_if_index_by_interface_name, s,
817 ntohl (mp->sw_if_index));
819 /* In sub interface case, fill the sub interface table entry */
820 if (mp->sw_if_index != mp->sup_sw_if_index)
822 sw_interface_subif_t *sub = NULL;
824 vec_add2 (vam->sw_if_subif_table, sub, 1);
826 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
827 strncpy ((char *) sub->interface_name, (char *) s,
828 vec_len (sub->interface_name));
829 sub->sw_if_index = ntohl (mp->sw_if_index);
830 sub->sub_id = ntohl (mp->sub_id);
832 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
834 sub->sub_number_of_tags = mp->sub_number_of_tags;
835 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
836 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
838 /* vlan tag rewrite */
839 sub->vtr_op = ntohl (mp->vtr_op);
840 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
841 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
842 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
846 static void vl_api_sw_interface_details_t_handler_json
847 (vl_api_sw_interface_details_t * mp)
849 vat_main_t *vam = &vat_main;
850 vat_json_node_t *node = NULL;
852 if (VAT_JSON_ARRAY != vam->json_tree.type)
854 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
855 vat_json_init_array (&vam->json_tree);
857 node = vat_json_array_add (&vam->json_tree);
859 vat_json_init_object (node);
860 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
861 vat_json_object_add_uint (node, "sup_sw_if_index",
862 ntohl (mp->sup_sw_if_index));
863 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
864 sizeof (mp->l2_address));
865 vat_json_object_add_string_copy (node, "interface_name",
867 vat_json_object_add_string_copy (node, "interface_dev_type",
868 mp->interface_dev_type);
869 vat_json_object_add_uint (node, "flags", mp->flags);
870 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
871 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
872 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
873 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
874 vat_json_object_add_uint (node, "sub_number_of_tags",
875 mp->sub_number_of_tags);
876 vat_json_object_add_uint (node, "sub_outer_vlan_id",
877 ntohs (mp->sub_outer_vlan_id));
878 vat_json_object_add_uint (node, "sub_inner_vlan_id",
879 ntohs (mp->sub_inner_vlan_id));
880 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
881 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
882 vat_json_object_add_uint (node, "vtr_push_dot1q",
883 ntohl (mp->vtr_push_dot1q));
884 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
885 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
886 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
888 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
890 format_ethernet_address,
892 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
894 format_ethernet_address,
896 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
897 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
901 #if VPP_API_TEST_BUILTIN == 0
902 static void vl_api_sw_interface_event_t_handler
903 (vl_api_sw_interface_event_t * mp)
905 vat_main_t *vam = &vat_main;
906 if (vam->interface_event_display)
907 errmsg ("interface flags: sw_if_index %d %s %s",
908 ntohl (mp->sw_if_index),
909 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
910 "admin-up" : "admin-down",
911 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
912 "link-up" : "link-down");
916 __clib_unused static void
917 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
919 /* JSON output not supported */
923 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
925 vat_main_t *vam = &vat_main;
926 i32 retval = ntohl (mp->retval);
928 vam->retval = retval;
929 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
930 vam->result_ready = 1;
934 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
936 vat_main_t *vam = &vat_main;
937 vat_json_node_t node;
941 vat_json_init_object (&node);
942 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
943 vat_json_object_add_uint (&node, "reply_in_shmem",
944 ntohl (mp->reply_in_shmem));
945 /* Toss the shared-memory original... */
946 oldheap = vl_msg_push_heap ();
948 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
951 vl_msg_pop_heap (oldheap);
953 vat_json_print (vam->ofp, &node);
954 vat_json_free (&node);
956 vam->retval = ntohl (mp->retval);
957 vam->result_ready = 1;
961 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
963 vat_main_t *vam = &vat_main;
964 i32 retval = ntohl (mp->retval);
966 vec_reset_length (vam->cmd_reply);
968 vam->retval = retval;
970 vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
971 vam->result_ready = 1;
975 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
977 vat_main_t *vam = &vat_main;
978 vat_json_node_t node;
979 u8 *reply = 0; /* reply vector */
981 reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
982 vec_reset_length (vam->cmd_reply);
984 vat_json_init_object (&node);
985 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
986 vat_json_object_add_string_copy (&node, "reply", reply);
988 vat_json_print (vam->ofp, &node);
989 vat_json_free (&node);
992 vam->retval = ntohl (mp->retval);
993 vam->result_ready = 1;
996 static void vl_api_get_node_index_reply_t_handler
997 (vl_api_get_node_index_reply_t * mp)
999 vat_main_t *vam = &vat_main;
1000 i32 retval = ntohl (mp->retval);
1001 if (vam->async_mode)
1003 vam->async_errors += (retval < 0);
1007 vam->retval = retval;
1009 errmsg ("node index %d", ntohl (mp->node_index));
1010 vam->result_ready = 1;
1014 static void vl_api_get_node_index_reply_t_handler_json
1015 (vl_api_get_node_index_reply_t * mp)
1017 vat_main_t *vam = &vat_main;
1018 vat_json_node_t node;
1020 vat_json_init_object (&node);
1021 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1022 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1024 vat_json_print (vam->ofp, &node);
1025 vat_json_free (&node);
1027 vam->retval = ntohl (mp->retval);
1028 vam->result_ready = 1;
1031 static void vl_api_get_next_index_reply_t_handler
1032 (vl_api_get_next_index_reply_t * mp)
1034 vat_main_t *vam = &vat_main;
1035 i32 retval = ntohl (mp->retval);
1036 if (vam->async_mode)
1038 vam->async_errors += (retval < 0);
1042 vam->retval = retval;
1044 errmsg ("next node index %d", ntohl (mp->next_index));
1045 vam->result_ready = 1;
1049 static void vl_api_get_next_index_reply_t_handler_json
1050 (vl_api_get_next_index_reply_t * mp)
1052 vat_main_t *vam = &vat_main;
1053 vat_json_node_t node;
1055 vat_json_init_object (&node);
1056 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1057 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1059 vat_json_print (vam->ofp, &node);
1060 vat_json_free (&node);
1062 vam->retval = ntohl (mp->retval);
1063 vam->result_ready = 1;
1066 static void vl_api_add_node_next_reply_t_handler
1067 (vl_api_add_node_next_reply_t * mp)
1069 vat_main_t *vam = &vat_main;
1070 i32 retval = ntohl (mp->retval);
1071 if (vam->async_mode)
1073 vam->async_errors += (retval < 0);
1077 vam->retval = retval;
1079 errmsg ("next index %d", ntohl (mp->next_index));
1080 vam->result_ready = 1;
1084 static void vl_api_add_node_next_reply_t_handler_json
1085 (vl_api_add_node_next_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 vat_json_node_t node;
1090 vat_json_init_object (&node);
1091 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1092 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1094 vat_json_print (vam->ofp, &node);
1095 vat_json_free (&node);
1097 vam->retval = ntohl (mp->retval);
1098 vam->result_ready = 1;
1101 static void vl_api_show_version_reply_t_handler
1102 (vl_api_show_version_reply_t * mp)
1104 vat_main_t *vam = &vat_main;
1105 i32 retval = ntohl (mp->retval);
1109 errmsg (" program: %s", mp->program);
1110 errmsg (" version: %s", mp->version);
1111 errmsg (" build date: %s", mp->build_date);
1112 errmsg ("build directory: %s", mp->build_directory);
1114 vam->retval = retval;
1115 vam->result_ready = 1;
1118 static void vl_api_show_version_reply_t_handler_json
1119 (vl_api_show_version_reply_t * mp)
1121 vat_main_t *vam = &vat_main;
1122 vat_json_node_t node;
1124 vat_json_init_object (&node);
1125 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1126 vat_json_object_add_string_copy (&node, "program", mp->program);
1127 vat_json_object_add_string_copy (&node, "version", mp->version);
1128 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1129 vat_json_object_add_string_copy (&node, "build_directory",
1130 mp->build_directory);
1132 vat_json_print (vam->ofp, &node);
1133 vat_json_free (&node);
1135 vam->retval = ntohl (mp->retval);
1136 vam->result_ready = 1;
1139 static void vl_api_show_threads_reply_t_handler
1140 (vl_api_show_threads_reply_t * mp)
1142 vat_main_t *vam = &vat_main;
1143 i32 retval = ntohl (mp->retval);
1147 count = ntohl (mp->count);
1149 for (i = 0; i < count; i++)
1151 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1152 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1153 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1154 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1155 ntohl (mp->thread_data[i].cpu_socket));
1157 vam->retval = retval;
1158 vam->result_ready = 1;
1161 static void vl_api_show_threads_reply_t_handler_json
1162 (vl_api_show_threads_reply_t * mp)
1164 vat_main_t *vam = &vat_main;
1165 vat_json_node_t node;
1166 vl_api_thread_data_t *td;
1167 i32 retval = ntohl (mp->retval);
1171 count = ntohl (mp->count);
1173 vat_json_init_object (&node);
1174 vat_json_object_add_int (&node, "retval", retval);
1175 vat_json_object_add_uint (&node, "count", count);
1177 for (i = 0; i < count; i++)
1179 td = &mp->thread_data[i];
1180 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1181 vat_json_object_add_string_copy (&node, "name", td->name);
1182 vat_json_object_add_string_copy (&node, "type", td->type);
1183 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1184 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1185 vat_json_object_add_int (&node, "core", ntohl (td->id));
1186 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1189 vat_json_print (vam->ofp, &node);
1190 vat_json_free (&node);
1192 vam->retval = retval;
1193 vam->result_ready = 1;
1197 api_show_threads (vat_main_t * vam)
1199 vl_api_show_threads_t *mp;
1203 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1204 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1206 M (SHOW_THREADS, mp);
1214 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1216 u32 n_macs = ntohl (mp->n_macs);
1217 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1218 ntohl (mp->pid), mp->client_index, n_macs);
1220 for (i = 0; i < n_macs; i++)
1222 vl_api_mac_entry_t *mac = &mp->mac[i];
1223 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1224 i + 1, ntohl (mac->sw_if_index),
1225 format_ethernet_address, mac->mac_addr, mac->action);
1232 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1234 /* JSON output not supported */
1237 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1238 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1241 * Special-case: build the bridge domain table, maintain
1242 * the next bd id vbl.
1244 static void vl_api_bridge_domain_details_t_handler
1245 (vl_api_bridge_domain_details_t * mp)
1247 vat_main_t *vam = &vat_main;
1248 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1251 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1252 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1254 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1255 ntohl (mp->bd_id), mp->learn, mp->forward,
1256 mp->flood, ntohl (mp->bvi_sw_if_index),
1257 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1261 vl_api_bridge_domain_sw_if_t *sw_ifs;
1262 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1265 sw_ifs = mp->sw_if_details;
1266 for (i = 0; i < n_sw_ifs; i++)
1272 sw_if_index = ntohl (sw_ifs->sw_if_index);
1275 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1277 if ((u32) p->value[0] == sw_if_index)
1279 sw_if_name = (u8 *)(p->key);
1284 print (vam->ofp, "%7d %3d %s", sw_if_index,
1285 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1286 "sw_if_index not found!");
1293 static void vl_api_bridge_domain_details_t_handler_json
1294 (vl_api_bridge_domain_details_t * mp)
1296 vat_main_t *vam = &vat_main;
1297 vat_json_node_t *node, *array = NULL;
1298 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1300 if (VAT_JSON_ARRAY != vam->json_tree.type)
1302 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1303 vat_json_init_array (&vam->json_tree);
1305 node = vat_json_array_add (&vam->json_tree);
1307 vat_json_init_object (node);
1308 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1309 vat_json_object_add_uint (node, "flood", mp->flood);
1310 vat_json_object_add_uint (node, "forward", mp->forward);
1311 vat_json_object_add_uint (node, "learn", mp->learn);
1312 vat_json_object_add_uint (node, "bvi_sw_if_index",
1313 ntohl (mp->bvi_sw_if_index));
1314 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1315 array = vat_json_object_add (node, "sw_if");
1316 vat_json_init_array (array);
1322 vl_api_bridge_domain_sw_if_t *sw_ifs;
1325 sw_ifs = mp->sw_if_details;
1326 for (i = 0; i < n_sw_ifs; i++)
1328 node = vat_json_array_add (array);
1329 vat_json_init_object (node);
1330 vat_json_object_add_uint (node, "sw_if_index",
1331 ntohl (sw_ifs->sw_if_index));
1332 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1338 static void vl_api_control_ping_reply_t_handler
1339 (vl_api_control_ping_reply_t * mp)
1341 vat_main_t *vam = &vat_main;
1342 i32 retval = ntohl (mp->retval);
1343 if (vam->async_mode)
1345 vam->async_errors += (retval < 0);
1349 vam->retval = retval;
1350 vam->result_ready = 1;
1352 if (vam->socket_client_main)
1353 vam->socket_client_main->control_pings_outstanding--;
1356 static void vl_api_control_ping_reply_t_handler_json
1357 (vl_api_control_ping_reply_t * mp)
1359 vat_main_t *vam = &vat_main;
1360 i32 retval = ntohl (mp->retval);
1362 if (VAT_JSON_NONE != vam->json_tree.type)
1364 vat_json_print (vam->ofp, &vam->json_tree);
1365 vat_json_free (&vam->json_tree);
1366 vam->json_tree.type = VAT_JSON_NONE;
1371 vat_json_init_array (&vam->json_tree);
1372 vat_json_print (vam->ofp, &vam->json_tree);
1373 vam->json_tree.type = VAT_JSON_NONE;
1376 vam->retval = retval;
1377 vam->result_ready = 1;
1381 vl_api_bridge_domain_set_mac_age_reply_t_handler
1382 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1384 vat_main_t *vam = &vat_main;
1385 i32 retval = ntohl (mp->retval);
1386 if (vam->async_mode)
1388 vam->async_errors += (retval < 0);
1392 vam->retval = retval;
1393 vam->result_ready = 1;
1397 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1398 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1400 vat_main_t *vam = &vat_main;
1401 vat_json_node_t node;
1403 vat_json_init_object (&node);
1404 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1406 vat_json_print (vam->ofp, &node);
1407 vat_json_free (&node);
1409 vam->retval = ntohl (mp->retval);
1410 vam->result_ready = 1;
1414 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1416 vat_main_t *vam = &vat_main;
1417 i32 retval = ntohl (mp->retval);
1418 if (vam->async_mode)
1420 vam->async_errors += (retval < 0);
1424 vam->retval = retval;
1425 vam->result_ready = 1;
1429 static void vl_api_l2_flags_reply_t_handler_json
1430 (vl_api_l2_flags_reply_t * mp)
1432 vat_main_t *vam = &vat_main;
1433 vat_json_node_t node;
1435 vat_json_init_object (&node);
1436 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1437 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1438 ntohl (mp->resulting_feature_bitmap));
1440 vat_json_print (vam->ofp, &node);
1441 vat_json_free (&node);
1443 vam->retval = ntohl (mp->retval);
1444 vam->result_ready = 1;
1447 static void vl_api_bridge_flags_reply_t_handler
1448 (vl_api_bridge_flags_reply_t * mp)
1450 vat_main_t *vam = &vat_main;
1451 i32 retval = ntohl (mp->retval);
1452 if (vam->async_mode)
1454 vam->async_errors += (retval < 0);
1458 vam->retval = retval;
1459 vam->result_ready = 1;
1463 static void vl_api_bridge_flags_reply_t_handler_json
1464 (vl_api_bridge_flags_reply_t * mp)
1466 vat_main_t *vam = &vat_main;
1467 vat_json_node_t node;
1469 vat_json_init_object (&node);
1470 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1471 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1472 ntohl (mp->resulting_feature_bitmap));
1474 vat_json_print (vam->ofp, &node);
1475 vat_json_free (&node);
1477 vam->retval = ntohl (mp->retval);
1478 vam->result_ready = 1;
1482 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1485 vat_main_t *vam = &vat_main;
1486 i32 retval = ntohl (mp->retval);
1487 if (vam->async_mode)
1489 vam->async_errors += (retval < 0);
1493 vam->retval = retval;
1494 vam->sw_if_index = ntohl (mp->sw_if_index);
1495 vam->result_ready = 1;
1499 static void vl_api_virtio_pci_create_reply_t_handler_json
1500 (vl_api_virtio_pci_create_reply_t * mp)
1502 vat_main_t *vam = &vat_main;
1503 vat_json_node_t node;
1505 vat_json_init_object (&node);
1506 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1507 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1509 vat_json_print (vam->ofp, &node);
1510 vat_json_free (&node);
1512 vam->retval = ntohl (mp->retval);
1513 vam->result_ready = 1;
1518 vl_api_virtio_pci_create_v2_reply_t_handler
1519 (vl_api_virtio_pci_create_v2_reply_t * mp)
1521 vat_main_t *vam = &vat_main;
1522 i32 retval = ntohl (mp->retval);
1523 if (vam->async_mode)
1525 vam->async_errors += (retval < 0);
1529 vam->retval = retval;
1530 vam->sw_if_index = ntohl (mp->sw_if_index);
1531 vam->result_ready = 1;
1535 static void vl_api_virtio_pci_create_v2_reply_t_handler_json
1536 (vl_api_virtio_pci_create_v2_reply_t * mp)
1538 vat_main_t *vam = &vat_main;
1539 vat_json_node_t node;
1541 vat_json_init_object (&node);
1542 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1543 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1545 vat_json_print (vam->ofp, &node);
1546 vat_json_free (&node);
1548 vam->retval = ntohl (mp->retval);
1549 vam->result_ready = 1;
1553 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1556 vat_main_t *vam = &vat_main;
1557 i32 retval = ntohl (mp->retval);
1558 if (vam->async_mode)
1560 vam->async_errors += (retval < 0);
1564 vam->retval = retval;
1565 vam->result_ready = 1;
1569 static void vl_api_virtio_pci_delete_reply_t_handler_json
1570 (vl_api_virtio_pci_delete_reply_t * mp)
1572 vat_main_t *vam = &vat_main;
1573 vat_json_node_t node;
1575 vat_json_init_object (&node);
1576 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1578 vat_json_print (vam->ofp, &node);
1579 vat_json_free (&node);
1581 vam->retval = ntohl (mp->retval);
1582 vam->result_ready = 1;
1585 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1586 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1588 vat_main_t *vam = &vat_main;
1589 i32 retval = ntohl (mp->retval);
1590 if (vam->async_mode)
1592 vam->async_errors += (retval < 0);
1596 vam->retval = retval;
1597 vam->sw_if_index = ntohl (mp->sw_if_index);
1598 vam->result_ready = 1;
1600 vam->regenerate_interface_table = 1;
1603 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1604 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1606 vat_main_t *vam = &vat_main;
1607 vat_json_node_t node;
1609 vat_json_init_object (&node);
1610 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1611 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1612 ntohl (mp->sw_if_index));
1614 vat_json_print (vam->ofp, &node);
1615 vat_json_free (&node);
1617 vam->retval = ntohl (mp->retval);
1618 vam->result_ready = 1;
1621 static void vl_api_ip_address_details_t_handler
1622 (vl_api_ip_address_details_t * mp)
1624 vat_main_t *vam = &vat_main;
1625 static ip_address_details_t empty_ip_address_details = { {0} };
1626 ip_address_details_t *address = NULL;
1627 ip_details_t *current_ip_details = NULL;
1628 ip_details_t *details = NULL;
1630 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1632 if (!details || vam->current_sw_if_index >= vec_len (details)
1633 || !details[vam->current_sw_if_index].present)
1635 errmsg ("ip address details arrived but not stored");
1636 errmsg ("ip_dump should be called first");
1640 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1642 #define addresses (current_ip_details->addr)
1644 vec_validate_init_empty (addresses, vec_len (addresses),
1645 empty_ip_address_details);
1647 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1649 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
1650 address->prefix_length = mp->prefix.len;
1654 static void vl_api_ip_address_details_t_handler_json
1655 (vl_api_ip_address_details_t * mp)
1657 vat_main_t *vam = &vat_main;
1658 vat_json_node_t *node = NULL;
1660 if (VAT_JSON_ARRAY != vam->json_tree.type)
1662 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1663 vat_json_init_array (&vam->json_tree);
1665 node = vat_json_array_add (&vam->json_tree);
1667 vat_json_init_object (node);
1668 vat_json_object_add_prefix (node, &mp->prefix);
1672 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1674 vat_main_t *vam = &vat_main;
1675 static ip_details_t empty_ip_details = { 0 };
1676 ip_details_t *ip = NULL;
1677 u32 sw_if_index = ~0;
1679 sw_if_index = ntohl (mp->sw_if_index);
1681 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1682 sw_if_index, empty_ip_details);
1684 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1691 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1693 vat_main_t *vam = &vat_main;
1695 if (VAT_JSON_ARRAY != vam->json_tree.type)
1697 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1698 vat_json_init_array (&vam->json_tree);
1700 vat_json_array_add_uint (&vam->json_tree,
1701 clib_net_to_host_u32 (mp->sw_if_index));
1704 static void vl_api_get_first_msg_id_reply_t_handler
1705 (vl_api_get_first_msg_id_reply_t * mp)
1707 vat_main_t *vam = &vat_main;
1708 i32 retval = ntohl (mp->retval);
1710 if (vam->async_mode)
1712 vam->async_errors += (retval < 0);
1716 vam->retval = retval;
1717 vam->result_ready = 1;
1721 errmsg ("first message id %d", ntohs (mp->first_msg_id));
1725 static void vl_api_get_first_msg_id_reply_t_handler_json
1726 (vl_api_get_first_msg_id_reply_t * mp)
1728 vat_main_t *vam = &vat_main;
1729 vat_json_node_t node;
1731 vat_json_init_object (&node);
1732 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1733 vat_json_object_add_uint (&node, "first_msg_id",
1734 (uint) ntohs (mp->first_msg_id));
1736 vat_json_print (vam->ofp, &node);
1737 vat_json_free (&node);
1739 vam->retval = ntohl (mp->retval);
1740 vam->result_ready = 1;
1743 static void vl_api_get_node_graph_reply_t_handler
1744 (vl_api_get_node_graph_reply_t * mp)
1746 vat_main_t *vam = &vat_main;
1747 i32 retval = ntohl (mp->retval);
1748 u8 *pvt_copy, *reply;
1753 if (vam->async_mode)
1755 vam->async_errors += (retval < 0);
1759 vam->retval = retval;
1760 vam->result_ready = 1;
1763 /* "Should never happen..." */
1767 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1768 pvt_copy = vec_dup (reply);
1770 /* Toss the shared-memory original... */
1771 oldheap = vl_msg_push_heap ();
1775 vl_msg_pop_heap (oldheap);
1777 if (vam->graph_nodes)
1779 hash_free (vam->graph_node_index_by_name);
1781 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1783 node = vam->graph_nodes[0][i];
1784 vec_free (node->name);
1785 vec_free (node->next_nodes);
1788 vec_free (vam->graph_nodes[0]);
1789 vec_free (vam->graph_nodes);
1792 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
1793 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
1794 vec_free (pvt_copy);
1796 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
1798 node = vam->graph_nodes[0][i];
1799 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
1803 static void vl_api_get_node_graph_reply_t_handler_json
1804 (vl_api_get_node_graph_reply_t * mp)
1806 vat_main_t *vam = &vat_main;
1808 vat_json_node_t node;
1811 /* $$$$ make this real? */
1812 vat_json_init_object (&node);
1813 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1814 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
1816 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1818 /* Toss the shared-memory original... */
1819 oldheap = vl_msg_push_heap ();
1823 vl_msg_pop_heap (oldheap);
1825 vat_json_print (vam->ofp, &node);
1826 vat_json_free (&node);
1828 vam->retval = ntohl (mp->retval);
1829 vam->result_ready = 1;
1832 /* Format hex dump. */
1834 format_hex_bytes (u8 * s, va_list * va)
1836 u8 *bytes = va_arg (*va, u8 *);
1837 int n_bytes = va_arg (*va, int);
1840 /* Print short or long form depending on byte count. */
1841 uword short_form = n_bytes <= 32;
1842 u32 indent = format_get_indent (s);
1847 for (i = 0; i < n_bytes; i++)
1849 if (!short_form && (i % 32) == 0)
1850 s = format (s, "%08x: ", i);
1851 s = format (s, "%02x", bytes[i]);
1852 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
1853 s = format (s, "\n%U", format_white_space, indent);
1860 * Generate boilerplate reply handlers, which
1861 * dig the return value out of the xxx_reply_t API message,
1862 * stick it into vam->retval, and set vam->result_ready
1864 * Could also do this by pointing N message decode slots at
1865 * a single function, but that could break in subtle ways.
1868 #define foreach_standard_reply_retval_handler \
1869 _(sw_interface_set_flags_reply) \
1870 _(sw_interface_add_del_address_reply) \
1871 _(sw_interface_set_rx_mode_reply) \
1872 _(sw_interface_set_rx_placement_reply) \
1873 _(sw_interface_set_table_reply) \
1874 _(sw_interface_set_mpls_enable_reply) \
1875 _(sw_interface_set_vpath_reply) \
1876 _(sw_interface_set_l2_bridge_reply) \
1877 _(bridge_domain_add_del_reply) \
1878 _(sw_interface_set_l2_xconnect_reply) \
1879 _(l2fib_add_del_reply) \
1880 _(l2fib_flush_int_reply) \
1881 _(l2fib_flush_bd_reply) \
1882 _(ip_route_add_del_reply) \
1883 _(ip_table_add_del_reply) \
1884 _(ip_table_replace_begin_reply) \
1885 _(ip_table_flush_reply) \
1886 _(ip_table_replace_end_reply) \
1887 _(ip_mroute_add_del_reply) \
1888 _(mpls_route_add_del_reply) \
1889 _(mpls_table_add_del_reply) \
1890 _(mpls_ip_bind_unbind_reply) \
1891 _(sw_interface_set_unnumbered_reply) \
1892 _(set_ip_flow_hash_reply) \
1893 _(sw_interface_ip6_enable_disable_reply) \
1894 _(l2_patch_add_del_reply) \
1895 _(l2_fib_clear_table_reply) \
1896 _(l2_interface_efp_filter_reply) \
1897 _(l2_interface_vlan_tag_rewrite_reply) \
1898 _(want_l2_macs_events_reply) \
1899 _(delete_loopback_reply) \
1900 _(bd_ip_mac_add_del_reply) \
1901 _(bd_ip_mac_flush_reply) \
1902 _(want_interface_events_reply) \
1903 _(sw_interface_clear_stats_reply) \
1904 _(ioam_enable_reply) \
1905 _(ioam_disable_reply) \
1906 _(sw_interface_span_enable_disable_reply) \
1907 _(ip_source_and_port_range_check_add_del_reply) \
1908 _(ip_source_and_port_range_check_interface_add_del_reply)\
1909 _(delete_subif_reply) \
1910 _(l2_interface_pbb_tag_rewrite_reply) \
1911 _(sw_interface_tag_add_del_reply) \
1912 _(sw_interface_add_del_mac_address_reply) \
1913 _(hw_interface_set_mtu_reply) \
1914 _(tcp_configure_src_addresses_reply) \
1915 _(session_rule_add_del_reply) \
1916 _(ip_container_proxy_add_del_reply) \
1919 static void vl_api_##n##_t_handler \
1920 (vl_api_##n##_t * mp) \
1922 vat_main_t * vam = &vat_main; \
1923 i32 retval = ntohl(mp->retval); \
1924 if (vam->async_mode) { \
1925 vam->async_errors += (retval < 0); \
1927 vam->retval = retval; \
1928 vam->result_ready = 1; \
1931 foreach_standard_reply_retval_handler;
1935 static void vl_api_##n##_t_handler_json \
1936 (vl_api_##n##_t * mp) \
1938 vat_main_t * vam = &vat_main; \
1939 vat_json_node_t node; \
1940 vat_json_init_object(&node); \
1941 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
1942 vat_json_print(vam->ofp, &node); \
1943 vam->retval = ntohl(mp->retval); \
1944 vam->result_ready = 1; \
1946 foreach_standard_reply_retval_handler;
1950 * Table of message reply handlers, must include boilerplate handlers
1954 #define foreach_vpe_api_reply_msg \
1955 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
1956 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
1957 _(SW_INTERFACE_DETAILS, sw_interface_details) \
1958 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
1959 _(CONTROL_PING_REPLY, control_ping_reply) \
1960 _(CLI_REPLY, cli_reply) \
1961 _(CLI_INBAND_REPLY, cli_inband_reply) \
1962 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
1963 sw_interface_add_del_address_reply) \
1964 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
1965 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
1966 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
1967 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
1968 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
1969 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
1970 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
1971 sw_interface_set_l2_xconnect_reply) \
1972 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
1973 sw_interface_set_l2_bridge_reply) \
1974 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
1975 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
1976 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
1977 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
1978 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
1979 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
1980 _(L2_FLAGS_REPLY, l2_flags_reply) \
1981 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
1982 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
1983 _(VIRTIO_PCI_CREATE_V2_REPLY, virtio_pci_create_v2_reply) \
1984 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
1985 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
1986 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
1987 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
1988 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
1989 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
1990 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
1991 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
1992 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
1993 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
1994 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
1995 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
1996 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
1997 sw_interface_set_unnumbered_reply) \
1998 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
1999 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2000 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2001 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2002 sw_interface_ip6_enable_disable_reply) \
2003 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2004 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2005 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2006 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2007 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2008 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2009 _(SHOW_VERSION_REPLY, show_version_reply) \
2010 _(SHOW_THREADS_REPLY, show_threads_reply) \
2011 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
2012 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2013 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
2014 _(L2_MACS_EVENT, l2_macs_event) \
2015 _(IP_ADDRESS_DETAILS, ip_address_details) \
2016 _(IP_DETAILS, ip_details) \
2017 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
2018 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
2019 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
2020 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
2021 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
2022 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
2023 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
2024 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
2025 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
2026 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
2027 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
2028 _(MPLS_TABLE_DETAILS, mpls_table_details) \
2029 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
2030 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
2031 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
2032 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
2033 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
2034 ip_source_and_port_range_check_add_del_reply) \
2035 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
2036 ip_source_and_port_range_check_interface_add_del_reply) \
2037 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
2038 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
2039 _(IP_TABLE_DETAILS, ip_table_details) \
2040 _(IP_ROUTE_DETAILS, ip_route_details) \
2041 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
2042 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
2043 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
2044 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
2045 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
2046 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
2047 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
2048 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
2049 _(SESSION_RULES_DETAILS, session_rules_details) \
2050 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
2052 #define foreach_standalone_reply_msg \
2053 _(SW_INTERFACE_EVENT, sw_interface_event)
2061 #define STR_VTR_OP_CASE(op) \
2062 case L2_VTR_ ## op: \
2066 str_vtr_op (u32 vtr_op)
2070 STR_VTR_OP_CASE (DISABLED);
2071 STR_VTR_OP_CASE (PUSH_1);
2072 STR_VTR_OP_CASE (PUSH_2);
2073 STR_VTR_OP_CASE (POP_1);
2074 STR_VTR_OP_CASE (POP_2);
2075 STR_VTR_OP_CASE (TRANSLATE_1_1);
2076 STR_VTR_OP_CASE (TRANSLATE_1_2);
2077 STR_VTR_OP_CASE (TRANSLATE_2_1);
2078 STR_VTR_OP_CASE (TRANSLATE_2_2);
2085 dump_sub_interface_table (vat_main_t * vam)
2087 const sw_interface_subif_t *sub = NULL;
2089 if (vam->json_output)
2092 ("JSON output supported only for VPE API calls and dump_stats_table");
2097 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
2098 "Interface", "sw_if_index",
2099 "sub id", "dot1ad", "tags", "outer id",
2100 "inner id", "exact", "default", "outer any", "inner any");
2102 vec_foreach (sub, vam->sw_if_subif_table)
2105 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
2106 sub->interface_name,
2108 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
2109 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
2110 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
2111 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
2112 if (sub->vtr_op != L2_VTR_DISABLED)
2115 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
2116 "tag1: %d tag2: %d ]",
2117 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
2118 sub->vtr_tag1, sub->vtr_tag2);
2126 name_sort_cmp (void *a1, void *a2)
2128 name_sort_t *n1 = a1;
2129 name_sort_t *n2 = a2;
2131 return strcmp ((char *) n1->name, (char *) n2->name);
2135 dump_interface_table (vat_main_t * vam)
2138 name_sort_t *nses = 0, *ns;
2140 if (vam->json_output)
2143 ("JSON output supported only for VPE API calls and dump_stats_table");
2148 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2150 vec_add2 (nses, ns, 1);
2151 ns->name = (u8 *)(p->key);
2152 ns->value = (u32) p->value[0];
2156 vec_sort_with_function (nses, name_sort_cmp);
2158 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
2159 vec_foreach (ns, nses)
2161 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
2168 dump_ip_table (vat_main_t * vam, int is_ipv6)
2170 const ip_details_t *det = NULL;
2171 const ip_address_details_t *address = NULL;
2174 print (vam->ofp, "%-12s", "sw_if_index");
2176 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
2183 print (vam->ofp, "%-12d", i);
2184 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
2189 vec_foreach (address, det->addr)
2193 is_ipv6 ? format_ip6_address : format_ip4_address,
2194 address->ip, address->prefix_length);
2202 dump_ipv4_table (vat_main_t * vam)
2204 if (vam->json_output)
2207 ("JSON output supported only for VPE API calls and dump_stats_table");
2211 return dump_ip_table (vam, 0);
2215 dump_ipv6_table (vat_main_t * vam)
2217 if (vam->json_output)
2220 ("JSON output supported only for VPE API calls and dump_stats_table");
2224 return dump_ip_table (vam, 1);
2228 * Pass CLI buffers directly in the CLI_INBAND API message,
2229 * instead of an additional shared memory area.
2232 exec_inband (vat_main_t * vam)
2234 vl_api_cli_inband_t *mp;
2235 unformat_input_t *i = vam->input;
2238 if (vec_len (i->buffer) == 0)
2241 if (vam->exec_mode == 0 && unformat (i, "mode"))
2246 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
2253 * In order for the CLI command to work, it
2254 * must be a vector ending in \n, not a C-string ending
2257 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
2258 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
2262 /* json responses may or may not include a useful reply... */
2263 if (vec_len (vam->cmd_reply))
2264 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
2269 exec (vat_main_t * vam)
2271 return exec_inband (vam);
2275 api_create_loopback (vat_main_t * vam)
2277 unformat_input_t *i = vam->input;
2278 vl_api_create_loopback_t *mp;
2279 vl_api_create_loopback_instance_t *mp_lbi;
2282 u8 is_specified = 0;
2283 u32 user_instance = 0;
2286 clib_memset (mac_address, 0, sizeof (mac_address));
2288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2290 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
2292 if (unformat (i, "instance %d", &user_instance))
2300 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
2301 mp_lbi->is_specified = is_specified;
2303 mp_lbi->user_instance = htonl (user_instance);
2305 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
2310 /* Construct the API message */
2311 M (CREATE_LOOPBACK, mp);
2313 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
2322 api_delete_loopback (vat_main_t * vam)
2324 unformat_input_t *i = vam->input;
2325 vl_api_delete_loopback_t *mp;
2326 u32 sw_if_index = ~0;
2329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2331 if (unformat (i, "sw_if_index %d", &sw_if_index))
2337 if (sw_if_index == ~0)
2339 errmsg ("missing sw_if_index");
2343 /* Construct the API message */
2344 M (DELETE_LOOPBACK, mp);
2345 mp->sw_if_index = ntohl (sw_if_index);
2353 api_want_interface_events (vat_main_t * vam)
2355 unformat_input_t *i = vam->input;
2356 vl_api_want_interface_events_t *mp;
2360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2362 if (unformat (i, "enable"))
2364 else if (unformat (i, "disable"))
2372 errmsg ("missing enable|disable");
2376 M (WANT_INTERFACE_EVENTS, mp);
2377 mp->enable_disable = enable;
2379 vam->interface_event_display = enable;
2387 /* Note: non-static, called once to set up the initial intfc table */
2389 api_sw_interface_dump (vat_main_t * vam)
2391 vl_api_sw_interface_dump_t *mp;
2392 vl_api_control_ping_t *mp_ping;
2394 name_sort_t *nses = 0, *ns;
2395 sw_interface_subif_t *sub = NULL;
2398 /* Toss the old name table */
2400 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2402 vec_add2 (nses, ns, 1);
2403 ns->name = (u8 *)(p->key);
2404 ns->value = (u32) p->value[0];
2408 hash_free (vam->sw_if_index_by_interface_name);
2410 vec_foreach (ns, nses) vec_free (ns->name);
2414 vec_foreach (sub, vam->sw_if_subif_table)
2416 vec_free (sub->interface_name);
2418 vec_free (vam->sw_if_subif_table);
2420 /* recreate the interface name hash table */
2421 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
2424 * Ask for all interface names. Otherwise, the epic catalog of
2425 * name filters becomes ridiculously long, and vat ends up needing
2426 * to be taught about new interface types.
2428 M (SW_INTERFACE_DUMP, mp);
2431 /* Use a control ping for synchronization */
2432 MPING (CONTROL_PING, mp_ping);
2440 api_sw_interface_set_flags (vat_main_t * vam)
2442 unformat_input_t *i = vam->input;
2443 vl_api_sw_interface_set_flags_t *mp;
2445 u8 sw_if_index_set = 0;
2449 /* Parse args required to build the message */
2450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2452 if (unformat (i, "admin-up"))
2454 else if (unformat (i, "admin-down"))
2457 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2458 sw_if_index_set = 1;
2459 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2460 sw_if_index_set = 1;
2465 if (sw_if_index_set == 0)
2467 errmsg ("missing interface name or sw_if_index");
2471 /* Construct the API message */
2472 M (SW_INTERFACE_SET_FLAGS, mp);
2473 mp->sw_if_index = ntohl (sw_if_index);
2474 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
2479 /* Wait for a reply, return the good/bad news... */
2485 api_sw_interface_set_rx_mode (vat_main_t * vam)
2487 unformat_input_t *i = vam->input;
2488 vl_api_sw_interface_set_rx_mode_t *mp;
2490 u8 sw_if_index_set = 0;
2492 u8 queue_id_valid = 0;
2494 vnet_hw_if_rx_mode mode = VNET_HW_IF_RX_MODE_UNKNOWN;
2496 /* Parse args required to build the message */
2497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2499 if (unformat (i, "queue %d", &queue_id))
2501 else if (unformat (i, "polling"))
2502 mode = VNET_HW_IF_RX_MODE_POLLING;
2503 else if (unformat (i, "interrupt"))
2504 mode = VNET_HW_IF_RX_MODE_INTERRUPT;
2505 else if (unformat (i, "adaptive"))
2506 mode = VNET_HW_IF_RX_MODE_ADAPTIVE;
2508 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2509 sw_if_index_set = 1;
2510 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2511 sw_if_index_set = 1;
2516 if (sw_if_index_set == 0)
2518 errmsg ("missing interface name or sw_if_index");
2521 if (mode == VNET_HW_IF_RX_MODE_UNKNOWN)
2523 errmsg ("missing rx-mode");
2527 /* Construct the API message */
2528 M (SW_INTERFACE_SET_RX_MODE, mp);
2529 mp->sw_if_index = ntohl (sw_if_index);
2530 mp->mode = (vl_api_rx_mode_t) mode;
2531 mp->queue_id_valid = queue_id_valid;
2532 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
2537 /* Wait for a reply, return the good/bad news... */
2543 api_sw_interface_set_rx_placement (vat_main_t * vam)
2545 unformat_input_t *i = vam->input;
2546 vl_api_sw_interface_set_rx_placement_t *mp;
2548 u8 sw_if_index_set = 0;
2551 u32 queue_id, thread_index;
2553 /* Parse args required to build the message */
2554 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2556 if (unformat (i, "queue %d", &queue_id))
2558 else if (unformat (i, "main"))
2560 else if (unformat (i, "worker %d", &thread_index))
2563 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2564 sw_if_index_set = 1;
2565 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2566 sw_if_index_set = 1;
2571 if (sw_if_index_set == 0)
2573 errmsg ("missing interface name or sw_if_index");
2579 /* Construct the API message */
2580 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
2581 mp->sw_if_index = ntohl (sw_if_index);
2582 mp->worker_id = ntohl (thread_index);
2583 mp->queue_id = ntohl (queue_id);
2584 mp->is_main = is_main;
2588 /* Wait for a reply, return the good/bad news... */
2593 static void vl_api_sw_interface_rx_placement_details_t_handler
2594 (vl_api_sw_interface_rx_placement_details_t * mp)
2596 vat_main_t *vam = &vat_main;
2597 u32 worker_id = ntohl (mp->worker_id);
2600 "\n%-11d %-11s %-6d %-5d %-9s",
2601 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
2602 worker_id, ntohl (mp->queue_id),
2604 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
2607 static void vl_api_sw_interface_rx_placement_details_t_handler_json
2608 (vl_api_sw_interface_rx_placement_details_t * mp)
2610 vat_main_t *vam = &vat_main;
2611 vat_json_node_t *node = NULL;
2613 if (VAT_JSON_ARRAY != vam->json_tree.type)
2615 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2616 vat_json_init_array (&vam->json_tree);
2618 node = vat_json_array_add (&vam->json_tree);
2620 vat_json_init_object (node);
2621 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2622 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
2623 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
2624 vat_json_object_add_uint (node, "mode", mp->mode);
2628 api_sw_interface_rx_placement_dump (vat_main_t * vam)
2630 unformat_input_t *i = vam->input;
2631 vl_api_sw_interface_rx_placement_dump_t *mp;
2632 vl_api_control_ping_t *mp_ping;
2635 u8 sw_if_index_set = 0;
2637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2639 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2641 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2648 "\n%-11s %-11s %-6s %-5s %-4s",
2649 "sw_if_index", "main/worker", "thread", "queue", "mode");
2651 /* Dump Interface rx placement */
2652 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
2654 if (sw_if_index_set)
2655 mp->sw_if_index = htonl (sw_if_index);
2657 mp->sw_if_index = ~0;
2661 /* Use a control ping for synchronization */
2662 MPING (CONTROL_PING, mp_ping);
2670 api_sw_interface_clear_stats (vat_main_t * vam)
2672 unformat_input_t *i = vam->input;
2673 vl_api_sw_interface_clear_stats_t *mp;
2675 u8 sw_if_index_set = 0;
2678 /* Parse args required to build the message */
2679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2681 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2682 sw_if_index_set = 1;
2683 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2684 sw_if_index_set = 1;
2689 /* Construct the API message */
2690 M (SW_INTERFACE_CLEAR_STATS, mp);
2692 if (sw_if_index_set == 1)
2693 mp->sw_if_index = ntohl (sw_if_index);
2695 mp->sw_if_index = ~0;
2700 /* Wait for a reply, return the good/bad news... */
2706 api_sw_interface_add_del_address (vat_main_t * vam)
2708 unformat_input_t *i = vam->input;
2709 vl_api_sw_interface_add_del_address_t *mp;
2711 u8 sw_if_index_set = 0;
2712 u8 is_add = 1, del_all = 0;
2713 u32 address_length = 0;
2714 u8 v4_address_set = 0;
2715 u8 v6_address_set = 0;
2716 ip4_address_t v4address;
2717 ip6_address_t v6address;
2720 /* Parse args required to build the message */
2721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2723 if (unformat (i, "del-all"))
2725 else if (unformat (i, "del"))
2728 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2729 sw_if_index_set = 1;
2730 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2731 sw_if_index_set = 1;
2732 else if (unformat (i, "%U/%d",
2733 unformat_ip4_address, &v4address, &address_length))
2735 else if (unformat (i, "%U/%d",
2736 unformat_ip6_address, &v6address, &address_length))
2742 if (sw_if_index_set == 0)
2744 errmsg ("missing interface name or sw_if_index");
2747 if (v4_address_set && v6_address_set)
2749 errmsg ("both v4 and v6 addresses set");
2752 if (!v4_address_set && !v6_address_set && !del_all)
2754 errmsg ("no addresses set");
2758 /* Construct the API message */
2759 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
2761 mp->sw_if_index = ntohl (sw_if_index);
2762 mp->is_add = is_add;
2763 mp->del_all = del_all;
2766 mp->prefix.address.af = ADDRESS_IP6;
2767 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
2771 mp->prefix.address.af = ADDRESS_IP4;
2772 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
2774 mp->prefix.len = address_length;
2779 /* Wait for a reply, return good/bad news */
2785 api_sw_interface_set_mpls_enable (vat_main_t * vam)
2787 unformat_input_t *i = vam->input;
2788 vl_api_sw_interface_set_mpls_enable_t *mp;
2790 u8 sw_if_index_set = 0;
2794 /* Parse args required to build the message */
2795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2797 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2798 sw_if_index_set = 1;
2799 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2800 sw_if_index_set = 1;
2801 else if (unformat (i, "disable"))
2803 else if (unformat (i, "dis"))
2809 if (sw_if_index_set == 0)
2811 errmsg ("missing interface name or sw_if_index");
2815 /* Construct the API message */
2816 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
2818 mp->sw_if_index = ntohl (sw_if_index);
2819 mp->enable = enable;
2824 /* Wait for a reply... */
2830 api_sw_interface_set_table (vat_main_t * vam)
2832 unformat_input_t *i = vam->input;
2833 vl_api_sw_interface_set_table_t *mp;
2834 u32 sw_if_index, vrf_id = 0;
2835 u8 sw_if_index_set = 0;
2839 /* Parse args required to build the message */
2840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2842 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2843 sw_if_index_set = 1;
2844 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2845 sw_if_index_set = 1;
2846 else if (unformat (i, "vrf %d", &vrf_id))
2848 else if (unformat (i, "ipv6"))
2854 if (sw_if_index_set == 0)
2856 errmsg ("missing interface name or sw_if_index");
2860 /* Construct the API message */
2861 M (SW_INTERFACE_SET_TABLE, mp);
2863 mp->sw_if_index = ntohl (sw_if_index);
2864 mp->is_ipv6 = is_ipv6;
2865 mp->vrf_id = ntohl (vrf_id);
2870 /* Wait for a reply... */
2875 static void vl_api_sw_interface_get_table_reply_t_handler
2876 (vl_api_sw_interface_get_table_reply_t * mp)
2878 vat_main_t *vam = &vat_main;
2880 print (vam->ofp, "%d", ntohl (mp->vrf_id));
2882 vam->retval = ntohl (mp->retval);
2883 vam->result_ready = 1;
2887 static void vl_api_sw_interface_get_table_reply_t_handler_json
2888 (vl_api_sw_interface_get_table_reply_t * mp)
2890 vat_main_t *vam = &vat_main;
2891 vat_json_node_t node;
2893 vat_json_init_object (&node);
2894 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2895 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
2897 vat_json_print (vam->ofp, &node);
2898 vat_json_free (&node);
2900 vam->retval = ntohl (mp->retval);
2901 vam->result_ready = 1;
2905 api_sw_interface_get_table (vat_main_t * vam)
2907 unformat_input_t *i = vam->input;
2908 vl_api_sw_interface_get_table_t *mp;
2910 u8 sw_if_index_set = 0;
2914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2916 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2917 sw_if_index_set = 1;
2918 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2919 sw_if_index_set = 1;
2920 else if (unformat (i, "ipv6"))
2926 if (sw_if_index_set == 0)
2928 errmsg ("missing interface name or sw_if_index");
2932 M (SW_INTERFACE_GET_TABLE, mp);
2933 mp->sw_if_index = htonl (sw_if_index);
2934 mp->is_ipv6 = is_ipv6;
2942 api_sw_interface_set_vpath (vat_main_t * vam)
2944 unformat_input_t *i = vam->input;
2945 vl_api_sw_interface_set_vpath_t *mp;
2946 u32 sw_if_index = 0;
2947 u8 sw_if_index_set = 0;
2951 /* Parse args required to build the message */
2952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2954 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2955 sw_if_index_set = 1;
2956 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2957 sw_if_index_set = 1;
2958 else if (unformat (i, "enable"))
2960 else if (unformat (i, "disable"))
2966 if (sw_if_index_set == 0)
2968 errmsg ("missing interface name or sw_if_index");
2972 /* Construct the API message */
2973 M (SW_INTERFACE_SET_VPATH, mp);
2975 mp->sw_if_index = ntohl (sw_if_index);
2976 mp->enable = is_enable;
2981 /* Wait for a reply... */
2987 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
2989 unformat_input_t *i = vam->input;
2990 vl_api_sw_interface_set_l2_xconnect_t *mp;
2992 u8 rx_sw_if_index_set = 0;
2994 u8 tx_sw_if_index_set = 0;
2998 /* Parse args required to build the message */
2999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3001 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
3002 rx_sw_if_index_set = 1;
3003 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
3004 tx_sw_if_index_set = 1;
3005 else if (unformat (i, "rx"))
3007 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3009 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
3011 rx_sw_if_index_set = 1;
3016 else if (unformat (i, "tx"))
3018 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3020 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
3022 tx_sw_if_index_set = 1;
3027 else if (unformat (i, "enable"))
3029 else if (unformat (i, "disable"))
3035 if (rx_sw_if_index_set == 0)
3037 errmsg ("missing rx interface name or rx_sw_if_index");
3041 if (enable && (tx_sw_if_index_set == 0))
3043 errmsg ("missing tx interface name or tx_sw_if_index");
3047 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
3049 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
3050 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
3051 mp->enable = enable;
3059 api_sw_interface_set_l2_bridge (vat_main_t * vam)
3061 unformat_input_t *i = vam->input;
3062 vl_api_sw_interface_set_l2_bridge_t *mp;
3063 vl_api_l2_port_type_t port_type;
3065 u8 rx_sw_if_index_set = 0;
3072 port_type = L2_API_PORT_TYPE_NORMAL;
3074 /* Parse args required to build the message */
3075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3077 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
3078 rx_sw_if_index_set = 1;
3079 else if (unformat (i, "bd_id %d", &bd_id))
3083 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
3084 rx_sw_if_index_set = 1;
3085 else if (unformat (i, "shg %d", &shg))
3087 else if (unformat (i, "bvi"))
3088 port_type = L2_API_PORT_TYPE_BVI;
3089 else if (unformat (i, "uu-fwd"))
3090 port_type = L2_API_PORT_TYPE_UU_FWD;
3091 else if (unformat (i, "enable"))
3093 else if (unformat (i, "disable"))
3099 if (rx_sw_if_index_set == 0)
3101 errmsg ("missing rx interface name or sw_if_index");
3105 if (enable && (bd_id_set == 0))
3107 errmsg ("missing bridge domain");
3111 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
3113 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
3114 mp->bd_id = ntohl (bd_id);
3116 mp->port_type = ntohl (port_type);
3117 mp->enable = enable;
3125 api_bridge_domain_dump (vat_main_t * vam)
3127 unformat_input_t *i = vam->input;
3128 vl_api_bridge_domain_dump_t *mp;
3129 vl_api_control_ping_t *mp_ping;
3133 /* Parse args required to build the message */
3134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3136 if (unformat (i, "bd_id %d", &bd_id))
3142 M (BRIDGE_DOMAIN_DUMP, mp);
3143 mp->bd_id = ntohl (bd_id);
3146 /* Use a control ping for synchronization */
3147 MPING (CONTROL_PING, mp_ping);
3155 api_bridge_domain_add_del (vat_main_t * vam)
3157 unformat_input_t *i = vam->input;
3158 vl_api_bridge_domain_add_del_t *mp;
3161 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
3166 /* Parse args required to build the message */
3167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3169 if (unformat (i, "bd_id %d", &bd_id))
3171 else if (unformat (i, "flood %d", &flood))
3173 else if (unformat (i, "uu-flood %d", &uu_flood))
3175 else if (unformat (i, "forward %d", &forward))
3177 else if (unformat (i, "learn %d", &learn))
3179 else if (unformat (i, "arp-term %d", &arp_term))
3181 else if (unformat (i, "mac-age %d", &mac_age))
3183 else if (unformat (i, "bd-tag %s", &bd_tag))
3185 else if (unformat (i, "del"))
3188 flood = uu_flood = forward = learn = 0;
3196 errmsg ("missing bridge domain");
3203 errmsg ("mac age must be less than 256 ");
3208 if ((bd_tag) && (vec_len (bd_tag) > 63))
3210 errmsg ("bd-tag cannot be longer than 63");
3215 M (BRIDGE_DOMAIN_ADD_DEL, mp);
3217 mp->bd_id = ntohl (bd_id);
3219 mp->uu_flood = uu_flood;
3220 mp->forward = forward;
3222 mp->arp_term = arp_term;
3223 mp->is_add = is_add;
3224 mp->mac_age = (u8) mac_age;
3227 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
3228 mp->bd_tag[vec_len (bd_tag)] = 0;
3239 api_l2fib_flush_bd (vat_main_t * vam)
3241 unformat_input_t *i = vam->input;
3242 vl_api_l2fib_flush_bd_t *mp;
3246 /* Parse args required to build the message */
3247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3249 if (unformat (i, "bd_id %d", &bd_id));
3256 errmsg ("missing bridge domain");
3260 M (L2FIB_FLUSH_BD, mp);
3262 mp->bd_id = htonl (bd_id);
3270 api_l2fib_flush_int (vat_main_t * vam)
3272 unformat_input_t *i = vam->input;
3273 vl_api_l2fib_flush_int_t *mp;
3274 u32 sw_if_index = ~0;
3277 /* Parse args required to build the message */
3278 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3280 if (unformat (i, "sw_if_index %d", &sw_if_index));
3282 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
3287 if (sw_if_index == ~0)
3289 errmsg ("missing interface name or sw_if_index");
3293 M (L2FIB_FLUSH_INT, mp);
3295 mp->sw_if_index = ntohl (sw_if_index);
3303 api_l2fib_add_del (vat_main_t * vam)
3305 unformat_input_t *i = vam->input;
3306 vl_api_l2fib_add_del_t *mp;
3312 u32 sw_if_index = 0;
3313 u8 sw_if_index_set = 0;
3322 /* Parse args required to build the message */
3323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3325 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
3327 else if (unformat (i, "bd_id %d", &bd_id))
3329 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3330 sw_if_index_set = 1;
3331 else if (unformat (i, "sw_if"))
3333 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3336 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3337 sw_if_index_set = 1;
3342 else if (unformat (i, "static"))
3344 else if (unformat (i, "filter"))
3349 else if (unformat (i, "bvi"))
3354 else if (unformat (i, "del"))
3356 else if (unformat (i, "count %d", &count))
3364 errmsg ("missing mac address");
3370 errmsg ("missing bridge domain");
3374 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
3376 errmsg ("missing interface name or sw_if_index");
3382 /* Turn on async mode */
3383 vam->async_mode = 1;
3384 vam->async_errors = 0;
3385 before = vat_time_now (vam);
3388 for (j = 0; j < count; j++)
3390 M (L2FIB_ADD_DEL, mp);
3392 clib_memcpy (mp->mac, mac, 6);
3393 mp->bd_id = ntohl (bd_id);
3394 mp->is_add = is_add;
3395 mp->sw_if_index = ntohl (sw_if_index);
3399 mp->static_mac = static_mac;
3400 mp->filter_mac = filter_mac;
3401 mp->bvi_mac = bvi_mac;
3403 increment_mac_address (mac);
3410 vl_api_control_ping_t *mp_ping;
3413 /* Shut off async mode */
3414 vam->async_mode = 0;
3416 MPING (CONTROL_PING, mp_ping);
3419 timeout = vat_time_now (vam) + 1.0;
3420 while (vat_time_now (vam) < timeout)
3421 if (vam->result_ready == 1)
3426 if (vam->retval == -99)
3429 if (vam->async_errors > 0)
3431 errmsg ("%d asynchronous errors", vam->async_errors);
3434 vam->async_errors = 0;
3435 after = vat_time_now (vam);
3437 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
3438 count, after - before, count / (after - before));
3444 /* Wait for a reply... */
3448 /* Return the good/bad news */
3449 return (vam->retval);
3453 api_bridge_domain_set_mac_age (vat_main_t * vam)
3455 unformat_input_t *i = vam->input;
3456 vl_api_bridge_domain_set_mac_age_t *mp;
3461 /* Parse args required to build the message */
3462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3464 if (unformat (i, "bd_id %d", &bd_id));
3465 else if (unformat (i, "mac-age %d", &mac_age));
3472 errmsg ("missing bridge domain");
3478 errmsg ("mac age must be less than 256 ");
3482 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
3484 mp->bd_id = htonl (bd_id);
3485 mp->mac_age = (u8) mac_age;
3493 api_l2_flags (vat_main_t * vam)
3495 unformat_input_t *i = vam->input;
3496 vl_api_l2_flags_t *mp;
3499 u8 sw_if_index_set = 0;
3503 /* Parse args required to build the message */
3504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3506 if (unformat (i, "sw_if_index %d", &sw_if_index))
3507 sw_if_index_set = 1;
3508 else if (unformat (i, "sw_if"))
3510 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3513 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3514 sw_if_index_set = 1;
3519 else if (unformat (i, "learn"))
3521 else if (unformat (i, "forward"))
3523 else if (unformat (i, "flood"))
3525 else if (unformat (i, "uu-flood"))
3526 flags |= L2_UU_FLOOD;
3527 else if (unformat (i, "arp-term"))
3528 flags |= L2_ARP_TERM;
3529 else if (unformat (i, "off"))
3531 else if (unformat (i, "disable"))
3537 if (sw_if_index_set == 0)
3539 errmsg ("missing interface name or sw_if_index");
3545 mp->sw_if_index = ntohl (sw_if_index);
3546 mp->feature_bitmap = ntohl (flags);
3547 mp->is_set = is_set;
3555 api_bridge_flags (vat_main_t * vam)
3557 unformat_input_t *i = vam->input;
3558 vl_api_bridge_flags_t *mp;
3562 bd_flags_t flags = 0;
3565 /* Parse args required to build the message */
3566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3568 if (unformat (i, "bd_id %d", &bd_id))
3570 else if (unformat (i, "learn"))
3571 flags |= BRIDGE_API_FLAG_LEARN;
3572 else if (unformat (i, "forward"))
3573 flags |= BRIDGE_API_FLAG_FWD;
3574 else if (unformat (i, "flood"))
3575 flags |= BRIDGE_API_FLAG_FLOOD;
3576 else if (unformat (i, "uu-flood"))
3577 flags |= BRIDGE_API_FLAG_UU_FLOOD;
3578 else if (unformat (i, "arp-term"))
3579 flags |= BRIDGE_API_FLAG_ARP_TERM;
3580 else if (unformat (i, "off"))
3582 else if (unformat (i, "disable"))
3590 errmsg ("missing bridge domain");
3594 M (BRIDGE_FLAGS, mp);
3596 mp->bd_id = ntohl (bd_id);
3597 mp->flags = ntohl (flags);
3598 mp->is_set = is_set;
3606 api_bd_ip_mac_add_del (vat_main_t * vam)
3608 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
3609 vl_api_mac_address_t mac = { 0 };
3610 unformat_input_t *i = vam->input;
3611 vl_api_bd_ip_mac_add_del_t *mp;
3620 /* Parse args required to build the message */
3621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3623 if (unformat (i, "bd_id %d", &bd_id))
3627 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
3631 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
3635 else if (unformat (i, "del"))
3643 errmsg ("missing bridge domain");
3646 else if (ip_set == 0)
3648 errmsg ("missing IP address");
3651 else if (mac_set == 0)
3653 errmsg ("missing MAC address");
3657 M (BD_IP_MAC_ADD_DEL, mp);
3659 mp->entry.bd_id = ntohl (bd_id);
3660 mp->is_add = is_add;
3662 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
3663 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
3671 api_bd_ip_mac_flush (vat_main_t * vam)
3673 unformat_input_t *i = vam->input;
3674 vl_api_bd_ip_mac_flush_t *mp;
3679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3681 if (unformat (i, "bd_id %d", &bd_id))
3691 errmsg ("missing bridge domain");
3695 M (BD_IP_MAC_FLUSH, mp);
3697 mp->bd_id = ntohl (bd_id);
3704 static void vl_api_bd_ip_mac_details_t_handler
3705 (vl_api_bd_ip_mac_details_t * mp)
3707 vat_main_t *vam = &vat_main;
3711 ntohl (mp->entry.bd_id),
3712 format_vl_api_mac_address, mp->entry.mac,
3713 format_vl_api_address, &mp->entry.ip);
3716 static void vl_api_bd_ip_mac_details_t_handler_json
3717 (vl_api_bd_ip_mac_details_t * mp)
3719 vat_main_t *vam = &vat_main;
3720 vat_json_node_t *node = NULL;
3722 if (VAT_JSON_ARRAY != vam->json_tree.type)
3724 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3725 vat_json_init_array (&vam->json_tree);
3727 node = vat_json_array_add (&vam->json_tree);
3729 vat_json_init_object (node);
3730 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
3731 vat_json_object_add_string_copy (node, "mac_address",
3732 format (0, "%U", format_vl_api_mac_address,
3736 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
3737 vat_json_object_add_string_copy (node, "ip_address", ip);
3742 api_bd_ip_mac_dump (vat_main_t * vam)
3744 unformat_input_t *i = vam->input;
3745 vl_api_bd_ip_mac_dump_t *mp;
3746 vl_api_control_ping_t *mp_ping;
3751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3753 if (unformat (i, "bd_id %d", &bd_id))
3762 "\n%-5s %-7s %-20s %-30s",
3763 "bd_id", "is_ipv6", "mac_address", "ip_address");
3765 /* Dump Bridge Domain Ip to Mac entries */
3766 M (BD_IP_MAC_DUMP, mp);
3769 mp->bd_id = htonl (bd_id);
3775 /* Use a control ping for synchronization */
3776 MPING (CONTROL_PING, mp_ping);
3784 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
3786 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
3789 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
3792 addr->domain = x[0];
3795 addr->function = x[3];
3801 api_virtio_pci_create_v2 (vat_main_t * vam)
3803 unformat_input_t *i = vam->input;
3804 vl_api_virtio_pci_create_v2_t *mp;
3808 u64 features = (u64) ~ (0ULL);
3809 u32 virtio_flags = 0;
3812 clib_memset (mac_address, 0, sizeof (mac_address));
3814 /* Parse args required to build the message */
3815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3817 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
3821 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
3823 else if (unformat (i, "features 0x%llx", &features))
3825 else if (unformat (i, "gso-enabled"))
3826 virtio_flags |= VIRTIO_API_FLAG_GSO;
3827 else if (unformat (i, "csum-offload-enabled"))
3828 virtio_flags |= VIRTIO_API_FLAG_CSUM_OFFLOAD;
3829 else if (unformat (i, "gro-coalesce"))
3830 virtio_flags |= VIRTIO_API_FLAG_GRO_COALESCE;
3831 else if (unformat (i, "packed"))
3832 virtio_flags |= VIRTIO_API_FLAG_PACKED;
3833 else if (unformat (i, "in-order"))
3834 virtio_flags |= VIRTIO_API_FLAG_IN_ORDER;
3835 else if (unformat (i, "buffering"))
3836 virtio_flags |= VIRTIO_API_FLAG_BUFFERING;
3843 errmsg ("pci address must be non zero. ");
3847 /* Construct the API message */
3848 M (VIRTIO_PCI_CREATE_V2, mp);
3850 mp->use_random_mac = random_mac;
3852 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
3853 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
3854 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
3855 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
3857 mp->features = clib_host_to_net_u64 (features);
3858 mp->virtio_flags = clib_host_to_net_u32 (virtio_flags);
3860 if (random_mac == 0)
3861 clib_memcpy (mp->mac_address, mac_address, 6);
3866 /* Wait for a reply... */
3872 api_virtio_pci_delete (vat_main_t * vam)
3874 unformat_input_t *i = vam->input;
3875 vl_api_virtio_pci_delete_t *mp;
3876 u32 sw_if_index = ~0;
3877 u8 sw_if_index_set = 0;
3880 /* Parse args required to build the message */
3881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3883 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
3884 sw_if_index_set = 1;
3885 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3886 sw_if_index_set = 1;
3891 if (sw_if_index_set == 0)
3893 errmsg ("missing vpp interface name. ");
3897 /* Construct the API message */
3898 M (VIRTIO_PCI_DELETE, mp);
3900 mp->sw_if_index = htonl (sw_if_index);
3905 /* Wait for a reply... */
3911 api_ip_table_add_del (vat_main_t * vam)
3913 unformat_input_t *i = vam->input;
3914 vl_api_ip_table_add_del_t *mp;
3920 /* Parse args required to build the message */
3921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3923 if (unformat (i, "ipv6"))
3925 else if (unformat (i, "del"))
3927 else if (unformat (i, "add"))
3929 else if (unformat (i, "table %d", &table_id))
3933 clib_warning ("parse error '%U'", format_unformat_error, i);
3940 errmsg ("missing table-ID");
3944 /* Construct the API message */
3945 M (IP_TABLE_ADD_DEL, mp);
3947 mp->table.table_id = ntohl (table_id);
3948 mp->table.is_ip6 = is_ipv6;
3949 mp->is_add = is_add;
3954 /* Wait for a reply... */
3961 unformat_fib_path (unformat_input_t * input, va_list * args)
3963 vat_main_t *vam = va_arg (*args, vat_main_t *);
3964 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
3965 u32 weight, preference;
3966 mpls_label_t out_label;
3968 clib_memset (path, 0, sizeof (*path));
3970 path->sw_if_index = ~0;
3974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3976 if (unformat (input, "%U %U",
3977 unformat_vl_api_ip4_address,
3978 &path->nh.address.ip4,
3979 api_unformat_sw_if_index, vam, &path->sw_if_index))
3981 path->proto = FIB_API_PATH_NH_PROTO_IP4;
3983 else if (unformat (input, "%U %U",
3984 unformat_vl_api_ip6_address,
3985 &path->nh.address.ip6,
3986 api_unformat_sw_if_index, vam, &path->sw_if_index))
3988 path->proto = FIB_API_PATH_NH_PROTO_IP6;
3990 else if (unformat (input, "weight %u", &weight))
3992 path->weight = weight;
3994 else if (unformat (input, "preference %u", &preference))
3996 path->preference = preference;
3998 else if (unformat (input, "%U next-hop-table %d",
3999 unformat_vl_api_ip4_address,
4000 &path->nh.address.ip4, &path->table_id))
4002 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4004 else if (unformat (input, "%U next-hop-table %d",
4005 unformat_vl_api_ip6_address,
4006 &path->nh.address.ip6, &path->table_id))
4008 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4010 else if (unformat (input, "%U",
4011 unformat_vl_api_ip4_address, &path->nh.address.ip4))
4014 * the recursive next-hops are by default in the default table
4017 path->sw_if_index = ~0;
4018 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4020 else if (unformat (input, "%U",
4021 unformat_vl_api_ip6_address, &path->nh.address.ip6))
4024 * the recursive next-hops are by default in the default table
4027 path->sw_if_index = ~0;
4028 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4030 else if (unformat (input, "resolve-via-host"))
4032 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
4034 else if (unformat (input, "resolve-via-attached"))
4036 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
4038 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
4040 path->type = FIB_API_PATH_TYPE_LOCAL;
4041 path->sw_if_index = ~0;
4042 path->proto = FIB_API_PATH_NH_PROTO_IP4;
4044 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
4046 path->type = FIB_API_PATH_TYPE_LOCAL;
4047 path->sw_if_index = ~0;
4048 path->proto = FIB_API_PATH_NH_PROTO_IP6;
4050 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
4052 else if (unformat (input, "via-label %d", &path->nh.via_label))
4054 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
4055 path->sw_if_index = ~0;
4057 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
4059 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
4060 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
4062 else if (unformat (input, "local"))
4064 path->type = FIB_API_PATH_TYPE_LOCAL;
4066 else if (unformat (input, "out-labels"))
4068 while (unformat (input, "%d", &out_label))
4070 path->label_stack[path->n_labels].label = out_label;
4071 path->label_stack[path->n_labels].is_uniform = 0;
4072 path->label_stack[path->n_labels].ttl = 64;
4076 else if (unformat (input, "via"))
4078 /* new path, back up and return */
4079 unformat_put_input (input);
4080 unformat_put_input (input);
4081 unformat_put_input (input);
4082 unformat_put_input (input);
4091 path->proto = ntohl (path->proto);
4092 path->type = ntohl (path->type);
4093 path->flags = ntohl (path->flags);
4094 path->table_id = ntohl (path->table_id);
4095 path->sw_if_index = ntohl (path->sw_if_index);
4101 api_ip_route_add_del (vat_main_t * vam)
4103 unformat_input_t *i = vam->input;
4104 vl_api_ip_route_add_del_t *mp;
4107 u8 is_multipath = 0;
4110 vl_api_prefix_t pfx = { };
4111 vl_api_fib_path_t paths[8];
4115 u32 random_add_del = 0;
4116 u32 *random_vector = 0;
4117 u32 random_seed = 0xdeaddabe;
4119 /* Parse args required to build the message */
4120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4122 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
4124 else if (unformat (i, "del"))
4126 else if (unformat (i, "add"))
4128 else if (unformat (i, "vrf %d", &vrf_id))
4130 else if (unformat (i, "count %d", &count))
4132 else if (unformat (i, "random"))
4134 else if (unformat (i, "multipath"))
4136 else if (unformat (i, "seed %d", &random_seed))
4140 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4143 if (8 == path_count)
4145 errmsg ("max 8 paths");
4151 clib_warning ("parse error '%U'", format_unformat_error, i);
4158 errmsg ("specify a path; via ...");
4161 if (prefix_set == 0)
4163 errmsg ("missing prefix");
4167 /* Generate a pile of unique, random routes */
4170 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
4171 u32 this_random_address;
4174 random_hash = hash_create (count, sizeof (uword));
4176 hash_set (random_hash, i->as_u32, 1);
4177 for (j = 0; j <= count; j++)
4181 this_random_address = random_u32 (&random_seed);
4182 this_random_address =
4183 clib_host_to_net_u32 (this_random_address);
4185 while (hash_get (random_hash, this_random_address));
4186 vec_add1 (random_vector, this_random_address);
4187 hash_set (random_hash, this_random_address, 1);
4189 hash_free (random_hash);
4190 set_ip4_address (&pfx.address, random_vector[0]);
4195 /* Turn on async mode */
4196 vam->async_mode = 1;
4197 vam->async_errors = 0;
4198 before = vat_time_now (vam);
4201 for (j = 0; j < count; j++)
4203 /* Construct the API message */
4204 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4206 mp->is_add = is_add;
4207 mp->is_multipath = is_multipath;
4209 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
4210 mp->route.table_id = ntohl (vrf_id);
4211 mp->route.n_paths = path_count;
4213 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
4216 set_ip4_address (&pfx.address, random_vector[j + 1]);
4218 increment_address (&pfx.address);
4221 /* If we receive SIGTERM, stop now... */
4226 /* When testing multiple add/del ops, use a control-ping to sync */
4229 vl_api_control_ping_t *mp_ping;
4233 /* Shut off async mode */
4234 vam->async_mode = 0;
4236 MPING (CONTROL_PING, mp_ping);
4239 timeout = vat_time_now (vam) + 1.0;
4240 while (vat_time_now (vam) < timeout)
4241 if (vam->result_ready == 1)
4246 if (vam->retval == -99)
4249 if (vam->async_errors > 0)
4251 errmsg ("%d asynchronous errors", vam->async_errors);
4254 vam->async_errors = 0;
4255 after = vat_time_now (vam);
4257 /* slim chance, but we might have eaten SIGTERM on the first iteration */
4261 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4262 count, after - before, count / (after - before));
4268 /* Wait for a reply... */
4273 /* Return the good/bad news */
4274 return (vam->retval);
4278 api_ip_mroute_add_del (vat_main_t * vam)
4280 unformat_input_t *i = vam->input;
4281 u8 path_set = 0, prefix_set = 0, is_add = 1;
4282 vl_api_ip_mroute_add_del_t *mp;
4283 mfib_entry_flags_t eflags = 0;
4284 vl_api_mfib_path_t path;
4285 vl_api_mprefix_t pfx = { };
4289 /* Parse args required to build the message */
4290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4292 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
4295 pfx.grp_address_length = htons (pfx.grp_address_length);
4297 else if (unformat (i, "del"))
4299 else if (unformat (i, "add"))
4301 else if (unformat (i, "vrf %d", &vrf_id))
4303 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
4304 path.itf_flags = htonl (path.itf_flags);
4305 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
4307 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
4311 clib_warning ("parse error '%U'", format_unformat_error, i);
4316 if (prefix_set == 0)
4318 errmsg ("missing addresses\n");
4323 errmsg ("missing path\n");
4327 /* Construct the API message */
4328 M (IP_MROUTE_ADD_DEL, mp);
4330 mp->is_add = is_add;
4331 mp->is_multipath = 1;
4333 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
4334 mp->route.table_id = htonl (vrf_id);
4335 mp->route.n_paths = 1;
4336 mp->route.entry_flags = htonl (eflags);
4338 clib_memcpy (&mp->route.paths, &path, sizeof (path));
4342 /* Wait for a reply... */
4348 api_mpls_table_add_del (vat_main_t * vam)
4350 unformat_input_t *i = vam->input;
4351 vl_api_mpls_table_add_del_t *mp;
4356 /* Parse args required to build the message */
4357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4359 if (unformat (i, "table %d", &table_id))
4361 else if (unformat (i, "del"))
4363 else if (unformat (i, "add"))
4367 clib_warning ("parse error '%U'", format_unformat_error, i);
4374 errmsg ("missing table-ID");
4378 /* Construct the API message */
4379 M (MPLS_TABLE_ADD_DEL, mp);
4381 mp->mt_table.mt_table_id = ntohl (table_id);
4382 mp->mt_is_add = is_add;
4387 /* Wait for a reply... */
4394 api_mpls_route_add_del (vat_main_t * vam)
4396 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
4397 mpls_label_t local_label = MPLS_LABEL_INVALID;
4398 unformat_input_t *i = vam->input;
4399 vl_api_mpls_route_add_del_t *mp;
4400 vl_api_fib_path_t paths[8];
4404 /* Parse args required to build the message */
4405 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4407 if (unformat (i, "%d", &local_label))
4409 else if (unformat (i, "eos"))
4411 else if (unformat (i, "non-eos"))
4413 else if (unformat (i, "del"))
4415 else if (unformat (i, "add"))
4417 else if (unformat (i, "multipath"))
4419 else if (unformat (i, "count %d", &count))
4423 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4426 if (8 == path_count)
4428 errmsg ("max 8 paths");
4434 clib_warning ("parse error '%U'", format_unformat_error, i);
4441 errmsg ("specify a path; via ...");
4445 if (MPLS_LABEL_INVALID == local_label)
4447 errmsg ("missing label");
4453 /* Turn on async mode */
4454 vam->async_mode = 1;
4455 vam->async_errors = 0;
4456 before = vat_time_now (vam);
4459 for (j = 0; j < count; j++)
4461 /* Construct the API message */
4462 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4464 mp->mr_is_add = is_add;
4465 mp->mr_is_multipath = is_multipath;
4467 mp->mr_route.mr_label = local_label;
4468 mp->mr_route.mr_eos = is_eos;
4469 mp->mr_route.mr_table_id = 0;
4470 mp->mr_route.mr_n_paths = path_count;
4472 clib_memcpy (&mp->mr_route.mr_paths, paths,
4473 sizeof (paths[0]) * path_count);
4479 /* If we receive SIGTERM, stop now... */
4484 /* When testing multiple add/del ops, use a control-ping to sync */
4487 vl_api_control_ping_t *mp_ping;
4491 /* Shut off async mode */
4492 vam->async_mode = 0;
4494 MPING (CONTROL_PING, mp_ping);
4497 timeout = vat_time_now (vam) + 1.0;
4498 while (vat_time_now (vam) < timeout)
4499 if (vam->result_ready == 1)
4504 if (vam->retval == -99)
4507 if (vam->async_errors > 0)
4509 errmsg ("%d asynchronous errors", vam->async_errors);
4512 vam->async_errors = 0;
4513 after = vat_time_now (vam);
4515 /* slim chance, but we might have eaten SIGTERM on the first iteration */
4519 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
4520 count, after - before, count / (after - before));
4526 /* Wait for a reply... */
4531 /* Return the good/bad news */
4532 return (vam->retval);
4537 api_mpls_ip_bind_unbind (vat_main_t * vam)
4539 unformat_input_t *i = vam->input;
4540 vl_api_mpls_ip_bind_unbind_t *mp;
4541 u32 ip_table_id = 0;
4543 vl_api_prefix_t pfx;
4545 mpls_label_t local_label = MPLS_LABEL_INVALID;
4548 /* Parse args required to build the message */
4549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4551 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
4553 else if (unformat (i, "%d", &local_label))
4555 else if (unformat (i, "table-id %d", &ip_table_id))
4557 else if (unformat (i, "unbind"))
4559 else if (unformat (i, "bind"))
4563 clib_warning ("parse error '%U'", format_unformat_error, i);
4570 errmsg ("IP prefix not set");
4574 if (MPLS_LABEL_INVALID == local_label)
4576 errmsg ("missing label");
4580 /* Construct the API message */
4581 M (MPLS_IP_BIND_UNBIND, mp);
4583 mp->mb_is_bind = is_bind;
4584 mp->mb_ip_table_id = ntohl (ip_table_id);
4585 mp->mb_mpls_table_id = 0;
4586 mp->mb_label = ntohl (local_label);
4587 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
4592 /* Wait for a reply... */
4599 api_mpls_tunnel_add_del (vat_main_t * vam)
4601 unformat_input_t *i = vam->input;
4602 vl_api_mpls_tunnel_add_del_t *mp;
4604 vl_api_fib_path_t paths[8];
4605 u32 sw_if_index = ~0;
4611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4613 if (unformat (i, "add"))
4617 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
4619 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
4621 else if (unformat (i, "l2-only"))
4625 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
4628 if (8 == path_count)
4630 errmsg ("max 8 paths");
4636 clib_warning ("parse error '%U'", format_unformat_error, i);
4641 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
4643 mp->mt_is_add = is_add;
4644 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
4645 mp->mt_tunnel.mt_l2_only = l2_only;
4646 mp->mt_tunnel.mt_is_multicast = 0;
4647 mp->mt_tunnel.mt_n_paths = path_count;
4649 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
4650 sizeof (paths[0]) * path_count);
4658 api_sw_interface_set_unnumbered (vat_main_t * vam)
4660 unformat_input_t *i = vam->input;
4661 vl_api_sw_interface_set_unnumbered_t *mp;
4663 u32 unnum_sw_index = ~0;
4665 u8 sw_if_index_set = 0;
4668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4670 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4671 sw_if_index_set = 1;
4672 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4673 sw_if_index_set = 1;
4674 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4676 else if (unformat (i, "del"))
4680 clib_warning ("parse error '%U'", format_unformat_error, i);
4685 if (sw_if_index_set == 0)
4687 errmsg ("missing interface name or sw_if_index");
4691 M (SW_INTERFACE_SET_UNNUMBERED, mp);
4693 mp->sw_if_index = ntohl (sw_if_index);
4694 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
4695 mp->is_add = is_add;
4704 api_create_vlan_subif (vat_main_t * vam)
4706 unformat_input_t *i = vam->input;
4707 vl_api_create_vlan_subif_t *mp;
4709 u8 sw_if_index_set = 0;
4714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4716 if (unformat (i, "sw_if_index %d", &sw_if_index))
4717 sw_if_index_set = 1;
4719 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4720 sw_if_index_set = 1;
4721 else if (unformat (i, "vlan %d", &vlan_id))
4725 clib_warning ("parse error '%U'", format_unformat_error, i);
4730 if (sw_if_index_set == 0)
4732 errmsg ("missing interface name or sw_if_index");
4736 if (vlan_id_set == 0)
4738 errmsg ("missing vlan_id");
4741 M (CREATE_VLAN_SUBIF, mp);
4743 mp->sw_if_index = ntohl (sw_if_index);
4744 mp->vlan_id = ntohl (vlan_id);
4751 #define foreach_create_subif_bit \
4758 _(outer_vlan_id_any) \
4759 _(inner_vlan_id_any)
4761 #define foreach_create_subif_flag \
4766 _(4, "exact_match") \
4767 _(5, "default_sub") \
4768 _(6, "outer_vlan_id_any") \
4769 _(7, "inner_vlan_id_any")
4772 api_create_subif (vat_main_t * vam)
4774 unformat_input_t *i = vam->input;
4775 vl_api_create_subif_t *mp;
4777 u8 sw_if_index_set = 0;
4780 u32 __attribute__ ((unused)) no_tags = 0;
4781 u32 __attribute__ ((unused)) one_tag = 0;
4782 u32 __attribute__ ((unused)) two_tags = 0;
4783 u32 __attribute__ ((unused)) dot1ad = 0;
4784 u32 __attribute__ ((unused)) exact_match = 0;
4785 u32 __attribute__ ((unused)) default_sub = 0;
4786 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
4787 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
4789 u16 outer_vlan_id = 0;
4790 u16 inner_vlan_id = 0;
4793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4795 if (unformat (i, "sw_if_index %d", &sw_if_index))
4796 sw_if_index_set = 1;
4798 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4799 sw_if_index_set = 1;
4800 else if (unformat (i, "sub_id %d", &sub_id))
4802 else if (unformat (i, "outer_vlan_id %d", &tmp))
4803 outer_vlan_id = tmp;
4804 else if (unformat (i, "inner_vlan_id %d", &tmp))
4805 inner_vlan_id = tmp;
4807 #define _(a) else if (unformat (i, #a)) a = 1 ;
4808 foreach_create_subif_bit
4812 clib_warning ("parse error '%U'", format_unformat_error, i);
4817 if (sw_if_index_set == 0)
4819 errmsg ("missing interface name or sw_if_index");
4823 if (sub_id_set == 0)
4825 errmsg ("missing sub_id");
4828 M (CREATE_SUBIF, mp);
4830 mp->sw_if_index = ntohl (sw_if_index);
4831 mp->sub_id = ntohl (sub_id);
4833 #define _(a,b) mp->sub_if_flags |= (1 << a);
4834 foreach_create_subif_flag;
4837 mp->outer_vlan_id = ntohs (outer_vlan_id);
4838 mp->inner_vlan_id = ntohs (inner_vlan_id);
4846 api_ip_table_replace_begin (vat_main_t * vam)
4848 unformat_input_t *i = vam->input;
4849 vl_api_ip_table_replace_begin_t *mp;
4854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4856 if (unformat (i, "table %d", &table_id))
4858 else if (unformat (i, "ipv6"))
4862 clib_warning ("parse error '%U'", format_unformat_error, i);
4867 M (IP_TABLE_REPLACE_BEGIN, mp);
4869 mp->table.table_id = ntohl (table_id);
4870 mp->table.is_ip6 = is_ipv6;
4878 api_ip_table_flush (vat_main_t * vam)
4880 unformat_input_t *i = vam->input;
4881 vl_api_ip_table_flush_t *mp;
4886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4888 if (unformat (i, "table %d", &table_id))
4890 else if (unformat (i, "ipv6"))
4894 clib_warning ("parse error '%U'", format_unformat_error, i);
4899 M (IP_TABLE_FLUSH, mp);
4901 mp->table.table_id = ntohl (table_id);
4902 mp->table.is_ip6 = is_ipv6;
4910 api_ip_table_replace_end (vat_main_t * vam)
4912 unformat_input_t *i = vam->input;
4913 vl_api_ip_table_replace_end_t *mp;
4918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4920 if (unformat (i, "table %d", &table_id))
4922 else if (unformat (i, "ipv6"))
4926 clib_warning ("parse error '%U'", format_unformat_error, i);
4931 M (IP_TABLE_REPLACE_END, mp);
4933 mp->table.table_id = ntohl (table_id);
4934 mp->table.is_ip6 = is_ipv6;
4942 api_set_ip_flow_hash (vat_main_t * vam)
4944 unformat_input_t *i = vam->input;
4945 vl_api_set_ip_flow_hash_t *mp;
4957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4959 if (unformat (i, "vrf %d", &vrf_id))
4961 else if (unformat (i, "ipv6"))
4963 else if (unformat (i, "src"))
4965 else if (unformat (i, "dst"))
4967 else if (unformat (i, "sport"))
4969 else if (unformat (i, "dport"))
4971 else if (unformat (i, "proto"))
4973 else if (unformat (i, "reverse"))
4978 clib_warning ("parse error '%U'", format_unformat_error, i);
4983 if (vrf_id_set == 0)
4985 errmsg ("missing vrf id");
4989 M (SET_IP_FLOW_HASH, mp);
4995 mp->reverse = reverse;
4996 mp->vrf_id = ntohl (vrf_id);
4997 mp->is_ipv6 = is_ipv6;
5005 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5007 unformat_input_t *i = vam->input;
5008 vl_api_sw_interface_ip6_enable_disable_t *mp;
5010 u8 sw_if_index_set = 0;
5014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5016 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5017 sw_if_index_set = 1;
5018 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5019 sw_if_index_set = 1;
5020 else if (unformat (i, "enable"))
5022 else if (unformat (i, "disable"))
5026 clib_warning ("parse error '%U'", format_unformat_error, i);
5031 if (sw_if_index_set == 0)
5033 errmsg ("missing interface name or sw_if_index");
5037 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
5039 mp->sw_if_index = ntohl (sw_if_index);
5040 mp->enable = enable;
5049 api_l2_patch_add_del (vat_main_t * vam)
5051 unformat_input_t *i = vam->input;
5052 vl_api_l2_patch_add_del_t *mp;
5054 u8 rx_sw_if_index_set = 0;
5056 u8 tx_sw_if_index_set = 0;
5060 /* Parse args required to build the message */
5061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5063 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5064 rx_sw_if_index_set = 1;
5065 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5066 tx_sw_if_index_set = 1;
5067 else if (unformat (i, "rx"))
5069 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5071 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5073 rx_sw_if_index_set = 1;
5078 else if (unformat (i, "tx"))
5080 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5082 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5084 tx_sw_if_index_set = 1;
5089 else if (unformat (i, "del"))
5095 if (rx_sw_if_index_set == 0)
5097 errmsg ("missing rx interface name or rx_sw_if_index");
5101 if (tx_sw_if_index_set == 0)
5103 errmsg ("missing tx interface name or tx_sw_if_index");
5107 M (L2_PATCH_ADD_DEL, mp);
5109 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5110 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5111 mp->is_add = is_add;
5119 u8 localsid_addr[16];
5128 api_ioam_enable (vat_main_t * vam)
5130 unformat_input_t *input = vam->input;
5131 vl_api_ioam_enable_t *mp;
5133 int has_trace_option = 0;
5134 int has_pot_option = 0;
5135 int has_seqno_option = 0;
5136 int has_analyse_option = 0;
5139 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5141 if (unformat (input, "trace"))
5142 has_trace_option = 1;
5143 else if (unformat (input, "pot"))
5145 else if (unformat (input, "seqno"))
5146 has_seqno_option = 1;
5147 else if (unformat (input, "analyse"))
5148 has_analyse_option = 1;
5152 M (IOAM_ENABLE, mp);
5153 mp->id = htons (id);
5154 mp->seqno = has_seqno_option;
5155 mp->analyse = has_analyse_option;
5156 mp->pot_enable = has_pot_option;
5157 mp->trace_enable = has_trace_option;
5166 api_ioam_disable (vat_main_t * vam)
5168 vl_api_ioam_disable_t *mp;
5171 M (IOAM_DISABLE, mp);
5177 #define foreach_tcp_proto_field \
5181 #define foreach_udp_proto_field \
5185 #define foreach_ip4_proto_field \
5197 u16 src_port, dst_port;
5200 #if VPP_API_TEST_BUILTIN == 0
5202 unformat_tcp_mask (unformat_input_t * input, va_list * args)
5204 u8 **maskp = va_arg (*args, u8 **);
5206 u8 found_something = 0;
5209 #define _(a) u8 a=0;
5210 foreach_tcp_proto_field;
5213 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5216 #define _(a) else if (unformat (input, #a)) a=1;
5217 foreach_tcp_proto_field
5223 #define _(a) found_something += a;
5224 foreach_tcp_proto_field;
5227 if (found_something == 0)
5230 vec_validate (mask, sizeof (*tcp) - 1);
5232 tcp = (tcp_header_t *) mask;
5234 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
5235 foreach_tcp_proto_field;
5243 unformat_udp_mask (unformat_input_t * input, va_list * args)
5245 u8 **maskp = va_arg (*args, u8 **);
5247 u8 found_something = 0;
5250 #define _(a) u8 a=0;
5251 foreach_udp_proto_field;
5254 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5257 #define _(a) else if (unformat (input, #a)) a=1;
5258 foreach_udp_proto_field
5264 #define _(a) found_something += a;
5265 foreach_udp_proto_field;
5268 if (found_something == 0)
5271 vec_validate (mask, sizeof (*udp) - 1);
5273 udp = (udp_header_t *) mask;
5275 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
5276 foreach_udp_proto_field;
5284 unformat_l4_mask (unformat_input_t * input, va_list * args)
5286 u8 **maskp = va_arg (*args, u8 **);
5287 u16 src_port = 0, dst_port = 0;
5288 tcpudp_header_t *tcpudp;
5290 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5292 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
5294 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
5296 else if (unformat (input, "src_port"))
5298 else if (unformat (input, "dst_port"))
5304 if (!src_port && !dst_port)
5308 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
5310 tcpudp = (tcpudp_header_t *) mask;
5311 tcpudp->src_port = src_port;
5312 tcpudp->dst_port = dst_port;
5320 unformat_ip4_mask (unformat_input_t * input, va_list * args)
5322 u8 **maskp = va_arg (*args, u8 **);
5324 u8 found_something = 0;
5327 #define _(a) u8 a=0;
5328 foreach_ip4_proto_field;
5334 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5336 if (unformat (input, "version"))
5338 else if (unformat (input, "hdr_length"))
5340 else if (unformat (input, "src"))
5342 else if (unformat (input, "dst"))
5344 else if (unformat (input, "proto"))
5347 #define _(a) else if (unformat (input, #a)) a=1;
5348 foreach_ip4_proto_field
5354 #define _(a) found_something += a;
5355 foreach_ip4_proto_field;
5358 if (found_something == 0)
5361 vec_validate (mask, sizeof (*ip) - 1);
5363 ip = (ip4_header_t *) mask;
5365 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
5366 foreach_ip4_proto_field;
5369 ip->ip_version_and_header_length = 0;
5372 ip->ip_version_and_header_length |= 0xF0;
5375 ip->ip_version_and_header_length |= 0x0F;
5381 #define foreach_ip6_proto_field \
5389 unformat_ip6_mask (unformat_input_t * input, va_list * args)
5391 u8 **maskp = va_arg (*args, u8 **);
5393 u8 found_something = 0;
5395 u32 ip_version_traffic_class_and_flow_label;
5397 #define _(a) u8 a=0;
5398 foreach_ip6_proto_field;
5401 u8 traffic_class = 0;
5404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5406 if (unformat (input, "version"))
5408 else if (unformat (input, "traffic-class"))
5410 else if (unformat (input, "flow-label"))
5412 else if (unformat (input, "src"))
5414 else if (unformat (input, "dst"))
5416 else if (unformat (input, "proto"))
5419 #define _(a) else if (unformat (input, #a)) a=1;
5420 foreach_ip6_proto_field
5426 #define _(a) found_something += a;
5427 foreach_ip6_proto_field;
5430 if (found_something == 0)
5433 vec_validate (mask, sizeof (*ip) - 1);
5435 ip = (ip6_header_t *) mask;
5437 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
5438 foreach_ip6_proto_field;
5441 ip_version_traffic_class_and_flow_label = 0;
5444 ip_version_traffic_class_and_flow_label |= 0xF0000000;
5447 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
5450 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
5452 ip->ip_version_traffic_class_and_flow_label =
5453 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
5460 unformat_l3_mask (unformat_input_t * input, va_list * args)
5462 u8 **maskp = va_arg (*args, u8 **);
5464 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5466 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
5468 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
5477 unformat_l2_mask (unformat_input_t * input, va_list * args)
5479 u8 **maskp = va_arg (*args, u8 **);
5494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5496 if (unformat (input, "src"))
5498 else if (unformat (input, "dst"))
5500 else if (unformat (input, "proto"))
5502 else if (unformat (input, "tag1"))
5504 else if (unformat (input, "tag2"))
5506 else if (unformat (input, "ignore-tag1"))
5508 else if (unformat (input, "ignore-tag2"))
5510 else if (unformat (input, "cos1"))
5512 else if (unformat (input, "cos2"))
5514 else if (unformat (input, "dot1q"))
5516 else if (unformat (input, "dot1ad"))
5521 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
5522 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
5525 if (tag1 || ignore_tag1 || cos1 || dot1q)
5527 if (tag2 || ignore_tag2 || cos2 || dot1ad)
5530 vec_validate (mask, len - 1);
5533 clib_memset (mask, 0xff, 6);
5536 clib_memset (mask + 6, 0xff, 6);
5540 /* inner vlan tag */
5549 mask[21] = mask[20] = 0xff;
5570 mask[16] = mask[17] = 0xff;
5580 mask[12] = mask[13] = 0xff;
5587 unformat_classify_mask (unformat_input_t * input, va_list * args)
5589 u8 **maskp = va_arg (*args, u8 **);
5590 u32 *skipp = va_arg (*args, u32 *);
5591 u32 *matchp = va_arg (*args, u32 *);
5599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5601 if (unformat (input, "hex %U", unformat_hex_string, &mask))
5603 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
5605 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
5607 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
5621 if (mask || l2 || l3 || l4)
5625 /* "With a free Ethernet header in every package" */
5627 vec_validate (l2, 13);
5631 vec_append (mask, l3);
5636 vec_append (mask, l4);
5641 /* Scan forward looking for the first significant mask octet */
5642 for (i = 0; i < vec_len (mask); i++)
5646 /* compute (skip, match) params */
5647 *skipp = i / sizeof (u32x4);
5648 vec_delete (mask, *skipp * sizeof (u32x4), 0);
5650 /* Pad mask to an even multiple of the vector size */
5651 while (vec_len (mask) % sizeof (u32x4))
5654 match = vec_len (mask) / sizeof (u32x4);
5656 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
5658 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
5659 if (*tmp || *(tmp + 1))
5664 clib_warning ("BUG: match 0");
5666 _vec_len (mask) = match * sizeof (u32x4);
5676 #endif /* VPP_API_TEST_BUILTIN */
5678 #define foreach_l2_next \
5680 _(ethernet, ETHERNET_INPUT) \
5685 unformat_l2_next_index (unformat_input_t * input, va_list * args)
5687 u32 *miss_next_indexp = va_arg (*args, u32 *);
5692 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
5696 if (unformat (input, "%d", &tmp))
5705 *miss_next_indexp = next_index;
5709 #define foreach_ip_next \
5715 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
5717 u32 *miss_next_indexp = va_arg (*args, u32 *);
5722 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
5726 if (unformat (input, "%d", &tmp))
5735 *miss_next_indexp = next_index;
5739 #define foreach_acl_next \
5743 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
5745 u32 *miss_next_indexp = va_arg (*args, u32 *);
5750 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
5754 if (unformat (input, "permit"))
5759 else if (unformat (input, "%d", &tmp))
5768 *miss_next_indexp = next_index;
5773 unformat_policer_precolor (unformat_input_t * input, va_list * args)
5775 u32 *r = va_arg (*args, u32 *);
5777 if (unformat (input, "conform-color"))
5778 *r = POLICE_CONFORM;
5779 else if (unformat (input, "exceed-color"))
5787 #if VPP_API_TEST_BUILTIN == 0
5789 unformat_l4_match (unformat_input_t * input, va_list * args)
5791 u8 **matchp = va_arg (*args, u8 **);
5793 u8 *proto_header = 0;
5799 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5801 if (unformat (input, "src_port %d", &src_port))
5803 else if (unformat (input, "dst_port %d", &dst_port))
5809 h.src_port = clib_host_to_net_u16 (src_port);
5810 h.dst_port = clib_host_to_net_u16 (dst_port);
5811 vec_validate (proto_header, sizeof (h) - 1);
5812 memcpy (proto_header, &h, sizeof (h));
5814 *matchp = proto_header;
5820 unformat_ip4_match (unformat_input_t * input, va_list * args)
5822 u8 **matchp = va_arg (*args, u8 **);
5829 int src = 0, dst = 0;
5830 ip4_address_t src_val, dst_val;
5837 int fragment_id = 0;
5838 u32 fragment_id_val;
5844 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5846 if (unformat (input, "version %d", &version_val))
5848 else if (unformat (input, "hdr_length %d", &hdr_length_val))
5850 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
5852 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
5854 else if (unformat (input, "proto %d", &proto_val))
5856 else if (unformat (input, "tos %d", &tos_val))
5858 else if (unformat (input, "length %d", &length_val))
5860 else if (unformat (input, "fragment_id %d", &fragment_id_val))
5862 else if (unformat (input, "ttl %d", &ttl_val))
5864 else if (unformat (input, "checksum %d", &checksum_val))
5870 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
5871 + ttl + checksum == 0)
5875 * Aligned because we use the real comparison functions
5877 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
5879 ip = (ip4_header_t *) match;
5881 /* These are realistically matched in practice */
5883 ip->src_address.as_u32 = src_val.as_u32;
5886 ip->dst_address.as_u32 = dst_val.as_u32;
5889 ip->protocol = proto_val;
5892 /* These are not, but they're included for completeness */
5894 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
5897 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
5903 ip->length = clib_host_to_net_u16 (length_val);
5909 ip->checksum = clib_host_to_net_u16 (checksum_val);
5916 unformat_ip6_match (unformat_input_t * input, va_list * args)
5918 u8 **matchp = va_arg (*args, u8 **);
5923 u8 traffic_class = 0;
5924 u32 traffic_class_val = 0;
5927 int src = 0, dst = 0;
5928 ip6_address_t src_val, dst_val;
5931 int payload_length = 0;
5932 u32 payload_length_val;
5935 u32 ip_version_traffic_class_and_flow_label;
5937 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5939 if (unformat (input, "version %d", &version_val))
5941 else if (unformat (input, "traffic_class %d", &traffic_class_val))
5943 else if (unformat (input, "flow_label %d", &flow_label_val))
5945 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
5947 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
5949 else if (unformat (input, "proto %d", &proto_val))
5951 else if (unformat (input, "payload_length %d", &payload_length_val))
5953 else if (unformat (input, "hop_limit %d", &hop_limit_val))
5959 if (version + traffic_class + flow_label + src + dst + proto +
5960 payload_length + hop_limit == 0)
5964 * Aligned because we use the real comparison functions
5966 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
5968 ip = (ip6_header_t *) match;
5971 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
5974 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
5977 ip->protocol = proto_val;
5979 ip_version_traffic_class_and_flow_label = 0;
5982 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
5985 ip_version_traffic_class_and_flow_label |=
5986 (traffic_class_val & 0xFF) << 20;
5989 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
5991 ip->ip_version_traffic_class_and_flow_label =
5992 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
5995 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
5998 ip->hop_limit = hop_limit_val;
6005 unformat_l3_match (unformat_input_t * input, va_list * args)
6007 u8 **matchp = va_arg (*args, u8 **);
6009 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6011 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
6013 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
6022 unformat_vlan_tag (unformat_input_t * input, va_list * args)
6024 u8 *tagp = va_arg (*args, u8 *);
6027 if (unformat (input, "%d", &tag))
6029 tagp[0] = (tag >> 8) & 0x0F;
6030 tagp[1] = tag & 0xFF;
6038 unformat_l2_match (unformat_input_t * input, va_list * args)
6040 u8 **matchp = va_arg (*args, u8 **);
6060 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6062 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
6065 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
6067 else if (unformat (input, "proto %U",
6068 unformat_ethernet_type_host_byte_order, &proto_val))
6070 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
6072 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
6074 else if (unformat (input, "ignore-tag1"))
6076 else if (unformat (input, "ignore-tag2"))
6078 else if (unformat (input, "cos1 %d", &cos1_val))
6080 else if (unformat (input, "cos2 %d", &cos2_val))
6085 if ((src + dst + proto + tag1 + tag2 +
6086 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6089 if (tag1 || ignore_tag1 || cos1)
6091 if (tag2 || ignore_tag2 || cos2)
6094 vec_validate_aligned (match, len - 1, sizeof (u32x4));
6097 clib_memcpy (match, dst_val, 6);
6100 clib_memcpy (match + 6, src_val, 6);
6104 /* inner vlan tag */
6105 match[19] = tag2_val[1];
6106 match[18] = tag2_val[0];
6108 match[18] |= (cos2_val & 0x7) << 5;
6111 match[21] = proto_val & 0xff;
6112 match[20] = proto_val >> 8;
6116 match[15] = tag1_val[1];
6117 match[14] = tag1_val[0];
6120 match[14] |= (cos1_val & 0x7) << 5;
6126 match[15] = tag1_val[1];
6127 match[14] = tag1_val[0];
6130 match[17] = proto_val & 0xff;
6131 match[16] = proto_val >> 8;
6134 match[14] |= (cos1_val & 0x7) << 5;
6140 match[18] |= (cos2_val & 0x7) << 5;
6142 match[14] |= (cos1_val & 0x7) << 5;
6145 match[13] = proto_val & 0xff;
6146 match[12] = proto_val >> 8;
6154 unformat_qos_source (unformat_input_t * input, va_list * args)
6156 int *qs = va_arg (*args, int *);
6158 if (unformat (input, "ip"))
6159 *qs = QOS_SOURCE_IP;
6160 else if (unformat (input, "mpls"))
6161 *qs = QOS_SOURCE_MPLS;
6162 else if (unformat (input, "ext"))
6163 *qs = QOS_SOURCE_EXT;
6164 else if (unformat (input, "vlan"))
6165 *qs = QOS_SOURCE_VLAN;
6174 api_unformat_classify_match (unformat_input_t * input, va_list * args)
6176 u8 **matchp = va_arg (*args, u8 **);
6177 u32 skip_n_vectors = va_arg (*args, u32);
6178 u32 match_n_vectors = va_arg (*args, u32);
6185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6187 if (unformat (input, "hex %U", unformat_hex_string, &match))
6189 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
6191 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
6193 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
6207 if (match || l2 || l3 || l4)
6211 /* "Win a free Ethernet header in every packet" */
6213 vec_validate_aligned (l2, 13, sizeof (u32x4));
6217 vec_append_aligned (match, l3, sizeof (u32x4));
6222 vec_append_aligned (match, l4, sizeof (u32x4));
6227 /* Make sure the vector is big enough even if key is all 0's */
6228 vec_validate_aligned
6229 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
6232 /* Set size, include skipped vectors */
6233 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
6244 api_get_node_index (vat_main_t * vam)
6246 unformat_input_t *i = vam->input;
6247 vl_api_get_node_index_t *mp;
6251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6253 if (unformat (i, "node %s", &name))
6260 errmsg ("node name required");
6263 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
6265 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6269 M (GET_NODE_INDEX, mp);
6270 clib_memcpy (mp->node_name, name, vec_len (name));
6279 api_get_next_index (vat_main_t * vam)
6281 unformat_input_t *i = vam->input;
6282 vl_api_get_next_index_t *mp;
6283 u8 *node_name = 0, *next_node_name = 0;
6286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6288 if (unformat (i, "node-name %s", &node_name))
6290 else if (unformat (i, "next-node-name %s", &next_node_name))
6296 errmsg ("node name required");
6299 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
6301 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6305 if (next_node_name == 0)
6307 errmsg ("next node name required");
6310 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
6312 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
6316 M (GET_NEXT_INDEX, mp);
6317 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
6318 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
6319 vec_free (node_name);
6320 vec_free (next_node_name);
6328 api_add_node_next (vat_main_t * vam)
6330 unformat_input_t *i = vam->input;
6331 vl_api_add_node_next_t *mp;
6336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6338 if (unformat (i, "node %s", &name))
6340 else if (unformat (i, "next %s", &next))
6347 errmsg ("node name required");
6350 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
6352 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
6357 errmsg ("next node required");
6360 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
6362 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
6366 M (ADD_NODE_NEXT, mp);
6367 clib_memcpy (mp->node_name, name, vec_len (name));
6368 clib_memcpy (mp->next_name, next, vec_len (next));
6377 static void vl_api_sw_interface_virtio_pci_details_t_handler
6378 (vl_api_sw_interface_virtio_pci_details_t * mp)
6380 vat_main_t *vam = &vat_main;
6395 addr.domain = ntohs (mp->pci_addr.domain);
6396 addr.bus = mp->pci_addr.bus;
6397 addr.slot = mp->pci_addr.slot;
6398 addr.function = mp->pci_addr.function;
6400 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
6401 addr.slot, addr.function);
6404 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
6405 pci_addr, ntohl (mp->sw_if_index),
6406 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
6407 format_ethernet_address, mp->mac_addr,
6408 clib_net_to_host_u64 (mp->features));
6409 vec_free (pci_addr);
6412 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
6413 (vl_api_sw_interface_virtio_pci_details_t * mp)
6415 vat_main_t *vam = &vat_main;
6416 vat_json_node_t *node = NULL;
6417 vlib_pci_addr_t pci_addr;
6419 if (VAT_JSON_ARRAY != vam->json_tree.type)
6421 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6422 vat_json_init_array (&vam->json_tree);
6424 node = vat_json_array_add (&vam->json_tree);
6426 pci_addr.domain = ntohs (mp->pci_addr.domain);
6427 pci_addr.bus = mp->pci_addr.bus;
6428 pci_addr.slot = mp->pci_addr.slot;
6429 pci_addr.function = mp->pci_addr.function;
6431 vat_json_init_object (node);
6432 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
6433 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6434 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
6435 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
6436 vat_json_object_add_uint (node, "features",
6437 clib_net_to_host_u64 (mp->features));
6438 vat_json_object_add_string_copy (node, "mac_addr",
6439 format (0, "%U", format_ethernet_address,
6444 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
6446 vl_api_sw_interface_virtio_pci_dump_t *mp;
6447 vl_api_control_ping_t *mp_ping;
6451 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
6452 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
6453 "mac_addr", "features");
6455 /* Get list of tap interfaces */
6456 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
6459 /* Use a control ping for synchronization */
6460 MPING (CONTROL_PING, mp_ping);
6468 api_l2_fib_clear_table (vat_main_t * vam)
6470 // unformat_input_t * i = vam->input;
6471 vl_api_l2_fib_clear_table_t *mp;
6474 M (L2_FIB_CLEAR_TABLE, mp);
6482 api_l2_interface_efp_filter (vat_main_t * vam)
6484 unformat_input_t *i = vam->input;
6485 vl_api_l2_interface_efp_filter_t *mp;
6488 u8 sw_if_index_set = 0;
6491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6493 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6494 sw_if_index_set = 1;
6495 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6496 sw_if_index_set = 1;
6497 else if (unformat (i, "enable"))
6499 else if (unformat (i, "disable"))
6503 clib_warning ("parse error '%U'", format_unformat_error, i);
6508 if (sw_if_index_set == 0)
6510 errmsg ("missing sw_if_index");
6514 M (L2_INTERFACE_EFP_FILTER, mp);
6516 mp->sw_if_index = ntohl (sw_if_index);
6517 mp->enable_disable = enable;
6524 #define foreach_vtr_op \
6525 _("disable", L2_VTR_DISABLED) \
6526 _("push-1", L2_VTR_PUSH_1) \
6527 _("push-2", L2_VTR_PUSH_2) \
6528 _("pop-1", L2_VTR_POP_1) \
6529 _("pop-2", L2_VTR_POP_2) \
6530 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
6531 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
6532 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
6533 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
6536 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
6538 unformat_input_t *i = vam->input;
6539 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
6541 u8 sw_if_index_set = 0;
6549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6551 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6552 sw_if_index_set = 1;
6553 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6554 sw_if_index_set = 1;
6555 else if (unformat (i, "vtr_op %d", &vtr_op))
6557 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
6560 else if (unformat (i, "push_dot1q %d", &push_dot1q))
6562 else if (unformat (i, "tag1 %d", &tag1))
6564 else if (unformat (i, "tag2 %d", &tag2))
6568 clib_warning ("parse error '%U'", format_unformat_error, i);
6573 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
6575 errmsg ("missing vtr operation or sw_if_index");
6579 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
6580 mp->sw_if_index = ntohl (sw_if_index);
6581 mp->vtr_op = ntohl (vtr_op);
6582 mp->push_dot1q = ntohl (push_dot1q);
6583 mp->tag1 = ntohl (tag1);
6584 mp->tag2 = ntohl (tag2);
6592 api_show_version (vat_main_t *vam)
6594 vl_api_show_version_t *mp;
6597 M (SHOW_VERSION, mp);
6605 vl_api_l2_fib_table_details_t_handler (vl_api_l2_fib_table_details_t *mp)
6607 vat_main_t *vam = &vat_main;
6610 "%3" PRIu32 " %U %3" PRIu32 " %d %d %d",
6611 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
6612 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac, mp->bvi_mac);
6616 vl_api_l2_fib_table_details_t_handler_json (vl_api_l2_fib_table_details_t *mp)
6618 vat_main_t *vam = &vat_main;
6619 vat_json_node_t *node = NULL;
6621 if (VAT_JSON_ARRAY != vam->json_tree.type)
6623 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6624 vat_json_init_array (&vam->json_tree);
6626 node = vat_json_array_add (&vam->json_tree);
6628 vat_json_init_object (node);
6629 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
6630 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
6631 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6632 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
6633 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
6634 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
6638 api_l2_fib_table_dump (vat_main_t *vam)
6640 unformat_input_t *i = vam->input;
6641 vl_api_l2_fib_table_dump_t *mp;
6642 vl_api_control_ping_t *mp_ping;
6647 /* Parse args required to build the message */
6648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6650 if (unformat (i, "bd_id %d", &bd_id))
6658 errmsg ("missing bridge domain");
6662 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
6664 /* Get list of l2 fib entries */
6665 M (L2_FIB_TABLE_DUMP, mp);
6667 mp->bd_id = ntohl (bd_id);
6670 /* Use a control ping for synchronization */
6671 MPING (CONTROL_PING, mp_ping);
6679 api_interface_name_renumber (vat_main_t *vam)
6681 unformat_input_t *line_input = vam->input;
6682 vl_api_interface_name_renumber_t *mp;
6683 u32 sw_if_index = ~0;
6684 u32 new_show_dev_instance = ~0;
6687 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
6689 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
6692 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
6694 else if (unformat (line_input, "new_show_dev_instance %d",
6695 &new_show_dev_instance))
6701 if (sw_if_index == ~0)
6703 errmsg ("missing interface name or sw_if_index");
6707 if (new_show_dev_instance == ~0)
6709 errmsg ("missing new_show_dev_instance");
6713 M (INTERFACE_NAME_RENUMBER, mp);
6715 mp->sw_if_index = ntohl (sw_if_index);
6716 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
6724 api_want_l2_macs_events (vat_main_t *vam)
6726 unformat_input_t *line_input = vam->input;
6727 vl_api_want_l2_macs_events_t *mp;
6728 u8 enable_disable = 1;
6730 u32 max_macs_in_event = 0;
6731 u32 learn_limit = 0;
6734 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
6736 if (unformat (line_input, "learn-limit %d", &learn_limit))
6738 else if (unformat (line_input, "scan-delay %d", &scan_delay))
6740 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
6742 else if (unformat (line_input, "disable"))
6748 M (WANT_L2_MACS_EVENTS, mp);
6749 mp->enable_disable = enable_disable;
6750 mp->pid = htonl (getpid ());
6751 mp->learn_limit = htonl (learn_limit);
6752 mp->scan_delay = (u8) scan_delay;
6753 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
6760 api_ip_address_dump (vat_main_t *vam)
6762 unformat_input_t *i = vam->input;
6763 vl_api_ip_address_dump_t *mp;
6764 vl_api_control_ping_t *mp_ping;
6765 u32 sw_if_index = ~0;
6766 u8 sw_if_index_set = 0;
6771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6773 if (unformat (i, "sw_if_index %d", &sw_if_index))
6774 sw_if_index_set = 1;
6775 else if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6776 sw_if_index_set = 1;
6777 else if (unformat (i, "ipv4"))
6779 else if (unformat (i, "ipv6"))
6785 if (ipv4_set && ipv6_set)
6787 errmsg ("ipv4 and ipv6 flags cannot be both set");
6791 if ((!ipv4_set) && (!ipv6_set))
6793 errmsg ("no ipv4 nor ipv6 flag set");
6797 if (sw_if_index_set == 0)
6799 errmsg ("missing interface name or sw_if_index");
6803 vam->current_sw_if_index = sw_if_index;
6804 vam->is_ipv6 = ipv6_set;
6806 M (IP_ADDRESS_DUMP, mp);
6807 mp->sw_if_index = ntohl (sw_if_index);
6808 mp->is_ipv6 = ipv6_set;
6811 /* Use a control ping for synchronization */
6812 MPING (CONTROL_PING, mp_ping);
6820 api_ip_dump (vat_main_t * vam)
6822 vl_api_ip_dump_t *mp;
6823 vl_api_control_ping_t *mp_ping;
6824 unformat_input_t *in = vam->input;
6831 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
6833 if (unformat (in, "ipv4"))
6835 else if (unformat (in, "ipv6"))
6841 if (ipv4_set && ipv6_set)
6843 errmsg ("ipv4 and ipv6 flags cannot be both set");
6847 if ((!ipv4_set) && (!ipv6_set))
6849 errmsg ("no ipv4 nor ipv6 flag set");
6854 vam->is_ipv6 = is_ipv6;
6857 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
6859 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
6861 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
6864 mp->is_ipv6 = ipv6_set;
6867 /* Use a control ping for synchronization */
6868 MPING (CONTROL_PING, mp_ping);
6876 api_get_first_msg_id (vat_main_t * vam)
6878 vl_api_get_first_msg_id_t *mp;
6879 unformat_input_t *i = vam->input;
6884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6886 if (unformat (i, "client %s", &name))
6894 errmsg ("missing client name");
6899 if (vec_len (name) > 63)
6901 errmsg ("client name too long");
6905 M (GET_FIRST_MSG_ID, mp);
6906 clib_memcpy (mp->name, name, vec_len (name));
6913 api_get_node_graph (vat_main_t * vam)
6915 vl_api_get_node_graph_t *mp;
6918 M (GET_NODE_GRAPH, mp);
6922 /* Wait for the reply */
6928 format_fib_api_path_nh_proto (u8 * s, va_list * args)
6930 vl_api_fib_path_nh_proto_t proto =
6931 va_arg (*args, vl_api_fib_path_nh_proto_t);
6935 case FIB_API_PATH_NH_PROTO_IP4:
6936 s = format (s, "ip4");
6938 case FIB_API_PATH_NH_PROTO_IP6:
6939 s = format (s, "ip6");
6941 case FIB_API_PATH_NH_PROTO_MPLS:
6942 s = format (s, "mpls");
6944 case FIB_API_PATH_NH_PROTO_BIER:
6945 s = format (s, "bier");
6947 case FIB_API_PATH_NH_PROTO_ETHERNET:
6948 s = format (s, "ethernet");
6956 format_vl_api_ip_address_union (u8 * s, va_list * args)
6958 vl_api_address_family_t af = va_arg (*args, int);
6959 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
6964 s = format (s, "%U", format_ip4_address, u->ip4);
6967 s = format (s, "%U", format_ip6_address, u->ip6);
6974 format_vl_api_fib_path_type (u8 * s, va_list * args)
6976 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
6980 case FIB_API_PATH_TYPE_NORMAL:
6981 s = format (s, "normal");
6983 case FIB_API_PATH_TYPE_LOCAL:
6984 s = format (s, "local");
6986 case FIB_API_PATH_TYPE_DROP:
6987 s = format (s, "drop");
6989 case FIB_API_PATH_TYPE_UDP_ENCAP:
6990 s = format (s, "udp-encap");
6992 case FIB_API_PATH_TYPE_BIER_IMP:
6993 s = format (s, "bier-imp");
6995 case FIB_API_PATH_TYPE_ICMP_UNREACH:
6996 s = format (s, "unreach");
6998 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
6999 s = format (s, "prohibit");
7001 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
7002 s = format (s, "src-lookup");
7004 case FIB_API_PATH_TYPE_DVR:
7005 s = format (s, "dvr");
7007 case FIB_API_PATH_TYPE_INTERFACE_RX:
7008 s = format (s, "interface-rx");
7010 case FIB_API_PATH_TYPE_CLASSIFY:
7011 s = format (s, "classify");
7019 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
7022 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
7023 ntohl (fp->weight), ntohl (fp->sw_if_index),
7024 format_vl_api_fib_path_type, fp->type,
7025 format_fib_api_path_nh_proto, fp->proto,
7026 format_vl_api_ip_address_union, &fp->nh.address);
7030 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
7031 vl_api_fib_path_t * fp)
7034 struct in6_addr ip6;
7036 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
7037 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
7038 vat_json_object_add_uint (node, "type", fp->type);
7039 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
7040 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
7042 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
7043 vat_json_object_add_ip4 (node, "next_hop", ip4);
7045 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
7047 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
7048 vat_json_object_add_ip6 (node, "next_hop", ip6);
7053 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
7055 vat_main_t *vam = &vat_main;
7056 int count = ntohl (mp->mt_tunnel.mt_n_paths);
7057 vl_api_fib_path_t *fp;
7060 print (vam->ofp, "sw_if_index %d via:",
7061 ntohl (mp->mt_tunnel.mt_sw_if_index));
7062 fp = mp->mt_tunnel.mt_paths;
7063 for (i = 0; i < count; i++)
7065 vl_api_fib_path_print (vam, fp);
7069 print (vam->ofp, "");
7072 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
7073 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
7076 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
7078 vat_main_t *vam = &vat_main;
7079 vat_json_node_t *node = NULL;
7080 int count = ntohl (mp->mt_tunnel.mt_n_paths);
7081 vl_api_fib_path_t *fp;
7084 if (VAT_JSON_ARRAY != vam->json_tree.type)
7086 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7087 vat_json_init_array (&vam->json_tree);
7089 node = vat_json_array_add (&vam->json_tree);
7091 vat_json_init_object (node);
7092 vat_json_object_add_uint (node, "sw_if_index",
7093 ntohl (mp->mt_tunnel.mt_sw_if_index));
7095 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
7097 fp = mp->mt_tunnel.mt_paths;
7098 for (i = 0; i < count; i++)
7100 vl_api_mpls_fib_path_json_print (node, fp);
7106 api_mpls_tunnel_dump (vat_main_t * vam)
7108 vl_api_mpls_tunnel_dump_t *mp;
7109 vl_api_control_ping_t *mp_ping;
7112 M (MPLS_TUNNEL_DUMP, mp);
7116 /* Use a control ping for synchronization */
7117 MPING (CONTROL_PING, mp_ping);
7124 #define vl_api_mpls_table_details_t_endian vl_noop_handler
7125 #define vl_api_mpls_table_details_t_print vl_noop_handler
7129 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
7131 vat_main_t *vam = &vat_main;
7133 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
7136 static void vl_api_mpls_table_details_t_handler_json
7137 (vl_api_mpls_table_details_t * mp)
7139 vat_main_t *vam = &vat_main;
7140 vat_json_node_t *node = NULL;
7142 if (VAT_JSON_ARRAY != vam->json_tree.type)
7144 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7145 vat_json_init_array (&vam->json_tree);
7147 node = vat_json_array_add (&vam->json_tree);
7149 vat_json_init_object (node);
7150 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
7154 api_mpls_table_dump (vat_main_t * vam)
7156 vl_api_mpls_table_dump_t *mp;
7157 vl_api_control_ping_t *mp_ping;
7160 M (MPLS_TABLE_DUMP, mp);
7163 /* Use a control ping for synchronization */
7164 MPING (CONTROL_PING, mp_ping);
7171 #define vl_api_mpls_route_details_t_endian vl_noop_handler
7172 #define vl_api_mpls_route_details_t_print vl_noop_handler
7175 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
7177 vat_main_t *vam = &vat_main;
7178 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
7179 vl_api_fib_path_t *fp;
7183 "table-id %d, label %u, ess_bit %u",
7184 ntohl (mp->mr_route.mr_table_id),
7185 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
7186 fp = mp->mr_route.mr_paths;
7187 for (i = 0; i < count; i++)
7189 vl_api_fib_path_print (vam, fp);
7194 static void vl_api_mpls_route_details_t_handler_json
7195 (vl_api_mpls_route_details_t * mp)
7197 vat_main_t *vam = &vat_main;
7198 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
7199 vat_json_node_t *node = NULL;
7200 vl_api_fib_path_t *fp;
7203 if (VAT_JSON_ARRAY != vam->json_tree.type)
7205 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7206 vat_json_init_array (&vam->json_tree);
7208 node = vat_json_array_add (&vam->json_tree);
7210 vat_json_init_object (node);
7211 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
7212 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
7213 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
7214 vat_json_object_add_uint (node, "path_count", count);
7215 fp = mp->mr_route.mr_paths;
7216 for (i = 0; i < count; i++)
7218 vl_api_mpls_fib_path_json_print (node, fp);
7224 api_mpls_route_dump (vat_main_t * vam)
7226 unformat_input_t *input = vam->input;
7227 vl_api_mpls_route_dump_t *mp;
7228 vl_api_control_ping_t *mp_ping;
7232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7234 if (unformat (input, "table_id %d", &table_id))
7241 errmsg ("missing table id");
7245 M (MPLS_ROUTE_DUMP, mp);
7247 mp->table.mt_table_id = ntohl (table_id);
7250 /* Use a control ping for synchronization */
7251 MPING (CONTROL_PING, mp_ping);
7258 #define vl_api_ip_table_details_t_endian vl_noop_handler
7259 #define vl_api_ip_table_details_t_print vl_noop_handler
7262 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
7264 vat_main_t *vam = &vat_main;
7267 "%s; table-id %d, prefix %U/%d",
7268 mp->table.name, ntohl (mp->table.table_id));
7272 static void vl_api_ip_table_details_t_handler_json
7273 (vl_api_ip_table_details_t * mp)
7275 vat_main_t *vam = &vat_main;
7276 vat_json_node_t *node = NULL;
7278 if (VAT_JSON_ARRAY != vam->json_tree.type)
7280 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7281 vat_json_init_array (&vam->json_tree);
7283 node = vat_json_array_add (&vam->json_tree);
7285 vat_json_init_object (node);
7286 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
7290 api_ip_table_dump (vat_main_t * vam)
7292 vl_api_ip_table_dump_t *mp;
7293 vl_api_control_ping_t *mp_ping;
7296 M (IP_TABLE_DUMP, mp);
7299 /* Use a control ping for synchronization */
7300 MPING (CONTROL_PING, mp_ping);
7308 api_ip_mtable_dump (vat_main_t * vam)
7310 vl_api_ip_mtable_dump_t *mp;
7311 vl_api_control_ping_t *mp_ping;
7314 M (IP_MTABLE_DUMP, mp);
7317 /* Use a control ping for synchronization */
7318 MPING (CONTROL_PING, mp_ping);
7326 api_ip_mroute_dump (vat_main_t * vam)
7328 unformat_input_t *input = vam->input;
7329 vl_api_control_ping_t *mp_ping;
7330 vl_api_ip_mroute_dump_t *mp;
7335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7337 if (unformat (input, "table_id %d", &table_id))
7339 else if (unformat (input, "ip6"))
7341 else if (unformat (input, "ip4"))
7348 errmsg ("missing table id");
7352 M (IP_MROUTE_DUMP, mp);
7353 mp->table.table_id = table_id;
7354 mp->table.is_ip6 = is_ip6;
7357 /* Use a control ping for synchronization */
7358 MPING (CONTROL_PING, mp_ping);
7365 #define vl_api_ip_route_details_t_endian vl_noop_handler
7366 #define vl_api_ip_route_details_t_print vl_noop_handler
7369 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
7371 vat_main_t *vam = &vat_main;
7372 u8 count = mp->route.n_paths;
7373 vl_api_fib_path_t *fp;
7377 "table-id %d, prefix %U/%d",
7378 ntohl (mp->route.table_id),
7379 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
7380 for (i = 0; i < count; i++)
7382 fp = &mp->route.paths[i];
7384 vl_api_fib_path_print (vam, fp);
7389 static void vl_api_ip_route_details_t_handler_json
7390 (vl_api_ip_route_details_t * mp)
7392 vat_main_t *vam = &vat_main;
7393 u8 count = mp->route.n_paths;
7394 vat_json_node_t *node = NULL;
7396 struct in6_addr ip6;
7397 vl_api_fib_path_t *fp;
7400 if (VAT_JSON_ARRAY != vam->json_tree.type)
7402 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7403 vat_json_init_array (&vam->json_tree);
7405 node = vat_json_array_add (&vam->json_tree);
7407 vat_json_init_object (node);
7408 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
7409 if (ADDRESS_IP6 == mp->route.prefix.address.af)
7411 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
7412 vat_json_object_add_ip6 (node, "prefix", ip6);
7416 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
7417 vat_json_object_add_ip4 (node, "prefix", ip4);
7419 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
7420 vat_json_object_add_uint (node, "path_count", count);
7421 for (i = 0; i < count; i++)
7423 fp = &mp->route.paths[i];
7424 vl_api_mpls_fib_path_json_print (node, fp);
7429 api_ip_route_dump (vat_main_t * vam)
7431 unformat_input_t *input = vam->input;
7432 vl_api_ip_route_dump_t *mp;
7433 vl_api_control_ping_t *mp_ping;
7439 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7441 if (unformat (input, "table_id %d", &table_id))
7443 else if (unformat (input, "ip6"))
7445 else if (unformat (input, "ip4"))
7452 errmsg ("missing table id");
7456 M (IP_ROUTE_DUMP, mp);
7458 mp->table.table_id = table_id;
7459 mp->table.is_ip6 = is_ip6;
7463 /* Use a control ping for synchronization */
7464 MPING (CONTROL_PING, mp_ping);
7472 api_sw_interface_span_enable_disable (vat_main_t * vam)
7474 unformat_input_t *i = vam->input;
7475 vl_api_sw_interface_span_enable_disable_t *mp;
7476 u32 src_sw_if_index = ~0;
7477 u32 dst_sw_if_index = ~0;
7482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7485 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
7487 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
7491 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
7493 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
7495 else if (unformat (i, "disable"))
7497 else if (unformat (i, "rx"))
7499 else if (unformat (i, "tx"))
7501 else if (unformat (i, "both"))
7503 else if (unformat (i, "l2"))
7509 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
7511 mp->sw_if_index_from = htonl (src_sw_if_index);
7512 mp->sw_if_index_to = htonl (dst_sw_if_index);
7522 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
7525 vat_main_t *vam = &vat_main;
7526 u8 *sw_if_from_name = 0;
7527 u8 *sw_if_to_name = 0;
7528 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
7529 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
7530 char *states[] = { "none", "rx", "tx", "both" };
7534 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
7536 if ((u32) p->value[0] == sw_if_index_from)
7538 sw_if_from_name = (u8 *)(p->key);
7542 if ((u32) p->value[0] == sw_if_index_to)
7544 sw_if_to_name = (u8 *)(p->key);
7545 if (sw_if_from_name)
7550 print (vam->ofp, "%20s => %20s (%s) %s",
7551 sw_if_from_name, sw_if_to_name, states[mp->state],
7552 mp->is_l2 ? "l2" : "device");
7556 vl_api_sw_interface_span_details_t_handler_json
7557 (vl_api_sw_interface_span_details_t * mp)
7559 vat_main_t *vam = &vat_main;
7560 vat_json_node_t *node = NULL;
7561 u8 *sw_if_from_name = 0;
7562 u8 *sw_if_to_name = 0;
7563 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
7564 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
7568 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
7570 if ((u32) p->value[0] == sw_if_index_from)
7572 sw_if_from_name = (u8 *)(p->key);
7576 if ((u32) p->value[0] == sw_if_index_to)
7578 sw_if_to_name = (u8 *)(p->key);
7579 if (sw_if_from_name)
7585 if (VAT_JSON_ARRAY != vam->json_tree.type)
7587 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7588 vat_json_init_array (&vam->json_tree);
7590 node = vat_json_array_add (&vam->json_tree);
7592 vat_json_init_object (node);
7593 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
7594 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
7595 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
7596 if (0 != sw_if_to_name)
7598 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
7600 vat_json_object_add_uint (node, "state", mp->state);
7601 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
7605 api_sw_interface_span_dump (vat_main_t * vam)
7607 unformat_input_t *input = vam->input;
7608 vl_api_sw_interface_span_dump_t *mp;
7609 vl_api_control_ping_t *mp_ping;
7613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7615 if (unformat (input, "l2"))
7621 M (SW_INTERFACE_SPAN_DUMP, mp);
7625 /* Use a control ping for synchronization */
7626 MPING (CONTROL_PING, mp_ping);
7634 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
7636 unformat_input_t *input = vam->input;
7637 vl_api_ip_source_and_port_range_check_add_del_t *mp;
7640 u16 *high_ports = 0;
7643 vl_api_prefix_t prefix;
7650 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7652 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
7654 else if (unformat (input, "vrf %d", &vrf_id))
7656 else if (unformat (input, "del"))
7658 else if (unformat (input, "port %d", &tmp))
7660 if (tmp == 0 || tmp > 65535)
7662 errmsg ("port %d out of range", tmp);
7666 this_hi = this_low + 1;
7667 vec_add1 (low_ports, this_low);
7668 vec_add1 (high_ports, this_hi);
7670 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
7672 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
7674 errmsg ("incorrect range parameters");
7678 /* Note: in debug CLI +1 is added to high before
7679 passing to real fn that does "the work"
7680 (ip_source_and_port_range_check_add_del).
7681 This fn is a wrapper around the binary API fn a
7682 control plane will call, which expects this increment
7683 to have occurred. Hence letting the binary API control
7684 plane fn do the increment for consistency between VAT
7685 and other control planes.
7688 vec_add1 (low_ports, this_low);
7689 vec_add1 (high_ports, this_hi);
7695 if (prefix_set == 0)
7697 errmsg ("<address>/<mask> not specified");
7703 errmsg ("VRF ID required, not specified");
7710 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
7714 if (vec_len (low_ports) == 0)
7716 errmsg ("At least one port or port range required");
7720 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
7722 mp->is_add = is_add;
7724 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
7726 mp->number_of_ranges = vec_len (low_ports);
7728 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
7729 vec_free (low_ports);
7731 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
7732 vec_free (high_ports);
7734 mp->vrf_id = ntohl (vrf_id);
7742 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
7744 unformat_input_t *input = vam->input;
7745 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
7746 u32 sw_if_index = ~0;
7748 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
7749 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
7753 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7755 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7757 else if (unformat (input, "sw_if_index %d", &sw_if_index))
7759 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
7761 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
7763 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
7765 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
7767 else if (unformat (input, "del"))
7773 if (sw_if_index == ~0)
7775 errmsg ("Interface required but not specified");
7781 errmsg ("VRF ID required but not specified");
7785 if (tcp_out_vrf_id == 0
7786 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
7789 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
7793 /* Construct the API message */
7794 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
7796 mp->sw_if_index = ntohl (sw_if_index);
7797 mp->is_add = is_add;
7798 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
7799 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
7800 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
7801 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
7806 /* Wait for a reply... */
7812 api_delete_subif (vat_main_t * vam)
7814 unformat_input_t *i = vam->input;
7815 vl_api_delete_subif_t *mp;
7816 u32 sw_if_index = ~0;
7819 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7821 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7823 if (unformat (i, "sw_if_index %d", &sw_if_index))
7829 if (sw_if_index == ~0)
7831 errmsg ("missing sw_if_index");
7835 /* Construct the API message */
7836 M (DELETE_SUBIF, mp);
7837 mp->sw_if_index = ntohl (sw_if_index);
7844 #define foreach_pbb_vtr_op \
7845 _("disable", L2_VTR_DISABLED) \
7846 _("pop", L2_VTR_POP_2) \
7847 _("push", L2_VTR_PUSH_2)
7850 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
7852 unformat_input_t *i = vam->input;
7853 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
7854 u32 sw_if_index = ~0, vtr_op = ~0;
7856 u8 dmac[6], smac[6];
7857 u8 dmac_set = 0, smac_set = 0;
7863 /* Shut up coverity */
7864 clib_memset (dmac, 0, sizeof (dmac));
7865 clib_memset (smac, 0, sizeof (smac));
7867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7869 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7871 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7873 else if (unformat (i, "vtr_op %d", &vtr_op))
7875 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
7878 else if (unformat (i, "translate_pbb_stag"))
7880 if (unformat (i, "%d", &tmp))
7882 vtr_op = L2_VTR_TRANSLATE_2_1;
7888 ("translate_pbb_stag operation requires outer tag definition");
7892 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
7894 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
7896 else if (unformat (i, "sid %d", &sid))
7898 else if (unformat (i, "vlanid %d", &tmp))
7902 clib_warning ("parse error '%U'", format_unformat_error, i);
7907 if ((sw_if_index == ~0) || (vtr_op == ~0))
7909 errmsg ("missing sw_if_index or vtr operation");
7912 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
7913 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
7916 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
7920 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
7921 mp->sw_if_index = ntohl (sw_if_index);
7922 mp->vtr_op = ntohl (vtr_op);
7923 mp->outer_tag = ntohs (outer_tag);
7924 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
7925 clib_memcpy (mp->b_smac, smac, sizeof (smac));
7926 mp->b_vlanid = ntohs (vlanid);
7927 mp->i_sid = ntohl (sid);
7935 api_sw_interface_tag_add_del (vat_main_t * vam)
7937 unformat_input_t *i = vam->input;
7938 vl_api_sw_interface_tag_add_del_t *mp;
7939 u32 sw_if_index = ~0;
7944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7946 if (unformat (i, "tag %s", &tag))
7948 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7952 else if (unformat (i, "del"))
7958 if (sw_if_index == ~0)
7960 errmsg ("missing interface name or sw_if_index");
7964 if (enable && (tag == 0))
7966 errmsg ("no tag specified");
7970 /* Construct the API message */
7971 M (SW_INTERFACE_TAG_ADD_DEL, mp);
7972 mp->sw_if_index = ntohl (sw_if_index);
7973 mp->is_add = enable;
7975 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
7984 api_sw_interface_add_del_mac_address (vat_main_t * vam)
7986 unformat_input_t *i = vam->input;
7987 vl_api_mac_address_t mac = { 0 };
7988 vl_api_sw_interface_add_del_mac_address_t *mp;
7989 u32 sw_if_index = ~0;
7994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7996 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7998 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8000 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
8002 else if (unformat (i, "del"))
8008 if (sw_if_index == ~0)
8010 errmsg ("missing interface name or sw_if_index");
8016 errmsg ("missing MAC address");
8020 /* Construct the API message */
8021 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
8022 mp->sw_if_index = ntohl (sw_if_index);
8023 mp->is_add = is_add;
8024 clib_memcpy (&mp->addr, &mac, sizeof (mac));
8031 static void vl_api_l2_xconnect_details_t_handler
8032 (vl_api_l2_xconnect_details_t * mp)
8034 vat_main_t *vam = &vat_main;
8036 print (vam->ofp, "%15d%15d",
8037 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
8040 static void vl_api_l2_xconnect_details_t_handler_json
8041 (vl_api_l2_xconnect_details_t * mp)
8043 vat_main_t *vam = &vat_main;
8044 vat_json_node_t *node = NULL;
8046 if (VAT_JSON_ARRAY != vam->json_tree.type)
8048 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8049 vat_json_init_array (&vam->json_tree);
8051 node = vat_json_array_add (&vam->json_tree);
8053 vat_json_init_object (node);
8054 vat_json_object_add_uint (node, "rx_sw_if_index",
8055 ntohl (mp->rx_sw_if_index));
8056 vat_json_object_add_uint (node, "tx_sw_if_index",
8057 ntohl (mp->tx_sw_if_index));
8061 api_l2_xconnect_dump (vat_main_t * vam)
8063 vl_api_l2_xconnect_dump_t *mp;
8064 vl_api_control_ping_t *mp_ping;
8067 if (!vam->json_output)
8069 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
8072 M (L2_XCONNECT_DUMP, mp);
8076 /* Use a control ping for synchronization */
8077 MPING (CONTROL_PING, mp_ping);
8085 api_hw_interface_set_mtu (vat_main_t * vam)
8087 unformat_input_t *i = vam->input;
8088 vl_api_hw_interface_set_mtu_t *mp;
8089 u32 sw_if_index = ~0;
8093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8095 if (unformat (i, "mtu %d", &mtu))
8097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8105 if (sw_if_index == ~0)
8107 errmsg ("missing interface name or sw_if_index");
8113 errmsg ("no mtu specified");
8117 /* Construct the API message */
8118 M (HW_INTERFACE_SET_MTU, mp);
8119 mp->sw_if_index = ntohl (sw_if_index);
8120 mp->mtu = ntohs ((u16) mtu);
8128 api_tcp_configure_src_addresses (vat_main_t * vam)
8130 vl_api_tcp_configure_src_addresses_t *mp;
8131 unformat_input_t *i = vam->input;
8132 vl_api_address_t first, last;
8137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8139 if (unformat (i, "%U - %U",
8140 unformat_vl_api_address, &first,
8141 unformat_vl_api_address, &last))
8145 errmsg ("one range per message (range already set)");
8150 else if (unformat (i, "vrf %d", &vrf_id))
8158 errmsg ("address range not set");
8162 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
8164 mp->vrf_id = ntohl (vrf_id);
8165 clib_memcpy (&mp->first_address, &first, sizeof (first));
8166 clib_memcpy (&mp->last_address, &last, sizeof (last));
8173 static void vl_api_app_namespace_add_del_reply_t_handler
8174 (vl_api_app_namespace_add_del_reply_t * mp)
8176 vat_main_t *vam = &vat_main;
8177 i32 retval = ntohl (mp->retval);
8178 if (vam->async_mode)
8180 vam->async_errors += (retval < 0);
8184 vam->retval = retval;
8186 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
8187 vam->result_ready = 1;
8191 static void vl_api_app_namespace_add_del_reply_t_handler_json
8192 (vl_api_app_namespace_add_del_reply_t * mp)
8194 vat_main_t *vam = &vat_main;
8195 vat_json_node_t node;
8197 vat_json_init_object (&node);
8198 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
8199 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
8201 vat_json_print (vam->ofp, &node);
8202 vat_json_free (&node);
8204 vam->retval = ntohl (mp->retval);
8205 vam->result_ready = 1;
8209 api_app_namespace_add_del (vat_main_t * vam)
8211 vl_api_app_namespace_add_del_t *mp;
8212 unformat_input_t *i = vam->input;
8213 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
8214 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
8218 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8220 if (unformat (i, "id %_%v%_", &ns_id))
8222 else if (unformat (i, "secret %lu", &secret))
8224 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8225 sw_if_index_set = 1;
8226 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
8228 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
8233 if (!ns_id || !secret_set || !sw_if_index_set)
8235 errmsg ("namespace id, secret and sw_if_index must be set");
8238 if (vec_len (ns_id) > 64)
8240 errmsg ("namespace id too long");
8243 M (APP_NAMESPACE_ADD_DEL, mp);
8245 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
8246 mp->secret = clib_host_to_net_u64 (secret);
8247 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
8248 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
8249 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
8257 api_sock_init_shm (vat_main_t * vam)
8259 #if VPP_API_TEST_BUILTIN == 0
8260 unformat_input_t *i = vam->input;
8261 vl_api_shm_elem_config_t *config = 0;
8262 u64 size = 64 << 20;
8265 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8267 if (unformat (i, "size %U", unformat_memory_size, &size))
8274 * Canned custom ring allocator config.
8275 * Should probably parse all of this
8277 vec_validate (config, 6);
8278 config[0].type = VL_API_VLIB_RING;
8279 config[0].size = 256;
8280 config[0].count = 32;
8282 config[1].type = VL_API_VLIB_RING;
8283 config[1].size = 1024;
8284 config[1].count = 16;
8286 config[2].type = VL_API_VLIB_RING;
8287 config[2].size = 4096;
8288 config[2].count = 2;
8290 config[3].type = VL_API_CLIENT_RING;
8291 config[3].size = 256;
8292 config[3].count = 32;
8294 config[4].type = VL_API_CLIENT_RING;
8295 config[4].size = 1024;
8296 config[4].count = 16;
8298 config[5].type = VL_API_CLIENT_RING;
8299 config[5].size = 4096;
8300 config[5].count = 2;
8302 config[6].type = VL_API_QUEUE;
8303 config[6].count = 128;
8304 config[6].size = sizeof (uword);
8306 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
8308 vam->client_index_invalid = 1;
8316 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
8318 vat_main_t *vam = &vat_main;
8319 fib_prefix_t lcl, rmt;
8321 ip_prefix_decode (&mp->lcl, &lcl);
8322 ip_prefix_decode (&mp->rmt, &rmt);
8324 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
8327 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
8328 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
8329 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
8330 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
8331 &rmt.fp_addr.ip4, rmt.fp_len,
8332 clib_net_to_host_u16 (mp->rmt_port),
8333 clib_net_to_host_u32 (mp->action_index), mp->tag);
8338 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
8339 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
8340 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
8341 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
8342 &rmt.fp_addr.ip6, rmt.fp_len,
8343 clib_net_to_host_u16 (mp->rmt_port),
8344 clib_net_to_host_u32 (mp->action_index), mp->tag);
8349 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
8352 vat_main_t *vam = &vat_main;
8353 vat_json_node_t *node = NULL;
8354 struct in6_addr ip6;
8357 fib_prefix_t lcl, rmt;
8359 ip_prefix_decode (&mp->lcl, &lcl);
8360 ip_prefix_decode (&mp->rmt, &rmt);
8362 if (VAT_JSON_ARRAY != vam->json_tree.type)
8364 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8365 vat_json_init_array (&vam->json_tree);
8367 node = vat_json_array_add (&vam->json_tree);
8368 vat_json_init_object (node);
8370 vat_json_object_add_uint (node, "appns_index",
8371 clib_net_to_host_u32 (mp->appns_index));
8372 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
8373 vat_json_object_add_uint (node, "scope", mp->scope);
8374 vat_json_object_add_uint (node, "action_index",
8375 clib_net_to_host_u32 (mp->action_index));
8376 vat_json_object_add_uint (node, "lcl_port",
8377 clib_net_to_host_u16 (mp->lcl_port));
8378 vat_json_object_add_uint (node, "rmt_port",
8379 clib_net_to_host_u16 (mp->rmt_port));
8380 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
8381 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
8382 vat_json_object_add_string_copy (node, "tag", mp->tag);
8383 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
8385 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
8386 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
8387 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
8388 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
8392 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
8393 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
8394 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
8395 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
8400 api_session_rule_add_del (vat_main_t * vam)
8402 vl_api_session_rule_add_del_t *mp;
8403 unformat_input_t *i = vam->input;
8404 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
8405 u32 appns_index = 0, scope = 0;
8406 ip4_address_t lcl_ip4, rmt_ip4;
8407 ip6_address_t lcl_ip6, rmt_ip6;
8408 u8 is_ip4 = 1, conn_set = 0;
8409 u8 is_add = 1, *tag = 0;
8411 fib_prefix_t lcl, rmt;
8413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8415 if (unformat (i, "del"))
8417 else if (unformat (i, "add"))
8419 else if (unformat (i, "proto tcp"))
8421 else if (unformat (i, "proto udp"))
8423 else if (unformat (i, "appns %d", &appns_index))
8425 else if (unformat (i, "scope %d", &scope))
8427 else if (unformat (i, "tag %_%v%_", &tag))
8431 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
8432 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
8440 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
8441 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
8447 else if (unformat (i, "action %d", &action))
8452 if (proto == ~0 || !conn_set || action == ~0)
8454 errmsg ("transport proto, connection and action must be set");
8460 errmsg ("scope should be 0-3");
8464 M (SESSION_RULE_ADD_DEL, mp);
8466 clib_memset (&lcl, 0, sizeof (lcl));
8467 clib_memset (&rmt, 0, sizeof (rmt));
8470 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
8471 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
8472 lcl.fp_len = lcl_plen;
8473 rmt.fp_len = rmt_plen;
8477 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
8478 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
8479 lcl.fp_len = lcl_plen;
8480 rmt.fp_len = rmt_plen;
8484 ip_prefix_encode (&lcl, &mp->lcl);
8485 ip_prefix_encode (&rmt, &mp->rmt);
8486 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
8487 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
8488 mp->transport_proto =
8489 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
8490 mp->action_index = clib_host_to_net_u32 (action);
8491 mp->appns_index = clib_host_to_net_u32 (appns_index);
8493 mp->is_add = is_add;
8496 clib_memcpy (mp->tag, tag, vec_len (tag));
8506 api_session_rules_dump (vat_main_t * vam)
8508 vl_api_session_rules_dump_t *mp;
8509 vl_api_control_ping_t *mp_ping;
8512 if (!vam->json_output)
8514 print (vam->ofp, "%=20s", "Session Rules");
8517 M (SESSION_RULES_DUMP, mp);
8521 /* Use a control ping for synchronization */
8522 MPING (CONTROL_PING, mp_ping);
8525 /* Wait for a reply... */
8531 api_ip_container_proxy_add_del (vat_main_t * vam)
8533 vl_api_ip_container_proxy_add_del_t *mp;
8534 unformat_input_t *i = vam->input;
8535 u32 sw_if_index = ~0;
8536 vl_api_prefix_t pfx = { };
8540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8542 if (unformat (i, "del"))
8544 else if (unformat (i, "add"))
8546 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8548 else if (unformat (i, "sw_if_index %u", &sw_if_index))
8553 if (sw_if_index == ~0 || pfx.len == 0)
8555 errmsg ("address and sw_if_index must be set");
8559 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
8561 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
8562 mp->is_add = is_add;
8563 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
8571 q_or_quit (vat_main_t * vam)
8573 #if VPP_API_TEST_BUILTIN == 0
8574 longjmp (vam->jump_buf, 1);
8576 return 0; /* not so much */
8580 q (vat_main_t * vam)
8582 return q_or_quit (vam);
8586 quit (vat_main_t * vam)
8588 return q_or_quit (vam);
8592 comment (vat_main_t * vam)
8598 elog_save (vat_main_t * vam)
8600 #if VPP_API_TEST_BUILTIN == 0
8601 elog_main_t *em = &vam->elog_main;
8602 unformat_input_t *i = vam->input;
8603 char *file, *chroot_file;
8604 clib_error_t *error;
8606 if (!unformat (i, "%s", &file))
8608 errmsg ("expected file name, got `%U'", format_unformat_error, i);
8612 /* It's fairly hard to get "../oopsie" through unformat; just in case */
8613 if (strstr (file, "..") || index (file, '/'))
8615 errmsg ("illegal characters in filename '%s'", file);
8619 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
8623 errmsg ("Saving %wd of %wd events to %s",
8624 elog_n_events_in_buffer (em),
8625 elog_buffer_capacity (em), chroot_file);
8627 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
8628 vec_free (chroot_file);
8631 clib_error_report (error);
8633 errmsg ("Use the vpp event loger...");
8640 elog_setup (vat_main_t * vam)
8642 #if VPP_API_TEST_BUILTIN == 0
8643 elog_main_t *em = &vam->elog_main;
8644 unformat_input_t *i = vam->input;
8645 u32 nevents = 128 << 10;
8647 (void) unformat (i, "nevents %d", &nevents);
8649 elog_init (em, nevents);
8650 vl_api_set_elog_main (em);
8651 vl_api_set_elog_trace_api_messages (1);
8652 errmsg ("Event logger initialized with %u events", nevents);
8654 errmsg ("Use the vpp event loger...");
8660 elog_enable (vat_main_t * vam)
8662 #if VPP_API_TEST_BUILTIN == 0
8663 elog_main_t *em = &vam->elog_main;
8665 elog_enable_disable (em, 1 /* enable */ );
8666 vl_api_set_elog_trace_api_messages (1);
8667 errmsg ("Event logger enabled...");
8669 errmsg ("Use the vpp event loger...");
8675 elog_disable (vat_main_t * vam)
8677 #if VPP_API_TEST_BUILTIN == 0
8678 elog_main_t *em = &vam->elog_main;
8680 elog_enable_disable (em, 0 /* enable */ );
8681 vl_api_set_elog_trace_api_messages (1);
8682 errmsg ("Event logger disabled...");
8684 errmsg ("Use the vpp event loger...");
8690 statseg (vat_main_t * vam)
8692 ssvm_private_t *ssvmp = &vam->stat_segment;
8693 ssvm_shared_header_t *shared_header = ssvmp->sh;
8694 vlib_counter_t **counters;
8695 u64 thread0_index1_packets;
8696 u64 thread0_index1_bytes;
8697 f64 vector_rate, input_rate;
8700 uword *counter_vector_by_name;
8701 if (vam->stat_segment_lockp == 0)
8703 errmsg ("Stat segment not mapped...");
8707 /* look up "/if/rx for sw_if_index 1 as a test */
8709 clib_spinlock_lock (vam->stat_segment_lockp);
8711 counter_vector_by_name = (uword *) shared_header->opaque[1];
8713 p = hash_get_mem (counter_vector_by_name, "/if/rx");
8716 clib_spinlock_unlock (vam->stat_segment_lockp);
8717 errmsg ("/if/tx not found?");
8721 /* Fish per-thread vector of combined counters from shared memory */
8722 counters = (vlib_counter_t **) p[0];
8724 if (vec_len (counters[0]) < 2)
8726 clib_spinlock_unlock (vam->stat_segment_lockp);
8727 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
8731 /* Read thread 0 sw_if_index 1 counter */
8732 thread0_index1_packets = counters[0][1].packets;
8733 thread0_index1_bytes = counters[0][1].bytes;
8735 p = hash_get_mem (counter_vector_by_name, "vector_rate");
8738 clib_spinlock_unlock (vam->stat_segment_lockp);
8739 errmsg ("vector_rate not found?");
8743 vector_rate = *(f64 *) (p[0]);
8744 p = hash_get_mem (counter_vector_by_name, "input_rate");
8747 clib_spinlock_unlock (vam->stat_segment_lockp);
8748 errmsg ("input_rate not found?");
8751 input_rate = *(f64 *) (p[0]);
8753 clib_spinlock_unlock (vam->stat_segment_lockp);
8755 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
8756 vector_rate, input_rate);
8757 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
8758 thread0_index1_packets, thread0_index1_bytes);
8764 cmd_cmp (void *a1, void *a2)
8769 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
8773 help (vat_main_t * vam)
8778 unformat_input_t *i = vam->input;
8781 if (unformat (i, "%s", &name))
8787 hs = hash_get_mem (vam->help_by_name, name);
8789 print (vam->ofp, "usage: %s %s", name, hs[0]);
8791 print (vam->ofp, "No such msg / command '%s'", name);
8796 print (vam->ofp, "Help is available for the following:");
8799 hash_foreach_pair (p, vam->function_by_name,
8801 vec_add1 (cmds, (u8 *)(p->key));
8805 vec_sort_with_function (cmds, cmd_cmp);
8807 for (j = 0; j < vec_len (cmds); j++)
8808 print (vam->ofp, "%s", cmds[j]);
8815 set (vat_main_t * vam)
8817 u8 *name = 0, *value = 0;
8818 unformat_input_t *i = vam->input;
8820 if (unformat (i, "%s", &name))
8822 /* The input buffer is a vector, not a string. */
8823 value = vec_dup (i->buffer);
8824 vec_delete (value, i->index, 0);
8825 /* Almost certainly has a trailing newline */
8826 if (value[vec_len (value) - 1] == '\n')
8827 value[vec_len (value) - 1] = 0;
8828 /* Make sure it's a proper string, one way or the other */
8829 vec_add1 (value, 0);
8830 (void) clib_macro_set_value (&vam->macro_main,
8831 (char *) name, (char *) value);
8834 errmsg ("usage: set <name> <value>");
8842 unset (vat_main_t * vam)
8846 if (unformat (vam->input, "%s", &name))
8847 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
8848 errmsg ("unset: %s wasn't set", name);
8861 macro_sort_cmp (void *a1, void *a2)
8863 macro_sort_t *s1 = a1;
8864 macro_sort_t *s2 = a2;
8866 return strcmp ((char *) (s1->name), (char *) (s2->name));
8870 dump_macro_table (vat_main_t * vam)
8872 macro_sort_t *sort_me = 0, *sm;
8877 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
8879 vec_add2 (sort_me, sm, 1);
8880 sm->name = (u8 *)(p->key);
8881 sm->value = (u8 *) (p->value[0]);
8885 vec_sort_with_function (sort_me, macro_sort_cmp);
8887 if (vec_len (sort_me))
8888 print (vam->ofp, "%-15s%s", "Name", "Value");
8890 print (vam->ofp, "The macro table is empty...");
8892 for (i = 0; i < vec_len (sort_me); i++)
8893 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
8898 dump_node_table (vat_main_t * vam)
8901 vlib_node_t *node, *next_node;
8903 if (vec_len (vam->graph_nodes) == 0)
8905 print (vam->ofp, "Node table empty, issue get_node_graph...");
8909 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
8911 node = vam->graph_nodes[0][i];
8912 print (vam->ofp, "[%d] %s", i, node->name);
8913 for (j = 0; j < vec_len (node->next_nodes); j++)
8915 if (node->next_nodes[j] != ~0)
8917 next_node = vam->graph_nodes[0][node->next_nodes[j]];
8918 print (vam->ofp, " [%d] %s", j, next_node->name);
8926 value_sort_cmp (void *a1, void *a2)
8928 name_sort_t *n1 = a1;
8929 name_sort_t *n2 = a2;
8931 if (n1->value < n2->value)
8933 if (n1->value > n2->value)
8940 dump_msg_api_table (vat_main_t * vam)
8942 api_main_t *am = vlibapi_get_main ();
8943 name_sort_t *nses = 0, *ns;
8948 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
8950 vec_add2 (nses, ns, 1);
8951 ns->name = (u8 *)(hp->key);
8952 ns->value = (u32) hp->value[0];
8956 vec_sort_with_function (nses, value_sort_cmp);
8958 for (i = 0; i < vec_len (nses); i++)
8959 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
8965 get_msg_id (vat_main_t * vam)
8970 if (unformat (vam->input, "%s", &name_and_crc))
8972 message_index = vl_msg_api_get_msg_index (name_and_crc);
8973 if (message_index == ~0)
8975 print (vam->ofp, " '%s' not found", name_and_crc);
8978 print (vam->ofp, " '%s' has message index %d",
8979 name_and_crc, message_index);
8982 errmsg ("name_and_crc required...");
8987 search_node_table (vat_main_t * vam)
8989 unformat_input_t *line_input = vam->input;
8992 vlib_node_t *node, *next_node;
8995 if (vam->graph_node_index_by_name == 0)
8997 print (vam->ofp, "Node table empty, issue get_node_graph...");
9001 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9003 if (unformat (line_input, "%s", &node_to_find))
9005 vec_add1 (node_to_find, 0);
9006 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
9009 print (vam->ofp, "%s not found...", node_to_find);
9012 node = vam->graph_nodes[0][p[0]];
9013 print (vam->ofp, "[%d] %s", p[0], node->name);
9014 for (j = 0; j < vec_len (node->next_nodes); j++)
9016 if (node->next_nodes[j] != ~0)
9018 next_node = vam->graph_nodes[0][node->next_nodes[j]];
9019 print (vam->ofp, " [%d] %s", j, next_node->name);
9026 clib_warning ("parse error '%U'", format_unformat_error,
9032 vec_free (node_to_find);
9041 script (vat_main_t * vam)
9043 #if (VPP_API_TEST_BUILTIN==0)
9045 char *save_current_file;
9046 unformat_input_t save_input;
9047 jmp_buf save_jump_buf;
9048 u32 save_line_number;
9050 FILE *new_fp, *save_ifp;
9052 if (unformat (vam->input, "%s", &s))
9054 new_fp = fopen ((char *) s, "r");
9057 errmsg ("Couldn't open script file %s", s);
9064 errmsg ("Missing script name");
9068 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
9069 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
9070 save_ifp = vam->ifp;
9071 save_line_number = vam->input_line_number;
9072 save_current_file = (char *) vam->current_file;
9074 vam->input_line_number = 0;
9076 vam->current_file = s;
9079 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
9080 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
9081 vam->ifp = save_ifp;
9082 vam->input_line_number = save_line_number;
9083 vam->current_file = (u8 *) save_current_file;
9088 clib_warning ("use the exec command...");
9094 echo (vat_main_t * vam)
9096 print (vam->ofp, "%v", vam->input->buffer);
9100 /* List of API message constructors, CLI names map to api_xxx */
9101 #define foreach_vpe_api_msg \
9102 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
9103 _(sw_interface_dump,"") \
9104 _(sw_interface_set_flags, \
9105 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
9106 _(sw_interface_add_del_address, \
9107 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
9108 _(sw_interface_set_rx_mode, \
9109 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
9110 _(sw_interface_set_rx_placement, \
9111 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
9112 _(sw_interface_rx_placement_dump, \
9113 "[<intfc> | sw_if_index <id>]") \
9114 _(sw_interface_set_table, \
9115 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
9116 _(sw_interface_set_mpls_enable, \
9117 "<intfc> | sw_if_index [disable | dis]") \
9118 _(sw_interface_set_vpath, \
9119 "<intfc> | sw_if_index <id> enable | disable") \
9120 _(sw_interface_set_l2_xconnect, \
9121 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
9122 "enable | disable") \
9123 _(sw_interface_set_l2_bridge, \
9124 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
9125 "[shg <split-horizon-group>] [bvi]\n" \
9126 "enable | disable") \
9127 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
9128 _(bridge_domain_add_del, \
9129 "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") \
9130 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
9132 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
9133 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
9134 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
9136 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
9138 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
9139 _(virtio_pci_create_v2, \
9140 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled [gro-coalesce] | csum-offload-enabled] [packed] [in-order] [buffering]") \
9141 _(virtio_pci_delete, \
9142 "<vpp-if-name> | sw_if_index <id>") \
9143 _(sw_interface_virtio_pci_dump, "") \
9144 _(ip_table_add_del, \
9145 "table <n> [ipv6] [add | del]\n") \
9146 _(ip_route_add_del, \
9147 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
9148 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
9149 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
9150 "[multipath] [count <n>] [del]") \
9151 _(ip_mroute_add_del, \
9152 "<src> <grp>/<mask> [table-id <n>]\n" \
9153 "[<intfc> | sw_if_index <id>] [local] [del]") \
9154 _(mpls_table_add_del, \
9155 "table <n> [add | del]\n") \
9156 _(mpls_route_add_del, \
9157 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
9158 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
9159 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
9160 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
9161 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
9162 "[count <n>] [del]") \
9163 _(mpls_ip_bind_unbind, \
9164 "<label> <addr/len>") \
9165 _(mpls_tunnel_add_del, \
9166 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
9167 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
9168 "[l2-only] [out-label <n>]") \
9169 _(sw_interface_set_unnumbered, \
9170 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
9171 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
9172 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
9173 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
9174 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
9175 "[outer_vlan_id_any][inner_vlan_id_any]") \
9176 _(ip_table_replace_begin, "table <n> [ipv6]") \
9177 _(ip_table_flush, "table <n> [ipv6]") \
9178 _(ip_table_replace_end, "table <n> [ipv6]") \
9179 _(set_ip_flow_hash, \
9180 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
9181 _(sw_interface_ip6_enable_disable, \
9182 "<intfc> | sw_if_index <id> enable | disable") \
9183 _(l2_patch_add_del, \
9184 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
9185 "enable | disable") \
9186 _(get_node_index, "node <node-name") \
9187 _(add_node_next, "node <node-name> next <next-node-name>") \
9188 _(l2_fib_clear_table, "") \
9189 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
9190 _(l2_interface_vlan_tag_rewrite, \
9191 "<intfc> | sw_if_index <nn> \n" \
9192 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
9193 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
9194 _(show_version, "") \
9195 _(show_threads, "") \
9196 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
9197 _(interface_name_renumber, \
9198 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
9199 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
9200 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
9201 _(ip_dump, "ipv4 | ipv6") \
9202 _(delete_loopback,"sw_if_index <nn>") \
9203 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
9204 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
9205 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
9206 _(want_interface_events, "enable|disable") \
9207 _(get_first_msg_id, "client <name>") \
9208 _(get_node_graph, " ") \
9209 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
9210 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
9211 _(ioam_disable, "") \
9212 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
9213 _(mpls_table_dump, "") \
9214 _(mpls_route_dump, "table-id <ID>") \
9215 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
9216 _(sw_interface_span_dump, "[l2]") \
9217 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
9218 _(ip_source_and_port_range_check_add_del, \
9219 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
9220 _(ip_source_and_port_range_check_interface_add_del, \
9221 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
9222 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
9223 _(delete_subif,"<intfc> | sw_if_index <nn>") \
9224 _(l2_interface_pbb_tag_rewrite, \
9225 "<intfc> | sw_if_index <nn> \n" \
9226 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
9227 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
9228 _(ip_table_dump, "") \
9229 _(ip_route_dump, "table-id [ip4|ip6]") \
9230 _(ip_mtable_dump, "") \
9231 _(ip_mroute_dump, "table-id [ip4|ip6]") \
9232 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
9234 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
9235 "mac <mac-address> [del]") \
9236 _(l2_xconnect_dump, "") \
9237 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
9238 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
9239 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
9240 _(sock_init_shm, "size <nnn>") \
9241 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
9242 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
9243 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
9244 _(session_rules_dump, "") \
9245 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
9247 /* List of command functions, CLI names map directly to functions */
9248 #define foreach_cli_function \
9249 _(comment, "usage: comment <ignore-rest-of-line>") \
9250 _(dump_interface_table, "usage: dump_interface_table") \
9251 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
9252 _(dump_ipv4_table, "usage: dump_ipv4_table") \
9253 _(dump_ipv6_table, "usage: dump_ipv6_table") \
9254 _(dump_macro_table, "usage: dump_macro_table ") \
9255 _(dump_node_table, "usage: dump_node_table") \
9256 _(dump_msg_api_table, "usage: dump_msg_api_table") \
9257 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
9258 _(elog_disable, "usage: elog_disable") \
9259 _(elog_enable, "usage: elog_enable") \
9260 _(elog_save, "usage: elog_save <filename>") \
9261 _(get_msg_id, "usage: get_msg_id name_and_crc") \
9262 _(echo, "usage: echo <message>") \
9263 _(exec, "usage: exec <vpe-debug-CLI-command>") \
9264 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
9265 _(help, "usage: help") \
9266 _(q, "usage: quit") \
9267 _(quit, "usage: quit") \
9268 _(search_node_table, "usage: search_node_table <name>...") \
9269 _(set, "usage: set <variable-name> <value>") \
9270 _(script, "usage: script <file-name>") \
9271 _(statseg, "usage: statseg") \
9272 _(unset, "usage: unset <variable-name>")
9275 static void vl_api_##n##_t_handler_uni \
9276 (vl_api_##n##_t * mp) \
9278 vat_main_t * vam = &vat_main; \
9279 if (vam->json_output) { \
9280 vl_api_##n##_t_handler_json(mp); \
9282 vl_api_##n##_t_handler(mp); \
9285 foreach_vpe_api_reply_msg;
9286 #if VPP_API_TEST_BUILTIN == 0
9287 foreach_standalone_reply_msg;
9292 vat_api_hookup (vat_main_t * vam)
9295 vl_msg_api_set_handlers(VL_API_##N, #n, \
9296 vl_api_##n##_t_handler_uni, \
9298 vl_api_##n##_t_endian, \
9299 vl_api_##n##_t_print, \
9300 sizeof(vl_api_##n##_t), 1);
9301 foreach_vpe_api_reply_msg;
9302 #if VPP_API_TEST_BUILTIN == 0
9303 foreach_standalone_reply_msg;
9307 #if (VPP_API_TEST_BUILTIN==0)
9308 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
9310 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
9312 vam->function_by_name = hash_create_string (0, sizeof (uword));
9314 vam->help_by_name = hash_create_string (0, sizeof (uword));
9317 /* API messages we can send */
9318 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
9319 foreach_vpe_api_msg;
9323 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
9324 foreach_vpe_api_msg;
9328 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
9329 foreach_cli_function;
9333 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
9334 foreach_cli_function;
9338 #if VPP_API_TEST_BUILTIN
9339 static clib_error_t *
9340 vat_api_hookup_shim (vlib_main_t * vm)
9342 vat_api_hookup (&vat_main);
9346 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
9350 * fd.io coding-style-patch-verification: ON
9353 * eval: (c-set-style "gnu")