2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 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/l2tp/l2tp.h>
31 #include <vnet/vxlan/vxlan.h>
32 #include <vnet/geneve/geneve.h>
33 #include <vnet/gre/gre.h>
34 #include <vnet/vxlan-gpe/vxlan_gpe.h>
35 #include <vnet/lisp-gpe/lisp_gpe.h>
37 #include <vpp/api/vpe_msg_enum.h>
38 #include <vnet/l2/l2_classify.h>
39 #include <vnet/l2/l2_vtr.h>
40 #include <vnet/classify/in_out_acl.h>
41 #include <vnet/classify/policer_classify.h>
42 #include <vnet/classify/flow_classify.h>
43 #include <vnet/mpls/mpls.h>
44 #include <vnet/ipsec/ipsec.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/span/span.h>
51 #include <vnet/policer/policer.h>
52 #include <vnet/policer/police.h>
53 #include <vnet/mfib/mfib_types.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
57 #include <vnet/ip/ip_types_api.h>
58 #include "vat/json_format.h"
59 #include <vnet/ip/ip_types_api.h>
60 #include <vnet/ethernet/ethernet_types_api.h>
65 #define vl_typedefs /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* declare message handlers for each api */
71 #define vl_endianfun /* define message structures */
72 #include <vpp/api/vpe_all_api_h.h>
75 /* instantiate all the print functions we know about */
76 #if VPP_API_TEST_BUILTIN == 0
77 #define vl_print(handle, ...)
79 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
82 #include <vpp/api/vpe_all_api_h.h>
85 #define __plugin_msg_base 0
86 #include <vlibapi/vat_helper_macros.h>
88 #include <vnet/format_fns.h>
90 void vl_api_set_elog_main (elog_main_t * m);
91 int vl_api_set_elog_trace_api_messages (int enable);
93 #if VPP_API_TEST_BUILTIN == 0
103 vat_socket_connect (vat_main_t * vam)
106 vam->socket_client_main = &socket_client_main;
107 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
109 0 /* default socket rx, tx buffer */ )))
111 /* vpp expects the client index in network order */
112 vam->my_client_index = htonl (socket_client_main.client_index);
115 #else /* vpp built-in case, we don't do sockets... */
117 vat_socket_connect (vat_main_t * vam)
123 vl_socket_client_read (int wait)
129 vl_socket_client_write ()
135 vl_socket_client_msg_alloc (int nbytes)
143 vat_time_now (vat_main_t * vam)
145 #if VPP_API_TEST_BUILTIN
146 return vlib_time_now (vam->vlib_main);
148 return clib_time_now (&vam->clib_time);
153 errmsg (char *fmt, ...)
155 vat_main_t *vam = &vat_main;
160 s = va_format (0, fmt, &va);
165 #if VPP_API_TEST_BUILTIN
166 vlib_cli_output (vam->vlib_main, (char *) s);
169 if (vam->ifp != stdin)
170 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
171 vam->input_line_number);
173 fformat (vam->ofp, "%s\n", (char *) s);
181 #if VPP_API_TEST_BUILTIN == 0
183 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
185 vat_main_t *vam = va_arg (*args, vat_main_t *);
186 u32 *result = va_arg (*args, u32 *);
190 if (!unformat (input, "%s", &if_name))
193 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
201 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
206 /* Parse an IP4 address %d.%d.%d.%d. */
208 unformat_ip4_address (unformat_input_t * input, va_list * args)
210 u8 *result = va_arg (*args, u8 *);
213 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
216 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
228 unformat_ethernet_address (unformat_input_t * input, va_list * args)
230 u8 *result = va_arg (*args, u8 *);
233 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
234 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
238 for (i = 0; i < 6; i++)
239 if (a[i] >= (1 << 8))
242 for (i = 0; i < 6; i++)
248 /* Returns ethernet type as an int in host byte order. */
250 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
253 u16 *result = va_arg (*args, u16 *);
257 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
259 if (type >= (1 << 16))
267 /* Parse an IP6 address. */
269 unformat_ip6_address (unformat_input_t * input, va_list * args)
271 ip6_address_t *result = va_arg (*args, ip6_address_t *);
273 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
274 uword c, n_colon, double_colon_index;
276 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
277 double_colon_index = ARRAY_LEN (hex_quads);
278 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
281 if (c >= '0' && c <= '9')
283 else if (c >= 'a' && c <= 'f')
284 hex_digit = c + 10 - 'a';
285 else if (c >= 'A' && c <= 'F')
286 hex_digit = c + 10 - 'A';
287 else if (c == ':' && n_colon < 2)
291 unformat_put_input (input);
295 /* Too many hex quads. */
296 if (n_hex_quads >= ARRAY_LEN (hex_quads))
301 hex_quad = (hex_quad << 4) | hex_digit;
303 /* Hex quad must fit in 16 bits. */
304 if (n_hex_digits >= 4)
311 /* Save position of :: */
314 /* More than one :: ? */
315 if (double_colon_index < ARRAY_LEN (hex_quads))
317 double_colon_index = n_hex_quads;
320 if (n_colon > 0 && n_hex_digits > 0)
322 hex_quads[n_hex_quads++] = hex_quad;
328 if (n_hex_digits > 0)
329 hex_quads[n_hex_quads++] = hex_quad;
334 /* Expand :: to appropriate number of zero hex quads. */
335 if (double_colon_index < ARRAY_LEN (hex_quads))
337 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
339 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
340 hex_quads[n_zero + i] = hex_quads[i];
342 for (i = 0; i < n_zero; i++)
343 hex_quads[double_colon_index + i] = 0;
345 n_hex_quads = ARRAY_LEN (hex_quads);
348 /* Too few hex quads given. */
349 if (n_hex_quads < ARRAY_LEN (hex_quads))
352 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
353 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
360 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
362 u32 *r = va_arg (*args, u32 *);
365 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
366 foreach_ipsec_policy_action
374 format_ipsec_crypto_alg (u8 * s, va_list * args)
376 u32 i = va_arg (*args, u32);
381 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
382 foreach_ipsec_crypto_alg
385 return format (s, "unknown");
387 return format (s, "%s", t);
391 format_ipsec_integ_alg (u8 * s, va_list * args)
393 u32 i = va_arg (*args, u32);
398 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
399 foreach_ipsec_integ_alg
402 return format (s, "unknown");
404 return format (s, "%s", t);
407 #else /* VPP_API_TEST_BUILTIN == 1 */
409 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
411 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
412 vnet_main_t *vnm = vnet_get_main ();
413 u32 *result = va_arg (*args, u32 *);
415 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
419 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
421 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
422 vnet_main_t *vnm = vnet_get_main ();
423 u32 *result = va_arg (*args, u32 *);
425 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
428 #endif /* VPP_API_TEST_BUILTIN */
431 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
433 u32 *r = va_arg (*args, u32 *);
436 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
437 foreach_ipsec_crypto_alg
445 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
447 u32 *r = va_arg (*args, u32 *);
450 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
451 foreach_ipsec_integ_alg
459 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
461 u8 *r = va_arg (*args, u8 *);
463 if (unformat (input, "kbps"))
464 *r = SSE2_QOS_RATE_KBPS;
465 else if (unformat (input, "pps"))
466 *r = SSE2_QOS_RATE_PPS;
473 unformat_policer_round_type (unformat_input_t * input, va_list * args)
475 u8 *r = va_arg (*args, u8 *);
477 if (unformat (input, "closest"))
478 *r = SSE2_QOS_ROUND_TO_CLOSEST;
479 else if (unformat (input, "up"))
480 *r = SSE2_QOS_ROUND_TO_UP;
481 else if (unformat (input, "down"))
482 *r = SSE2_QOS_ROUND_TO_DOWN;
489 unformat_policer_type (unformat_input_t * input, va_list * args)
491 u8 *r = va_arg (*args, u8 *);
493 if (unformat (input, "1r2c"))
494 *r = SSE2_QOS_POLICER_TYPE_1R2C;
495 else if (unformat (input, "1r3c"))
496 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
497 else if (unformat (input, "2r3c-2698"))
498 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
499 else if (unformat (input, "2r3c-4115"))
500 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
501 else if (unformat (input, "2r3c-mef5cf1"))
502 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
509 unformat_dscp (unformat_input_t * input, va_list * va)
511 u8 *r = va_arg (*va, u8 *);
514 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
523 unformat_policer_action_type (unformat_input_t * input, va_list * va)
525 sse2_qos_pol_action_params_st *a
526 = va_arg (*va, sse2_qos_pol_action_params_st *);
528 if (unformat (input, "drop"))
529 a->action_type = SSE2_QOS_ACTION_DROP;
530 else if (unformat (input, "transmit"))
531 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
532 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
533 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
540 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
542 u32 *r = va_arg (*va, u32 *);
545 if (unformat (input, "ip4"))
546 tid = POLICER_CLASSIFY_TABLE_IP4;
547 else if (unformat (input, "ip6"))
548 tid = POLICER_CLASSIFY_TABLE_IP6;
549 else if (unformat (input, "l2"))
550 tid = POLICER_CLASSIFY_TABLE_L2;
559 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
561 u32 *r = va_arg (*va, u32 *);
564 if (unformat (input, "ip4"))
565 tid = FLOW_CLASSIFY_TABLE_IP4;
566 else if (unformat (input, "ip6"))
567 tid = FLOW_CLASSIFY_TABLE_IP6;
575 #if (VPP_API_TEST_BUILTIN==0)
577 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
578 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
579 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
580 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
583 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
585 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
586 mfib_itf_attribute_t attr;
589 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
591 if (unformat (input, mfib_itf_flag_long_names[attr]))
592 *iflags |= (1 << attr);
594 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
596 if (unformat (input, mfib_itf_flag_names[attr]))
597 *iflags |= (1 << attr);
600 return (old == *iflags ? 0 : 1);
604 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
606 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
607 mfib_entry_attribute_t attr;
610 FOR_EACH_MFIB_ATTRIBUTE (attr)
612 if (unformat (input, mfib_flag_long_names[attr]))
613 *eflags |= (1 << attr);
615 FOR_EACH_MFIB_ATTRIBUTE (attr)
617 if (unformat (input, mfib_flag_names[attr]))
618 *eflags |= (1 << attr);
621 return (old == *eflags ? 0 : 1);
625 format_ip4_address (u8 * s, va_list * args)
627 u8 *a = va_arg (*args, u8 *);
628 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
632 format_ip6_address (u8 * s, va_list * args)
634 ip6_address_t *a = va_arg (*args, ip6_address_t *);
635 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
637 i_max_n_zero = ARRAY_LEN (a->as_u16);
639 i_first_zero = i_max_n_zero;
641 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
643 u32 is_zero = a->as_u16[i] == 0;
644 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
650 if ((!is_zero && n_zeros > max_n_zeros)
651 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
653 i_max_n_zero = i_first_zero;
654 max_n_zeros = n_zeros;
655 i_first_zero = ARRAY_LEN (a->as_u16);
660 last_double_colon = 0;
661 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
663 if (i == i_max_n_zero && max_n_zeros > 1)
665 s = format (s, "::");
666 i += max_n_zeros - 1;
667 last_double_colon = 1;
671 s = format (s, "%s%x",
672 (last_double_colon || i == 0) ? "" : ":",
673 clib_net_to_host_u16 (a->as_u16[i]));
674 last_double_colon = 0;
681 /* Format an IP46 address. */
683 format_ip46_address (u8 * s, va_list * args)
685 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
686 ip46_type_t type = va_arg (*args, ip46_type_t);
692 is_ip4 = ip46_address_is_ip4 (ip46);
703 format (s, "%U", format_ip4_address, &ip46->ip4) :
704 format (s, "%U", format_ip6_address, &ip46->ip6);
708 format_ethernet_address (u8 * s, va_list * args)
710 u8 *a = va_arg (*args, u8 *);
712 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
713 a[0], a[1], a[2], a[3], a[4], a[5]);
718 increment_v4_address (vl_api_ip4_address_t * i)
720 ip4_address_t *a = (ip4_address_t *) i;
723 v = ntohl (a->as_u32) + 1;
724 a->as_u32 = ntohl (v);
728 increment_v6_address (vl_api_ip6_address_t * i)
730 ip6_address_t *a = (ip6_address_t *) i;
733 v0 = clib_net_to_host_u64 (a->as_u64[0]);
734 v1 = clib_net_to_host_u64 (a->as_u64[1]);
739 a->as_u64[0] = clib_net_to_host_u64 (v0);
740 a->as_u64[1] = clib_net_to_host_u64 (v1);
744 increment_address (vl_api_address_t * a)
746 if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
747 increment_v4_address (&a->un.ip4);
748 else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
749 increment_v6_address (&a->un.ip6);
753 set_ip4_address (vl_api_address_t * a, u32 v)
755 if (a->af == ADDRESS_IP4)
757 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
763 increment_mac_address (u8 * mac)
765 u64 tmp = *((u64 *) mac);
766 tmp = clib_net_to_host_u64 (tmp);
767 tmp += 1 << 16; /* skip unused (least significant) octets */
768 tmp = clib_host_to_net_u64 (tmp);
770 clib_memcpy (mac, &tmp, 6);
774 vat_json_object_add_address (vat_json_node_t * node,
775 const char *str, const vl_api_address_t * addr)
777 if (ADDRESS_IP6 == addr->af)
781 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
782 vat_json_object_add_ip6 (node, str, ip6);
788 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
789 vat_json_object_add_ip4 (node, str, ip4);
794 vat_json_object_add_prefix (vat_json_node_t * node,
795 const vl_api_prefix_t * prefix)
797 vat_json_object_add_uint (node, "len", prefix->len);
798 vat_json_object_add_address (node, "address", &prefix->address);
801 static void vl_api_create_loopback_reply_t_handler
802 (vl_api_create_loopback_reply_t * mp)
804 vat_main_t *vam = &vat_main;
805 i32 retval = ntohl (mp->retval);
807 vam->retval = retval;
808 vam->regenerate_interface_table = 1;
809 vam->sw_if_index = ntohl (mp->sw_if_index);
810 vam->result_ready = 1;
813 static void vl_api_create_loopback_reply_t_handler_json
814 (vl_api_create_loopback_reply_t * mp)
816 vat_main_t *vam = &vat_main;
817 vat_json_node_t node;
819 vat_json_init_object (&node);
820 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
821 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
823 vat_json_print (vam->ofp, &node);
824 vat_json_free (&node);
825 vam->retval = ntohl (mp->retval);
826 vam->result_ready = 1;
829 static void vl_api_create_loopback_instance_reply_t_handler
830 (vl_api_create_loopback_instance_reply_t * mp)
832 vat_main_t *vam = &vat_main;
833 i32 retval = ntohl (mp->retval);
835 vam->retval = retval;
836 vam->regenerate_interface_table = 1;
837 vam->sw_if_index = ntohl (mp->sw_if_index);
838 vam->result_ready = 1;
841 static void vl_api_create_loopback_instance_reply_t_handler_json
842 (vl_api_create_loopback_instance_reply_t * mp)
844 vat_main_t *vam = &vat_main;
845 vat_json_node_t node;
847 vat_json_init_object (&node);
848 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
849 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
851 vat_json_print (vam->ofp, &node);
852 vat_json_free (&node);
853 vam->retval = ntohl (mp->retval);
854 vam->result_ready = 1;
857 static void vl_api_af_packet_create_reply_t_handler
858 (vl_api_af_packet_create_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 i32 retval = ntohl (mp->retval);
863 vam->retval = retval;
864 vam->regenerate_interface_table = 1;
865 vam->sw_if_index = ntohl (mp->sw_if_index);
866 vam->result_ready = 1;
869 static void vl_api_af_packet_create_reply_t_handler_json
870 (vl_api_af_packet_create_reply_t * mp)
872 vat_main_t *vam = &vat_main;
873 vat_json_node_t node;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
879 vat_json_print (vam->ofp, &node);
880 vat_json_free (&node);
882 vam->retval = ntohl (mp->retval);
883 vam->result_ready = 1;
886 static void vl_api_create_vlan_subif_reply_t_handler
887 (vl_api_create_vlan_subif_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 i32 retval = ntohl (mp->retval);
892 vam->retval = retval;
893 vam->regenerate_interface_table = 1;
894 vam->sw_if_index = ntohl (mp->sw_if_index);
895 vam->result_ready = 1;
898 static void vl_api_create_vlan_subif_reply_t_handler_json
899 (vl_api_create_vlan_subif_reply_t * mp)
901 vat_main_t *vam = &vat_main;
902 vat_json_node_t node;
904 vat_json_init_object (&node);
905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
906 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
908 vat_json_print (vam->ofp, &node);
909 vat_json_free (&node);
911 vam->retval = ntohl (mp->retval);
912 vam->result_ready = 1;
915 static void vl_api_create_subif_reply_t_handler
916 (vl_api_create_subif_reply_t * mp)
918 vat_main_t *vam = &vat_main;
919 i32 retval = ntohl (mp->retval);
921 vam->retval = retval;
922 vam->regenerate_interface_table = 1;
923 vam->sw_if_index = ntohl (mp->sw_if_index);
924 vam->result_ready = 1;
927 static void vl_api_create_subif_reply_t_handler_json
928 (vl_api_create_subif_reply_t * mp)
930 vat_main_t *vam = &vat_main;
931 vat_json_node_t node;
933 vat_json_init_object (&node);
934 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
935 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
937 vat_json_print (vam->ofp, &node);
938 vat_json_free (&node);
940 vam->retval = ntohl (mp->retval);
941 vam->result_ready = 1;
944 static void vl_api_interface_name_renumber_reply_t_handler
945 (vl_api_interface_name_renumber_reply_t * mp)
947 vat_main_t *vam = &vat_main;
948 i32 retval = ntohl (mp->retval);
950 vam->retval = retval;
951 vam->regenerate_interface_table = 1;
952 vam->result_ready = 1;
955 static void vl_api_interface_name_renumber_reply_t_handler_json
956 (vl_api_interface_name_renumber_reply_t * mp)
958 vat_main_t *vam = &vat_main;
959 vat_json_node_t node;
961 vat_json_init_object (&node);
962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
964 vat_json_print (vam->ofp, &node);
965 vat_json_free (&node);
967 vam->retval = ntohl (mp->retval);
968 vam->result_ready = 1;
972 * Special-case: build the interface table, maintain
973 * the next loopback sw_if_index vbl.
975 static void vl_api_sw_interface_details_t_handler
976 (vl_api_sw_interface_details_t * mp)
978 vat_main_t *vam = &vat_main;
979 u8 *s = format (0, "%s%c", mp->interface_name, 0);
981 hash_set_mem (vam->sw_if_index_by_interface_name, s,
982 ntohl (mp->sw_if_index));
984 /* In sub interface case, fill the sub interface table entry */
985 if (mp->sw_if_index != mp->sup_sw_if_index)
987 sw_interface_subif_t *sub = NULL;
989 vec_add2 (vam->sw_if_subif_table, sub, 1);
991 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
992 strncpy ((char *) sub->interface_name, (char *) s,
993 vec_len (sub->interface_name));
994 sub->sw_if_index = ntohl (mp->sw_if_index);
995 sub->sub_id = ntohl (mp->sub_id);
997 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
999 sub->sub_number_of_tags = mp->sub_number_of_tags;
1000 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1001 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1003 /* vlan tag rewrite */
1004 sub->vtr_op = ntohl (mp->vtr_op);
1005 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1006 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1007 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1011 static void vl_api_sw_interface_details_t_handler_json
1012 (vl_api_sw_interface_details_t * mp)
1014 vat_main_t *vam = &vat_main;
1015 vat_json_node_t *node = NULL;
1017 if (VAT_JSON_ARRAY != vam->json_tree.type)
1019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1020 vat_json_init_array (&vam->json_tree);
1022 node = vat_json_array_add (&vam->json_tree);
1024 vat_json_init_object (node);
1025 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1026 vat_json_object_add_uint (node, "sup_sw_if_index",
1027 ntohl (mp->sup_sw_if_index));
1028 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1029 sizeof (mp->l2_address));
1030 vat_json_object_add_string_copy (node, "interface_name",
1031 mp->interface_name);
1032 vat_json_object_add_string_copy (node, "interface_dev_type",
1033 mp->interface_dev_type);
1034 vat_json_object_add_uint (node, "flags", mp->flags);
1035 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1036 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1037 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1038 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1039 vat_json_object_add_uint (node, "sub_number_of_tags",
1040 mp->sub_number_of_tags);
1041 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1042 ntohs (mp->sub_outer_vlan_id));
1043 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1044 ntohs (mp->sub_inner_vlan_id));
1045 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1046 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1047 vat_json_object_add_uint (node, "vtr_push_dot1q",
1048 ntohl (mp->vtr_push_dot1q));
1049 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1050 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1051 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1053 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1055 format_ethernet_address,
1057 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1059 format_ethernet_address,
1061 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1062 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1066 #if VPP_API_TEST_BUILTIN == 0
1067 static void vl_api_sw_interface_event_t_handler
1068 (vl_api_sw_interface_event_t * mp)
1070 vat_main_t *vam = &vat_main;
1071 if (vam->interface_event_display)
1072 errmsg ("interface flags: sw_if_index %d %s %s",
1073 ntohl (mp->sw_if_index),
1074 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1075 "admin-up" : "admin-down",
1076 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1077 "link-up" : "link-down");
1081 __clib_unused static void
1082 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1084 /* JSON output not supported */
1088 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1090 vat_main_t *vam = &vat_main;
1091 i32 retval = ntohl (mp->retval);
1093 vam->retval = retval;
1094 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1095 vam->result_ready = 1;
1099 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1101 vat_main_t *vam = &vat_main;
1102 vat_json_node_t node;
1106 vat_json_init_object (&node);
1107 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1108 vat_json_object_add_uint (&node, "reply_in_shmem",
1109 ntohl (mp->reply_in_shmem));
1110 /* Toss the shared-memory original... */
1111 oldheap = vl_msg_push_heap ();
1113 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1116 vl_msg_pop_heap (oldheap);
1118 vat_json_print (vam->ofp, &node);
1119 vat_json_free (&node);
1121 vam->retval = ntohl (mp->retval);
1122 vam->result_ready = 1;
1126 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1128 vat_main_t *vam = &vat_main;
1129 i32 retval = ntohl (mp->retval);
1130 u32 length = vl_api_string_len (&mp->reply);
1132 vec_reset_length (vam->cmd_reply);
1134 vam->retval = retval;
1137 vec_validate (vam->cmd_reply, length);
1138 clib_memcpy ((char *) (vam->cmd_reply),
1139 vl_api_from_api_string (&mp->reply), length);
1140 vam->cmd_reply[length] = 0;
1142 vam->result_ready = 1;
1146 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1148 vat_main_t *vam = &vat_main;
1149 vat_json_node_t node;
1151 vec_reset_length (vam->cmd_reply);
1153 vat_json_init_object (&node);
1154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1155 vat_json_object_add_string_copy (&node, "reply",
1156 vl_api_from_api_string (&mp->reply));
1158 vat_json_print (vam->ofp, &node);
1159 vat_json_free (&node);
1161 vam->retval = ntohl (mp->retval);
1162 vam->result_ready = 1;
1165 static void vl_api_classify_add_del_table_reply_t_handler
1166 (vl_api_classify_add_del_table_reply_t * mp)
1168 vat_main_t *vam = &vat_main;
1169 i32 retval = ntohl (mp->retval);
1170 if (vam->async_mode)
1172 vam->async_errors += (retval < 0);
1176 vam->retval = retval;
1178 ((mp->new_table_index != 0xFFFFFFFF) ||
1179 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1180 (mp->match_n_vectors != 0xFFFFFFFF)))
1182 * Note: this is just barely thread-safe, depends on
1183 * the main thread spinning waiting for an answer...
1185 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1186 ntohl (mp->new_table_index),
1187 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1188 vam->result_ready = 1;
1192 static void vl_api_classify_add_del_table_reply_t_handler_json
1193 (vl_api_classify_add_del_table_reply_t * mp)
1195 vat_main_t *vam = &vat_main;
1196 vat_json_node_t node;
1198 vat_json_init_object (&node);
1199 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1200 vat_json_object_add_uint (&node, "new_table_index",
1201 ntohl (mp->new_table_index));
1202 vat_json_object_add_uint (&node, "skip_n_vectors",
1203 ntohl (mp->skip_n_vectors));
1204 vat_json_object_add_uint (&node, "match_n_vectors",
1205 ntohl (mp->match_n_vectors));
1207 vat_json_print (vam->ofp, &node);
1208 vat_json_free (&node);
1210 vam->retval = ntohl (mp->retval);
1211 vam->result_ready = 1;
1214 static void vl_api_get_node_index_reply_t_handler
1215 (vl_api_get_node_index_reply_t * mp)
1217 vat_main_t *vam = &vat_main;
1218 i32 retval = ntohl (mp->retval);
1219 if (vam->async_mode)
1221 vam->async_errors += (retval < 0);
1225 vam->retval = retval;
1227 errmsg ("node index %d", ntohl (mp->node_index));
1228 vam->result_ready = 1;
1232 static void vl_api_get_node_index_reply_t_handler_json
1233 (vl_api_get_node_index_reply_t * mp)
1235 vat_main_t *vam = &vat_main;
1236 vat_json_node_t node;
1238 vat_json_init_object (&node);
1239 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1240 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1242 vat_json_print (vam->ofp, &node);
1243 vat_json_free (&node);
1245 vam->retval = ntohl (mp->retval);
1246 vam->result_ready = 1;
1249 static void vl_api_get_next_index_reply_t_handler
1250 (vl_api_get_next_index_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1254 if (vam->async_mode)
1256 vam->async_errors += (retval < 0);
1260 vam->retval = retval;
1262 errmsg ("next node index %d", ntohl (mp->next_index));
1263 vam->result_ready = 1;
1267 static void vl_api_get_next_index_reply_t_handler_json
1268 (vl_api_get_next_index_reply_t * mp)
1270 vat_main_t *vam = &vat_main;
1271 vat_json_node_t node;
1273 vat_json_init_object (&node);
1274 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1275 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1277 vat_json_print (vam->ofp, &node);
1278 vat_json_free (&node);
1280 vam->retval = ntohl (mp->retval);
1281 vam->result_ready = 1;
1284 static void vl_api_add_node_next_reply_t_handler
1285 (vl_api_add_node_next_reply_t * mp)
1287 vat_main_t *vam = &vat_main;
1288 i32 retval = ntohl (mp->retval);
1289 if (vam->async_mode)
1291 vam->async_errors += (retval < 0);
1295 vam->retval = retval;
1297 errmsg ("next index %d", ntohl (mp->next_index));
1298 vam->result_ready = 1;
1302 static void vl_api_add_node_next_reply_t_handler_json
1303 (vl_api_add_node_next_reply_t * mp)
1305 vat_main_t *vam = &vat_main;
1306 vat_json_node_t node;
1308 vat_json_init_object (&node);
1309 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1310 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1312 vat_json_print (vam->ofp, &node);
1313 vat_json_free (&node);
1315 vam->retval = ntohl (mp->retval);
1316 vam->result_ready = 1;
1319 static void vl_api_show_version_reply_t_handler
1320 (vl_api_show_version_reply_t * mp)
1322 vat_main_t *vam = &vat_main;
1323 i32 retval = ntohl (mp->retval);
1327 errmsg (" program: %s", mp->program);
1328 errmsg (" version: %s", mp->version);
1329 errmsg (" build date: %s", mp->build_date);
1330 errmsg ("build directory: %s", mp->build_directory);
1332 vam->retval = retval;
1333 vam->result_ready = 1;
1336 static void vl_api_show_version_reply_t_handler_json
1337 (vl_api_show_version_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 vat_json_node_t node;
1342 vat_json_init_object (&node);
1343 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1344 vat_json_object_add_string_copy (&node, "program", mp->program);
1345 vat_json_object_add_string_copy (&node, "version", mp->version);
1346 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1347 vat_json_object_add_string_copy (&node, "build_directory",
1348 mp->build_directory);
1350 vat_json_print (vam->ofp, &node);
1351 vat_json_free (&node);
1353 vam->retval = ntohl (mp->retval);
1354 vam->result_ready = 1;
1357 static void vl_api_show_threads_reply_t_handler
1358 (vl_api_show_threads_reply_t * mp)
1360 vat_main_t *vam = &vat_main;
1361 i32 retval = ntohl (mp->retval);
1365 count = ntohl (mp->count);
1367 for (i = 0; i < count; i++)
1369 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1370 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1371 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1372 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1373 ntohl (mp->thread_data[i].cpu_socket));
1375 vam->retval = retval;
1376 vam->result_ready = 1;
1379 static void vl_api_show_threads_reply_t_handler_json
1380 (vl_api_show_threads_reply_t * mp)
1382 vat_main_t *vam = &vat_main;
1383 vat_json_node_t node;
1384 vl_api_thread_data_t *td;
1385 i32 retval = ntohl (mp->retval);
1389 count = ntohl (mp->count);
1391 vat_json_init_object (&node);
1392 vat_json_object_add_int (&node, "retval", retval);
1393 vat_json_object_add_uint (&node, "count", count);
1395 for (i = 0; i < count; i++)
1397 td = &mp->thread_data[i];
1398 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1399 vat_json_object_add_string_copy (&node, "name", td->name);
1400 vat_json_object_add_string_copy (&node, "type", td->type);
1401 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1402 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1403 vat_json_object_add_int (&node, "core", ntohl (td->id));
1404 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1407 vat_json_print (vam->ofp, &node);
1408 vat_json_free (&node);
1410 vam->retval = retval;
1411 vam->result_ready = 1;
1415 api_show_threads (vat_main_t * vam)
1417 vl_api_show_threads_t *mp;
1421 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1422 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1424 M (SHOW_THREADS, mp);
1432 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1434 u32 n_macs = ntohl (mp->n_macs);
1435 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1436 ntohl (mp->pid), mp->client_index, n_macs);
1438 for (i = 0; i < n_macs; i++)
1440 vl_api_mac_entry_t *mac = &mp->mac[i];
1441 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1442 i + 1, ntohl (mac->sw_if_index),
1443 format_ethernet_address, mac->mac_addr, mac->action);
1450 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1452 /* JSON output not supported */
1455 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1456 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1459 * Special-case: build the bridge domain table, maintain
1460 * the next bd id vbl.
1462 static void vl_api_bridge_domain_details_t_handler
1463 (vl_api_bridge_domain_details_t * mp)
1465 vat_main_t *vam = &vat_main;
1466 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1469 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1470 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1472 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1473 ntohl (mp->bd_id), mp->learn, mp->forward,
1474 mp->flood, ntohl (mp->bvi_sw_if_index),
1475 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1479 vl_api_bridge_domain_sw_if_t *sw_ifs;
1480 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1483 sw_ifs = mp->sw_if_details;
1484 for (i = 0; i < n_sw_ifs; i++)
1490 sw_if_index = ntohl (sw_ifs->sw_if_index);
1493 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1495 if ((u32) p->value[0] == sw_if_index)
1497 sw_if_name = (u8 *)(p->key);
1502 print (vam->ofp, "%7d %3d %s", sw_if_index,
1503 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1504 "sw_if_index not found!");
1511 static void vl_api_bridge_domain_details_t_handler_json
1512 (vl_api_bridge_domain_details_t * mp)
1514 vat_main_t *vam = &vat_main;
1515 vat_json_node_t *node, *array = NULL;
1516 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1518 if (VAT_JSON_ARRAY != vam->json_tree.type)
1520 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1521 vat_json_init_array (&vam->json_tree);
1523 node = vat_json_array_add (&vam->json_tree);
1525 vat_json_init_object (node);
1526 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1527 vat_json_object_add_uint (node, "flood", mp->flood);
1528 vat_json_object_add_uint (node, "forward", mp->forward);
1529 vat_json_object_add_uint (node, "learn", mp->learn);
1530 vat_json_object_add_uint (node, "bvi_sw_if_index",
1531 ntohl (mp->bvi_sw_if_index));
1532 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1533 array = vat_json_object_add (node, "sw_if");
1534 vat_json_init_array (array);
1540 vl_api_bridge_domain_sw_if_t *sw_ifs;
1543 sw_ifs = mp->sw_if_details;
1544 for (i = 0; i < n_sw_ifs; i++)
1546 node = vat_json_array_add (array);
1547 vat_json_init_object (node);
1548 vat_json_object_add_uint (node, "sw_if_index",
1549 ntohl (sw_ifs->sw_if_index));
1550 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1556 static void vl_api_control_ping_reply_t_handler
1557 (vl_api_control_ping_reply_t * mp)
1559 vat_main_t *vam = &vat_main;
1560 i32 retval = ntohl (mp->retval);
1561 if (vam->async_mode)
1563 vam->async_errors += (retval < 0);
1567 vam->retval = retval;
1568 vam->result_ready = 1;
1570 if (vam->socket_client_main)
1571 vam->socket_client_main->control_pings_outstanding--;
1574 static void vl_api_control_ping_reply_t_handler_json
1575 (vl_api_control_ping_reply_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 i32 retval = ntohl (mp->retval);
1580 if (VAT_JSON_NONE != vam->json_tree.type)
1582 vat_json_print (vam->ofp, &vam->json_tree);
1583 vat_json_free (&vam->json_tree);
1584 vam->json_tree.type = VAT_JSON_NONE;
1589 vat_json_init_array (&vam->json_tree);
1590 vat_json_print (vam->ofp, &vam->json_tree);
1591 vam->json_tree.type = VAT_JSON_NONE;
1594 vam->retval = retval;
1595 vam->result_ready = 1;
1599 vl_api_bridge_domain_set_mac_age_reply_t_handler
1600 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1602 vat_main_t *vam = &vat_main;
1603 i32 retval = ntohl (mp->retval);
1604 if (vam->async_mode)
1606 vam->async_errors += (retval < 0);
1610 vam->retval = retval;
1611 vam->result_ready = 1;
1615 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1616 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1618 vat_main_t *vam = &vat_main;
1619 vat_json_node_t node;
1621 vat_json_init_object (&node);
1622 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1624 vat_json_print (vam->ofp, &node);
1625 vat_json_free (&node);
1627 vam->retval = ntohl (mp->retval);
1628 vam->result_ready = 1;
1632 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1634 vat_main_t *vam = &vat_main;
1635 i32 retval = ntohl (mp->retval);
1636 if (vam->async_mode)
1638 vam->async_errors += (retval < 0);
1642 vam->retval = retval;
1643 vam->result_ready = 1;
1647 static void vl_api_l2_flags_reply_t_handler_json
1648 (vl_api_l2_flags_reply_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 vat_json_node_t node;
1653 vat_json_init_object (&node);
1654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1656 ntohl (mp->resulting_feature_bitmap));
1658 vat_json_print (vam->ofp, &node);
1659 vat_json_free (&node);
1661 vam->retval = ntohl (mp->retval);
1662 vam->result_ready = 1;
1665 static void vl_api_bridge_flags_reply_t_handler
1666 (vl_api_bridge_flags_reply_t * mp)
1668 vat_main_t *vam = &vat_main;
1669 i32 retval = ntohl (mp->retval);
1670 if (vam->async_mode)
1672 vam->async_errors += (retval < 0);
1676 vam->retval = retval;
1677 vam->result_ready = 1;
1681 static void vl_api_bridge_flags_reply_t_handler_json
1682 (vl_api_bridge_flags_reply_t * mp)
1684 vat_main_t *vam = &vat_main;
1685 vat_json_node_t node;
1687 vat_json_init_object (&node);
1688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1689 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1690 ntohl (mp->resulting_feature_bitmap));
1692 vat_json_print (vam->ofp, &node);
1693 vat_json_free (&node);
1695 vam->retval = ntohl (mp->retval);
1696 vam->result_ready = 1;
1700 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1702 vat_main_t *vam = &vat_main;
1703 i32 retval = ntohl (mp->retval);
1704 if (vam->async_mode)
1706 vam->async_errors += (retval < 0);
1710 vam->retval = retval;
1711 vam->sw_if_index = ntohl (mp->sw_if_index);
1712 vam->result_ready = 1;
1717 static void vl_api_tap_create_v2_reply_t_handler_json
1718 (vl_api_tap_create_v2_reply_t * mp)
1720 vat_main_t *vam = &vat_main;
1721 vat_json_node_t node;
1723 vat_json_init_object (&node);
1724 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1725 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1727 vat_json_print (vam->ofp, &node);
1728 vat_json_free (&node);
1730 vam->retval = ntohl (mp->retval);
1731 vam->result_ready = 1;
1736 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1738 vat_main_t *vam = &vat_main;
1739 i32 retval = ntohl (mp->retval);
1740 if (vam->async_mode)
1742 vam->async_errors += (retval < 0);
1746 vam->retval = retval;
1747 vam->result_ready = 1;
1751 static void vl_api_tap_delete_v2_reply_t_handler_json
1752 (vl_api_tap_delete_v2_reply_t * mp)
1754 vat_main_t *vam = &vat_main;
1755 vat_json_node_t node;
1757 vat_json_init_object (&node);
1758 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1760 vat_json_print (vam->ofp, &node);
1761 vat_json_free (&node);
1763 vam->retval = ntohl (mp->retval);
1764 vam->result_ready = 1;
1768 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1771 vat_main_t *vam = &vat_main;
1772 i32 retval = ntohl (mp->retval);
1773 if (vam->async_mode)
1775 vam->async_errors += (retval < 0);
1779 vam->retval = retval;
1780 vam->sw_if_index = ntohl (mp->sw_if_index);
1781 vam->result_ready = 1;
1785 static void vl_api_virtio_pci_create_reply_t_handler_json
1786 (vl_api_virtio_pci_create_reply_t * mp)
1788 vat_main_t *vam = &vat_main;
1789 vat_json_node_t node;
1791 vat_json_init_object (&node);
1792 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1793 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1795 vat_json_print (vam->ofp, &node);
1796 vat_json_free (&node);
1798 vam->retval = ntohl (mp->retval);
1799 vam->result_ready = 1;
1804 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1807 vat_main_t *vam = &vat_main;
1808 i32 retval = ntohl (mp->retval);
1809 if (vam->async_mode)
1811 vam->async_errors += (retval < 0);
1815 vam->retval = retval;
1816 vam->result_ready = 1;
1820 static void vl_api_virtio_pci_delete_reply_t_handler_json
1821 (vl_api_virtio_pci_delete_reply_t * mp)
1823 vat_main_t *vam = &vat_main;
1824 vat_json_node_t node;
1826 vat_json_init_object (&node);
1827 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1829 vat_json_print (vam->ofp, &node);
1830 vat_json_free (&node);
1832 vam->retval = ntohl (mp->retval);
1833 vam->result_ready = 1;
1837 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1839 vat_main_t *vam = &vat_main;
1840 i32 retval = ntohl (mp->retval);
1842 if (vam->async_mode)
1844 vam->async_errors += (retval < 0);
1848 vam->retval = retval;
1849 vam->sw_if_index = ntohl (mp->sw_if_index);
1850 vam->result_ready = 1;
1854 static void vl_api_bond_create_reply_t_handler_json
1855 (vl_api_bond_create_reply_t * mp)
1857 vat_main_t *vam = &vat_main;
1858 vat_json_node_t node;
1860 vat_json_init_object (&node);
1861 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1862 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1864 vat_json_print (vam->ofp, &node);
1865 vat_json_free (&node);
1867 vam->retval = ntohl (mp->retval);
1868 vam->result_ready = 1;
1872 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1874 vat_main_t *vam = &vat_main;
1875 i32 retval = ntohl (mp->retval);
1877 if (vam->async_mode)
1879 vam->async_errors += (retval < 0);
1883 vam->retval = retval;
1884 vam->result_ready = 1;
1888 static void vl_api_bond_delete_reply_t_handler_json
1889 (vl_api_bond_delete_reply_t * mp)
1891 vat_main_t *vam = &vat_main;
1892 vat_json_node_t node;
1894 vat_json_init_object (&node);
1895 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1897 vat_json_print (vam->ofp, &node);
1898 vat_json_free (&node);
1900 vam->retval = ntohl (mp->retval);
1901 vam->result_ready = 1;
1905 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1907 vat_main_t *vam = &vat_main;
1908 i32 retval = ntohl (mp->retval);
1910 if (vam->async_mode)
1912 vam->async_errors += (retval < 0);
1916 vam->retval = retval;
1917 vam->result_ready = 1;
1921 static void vl_api_bond_enslave_reply_t_handler_json
1922 (vl_api_bond_enslave_reply_t * mp)
1924 vat_main_t *vam = &vat_main;
1925 vat_json_node_t node;
1927 vat_json_init_object (&node);
1928 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1930 vat_json_print (vam->ofp, &node);
1931 vat_json_free (&node);
1933 vam->retval = ntohl (mp->retval);
1934 vam->result_ready = 1;
1938 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1941 vat_main_t *vam = &vat_main;
1942 i32 retval = ntohl (mp->retval);
1944 if (vam->async_mode)
1946 vam->async_errors += (retval < 0);
1950 vam->retval = retval;
1951 vam->result_ready = 1;
1955 static void vl_api_bond_detach_slave_reply_t_handler_json
1956 (vl_api_bond_detach_slave_reply_t * mp)
1958 vat_main_t *vam = &vat_main;
1959 vat_json_node_t node;
1961 vat_json_init_object (&node);
1962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1964 vat_json_print (vam->ofp, &node);
1965 vat_json_free (&node);
1967 vam->retval = ntohl (mp->retval);
1968 vam->result_ready = 1;
1972 api_sw_interface_set_bond_weight (vat_main_t * vam)
1974 unformat_input_t *i = vam->input;
1975 vl_api_sw_interface_set_bond_weight_t *mp;
1976 u32 sw_if_index = ~0;
1978 u8 weight_enter = 0;
1981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
1983 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
1985 else if (unformat (i, "sw_if_index %d", &sw_if_index))
1987 else if (unformat (i, "weight %u", &weight))
1993 if (sw_if_index == ~0)
1995 errmsg ("missing interface name or sw_if_index");
1998 if (weight_enter == 0)
2000 errmsg ("missing valid weight");
2004 /* Construct the API message */
2005 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2006 mp->sw_if_index = ntohl (sw_if_index);
2007 mp->weight = ntohl (weight);
2014 static void vl_api_sw_interface_bond_details_t_handler
2015 (vl_api_sw_interface_bond_details_t * mp)
2017 vat_main_t *vam = &vat_main;
2020 "%-16s %-12d %-12U %-13U %-14u %-14u",
2021 mp->interface_name, ntohl (mp->sw_if_index),
2022 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2023 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2026 static void vl_api_sw_interface_bond_details_t_handler_json
2027 (vl_api_sw_interface_bond_details_t * mp)
2029 vat_main_t *vam = &vat_main;
2030 vat_json_node_t *node = NULL;
2032 if (VAT_JSON_ARRAY != vam->json_tree.type)
2034 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2035 vat_json_init_array (&vam->json_tree);
2037 node = vat_json_array_add (&vam->json_tree);
2039 vat_json_init_object (node);
2040 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2041 vat_json_object_add_string_copy (node, "interface_name",
2042 mp->interface_name);
2043 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2044 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2045 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2046 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2050 api_sw_interface_bond_dump (vat_main_t * vam)
2052 vl_api_sw_interface_bond_dump_t *mp;
2053 vl_api_control_ping_t *mp_ping;
2057 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2058 "interface name", "sw_if_index", "mode", "load balance",
2059 "active slaves", "slaves");
2061 /* Get list of bond interfaces */
2062 M (SW_INTERFACE_BOND_DUMP, mp);
2065 /* Use a control ping for synchronization */
2066 MPING (CONTROL_PING, mp_ping);
2073 static void vl_api_sw_interface_slave_details_t_handler
2074 (vl_api_sw_interface_slave_details_t * mp)
2076 vat_main_t *vam = &vat_main;
2079 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2080 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2081 ntohl (mp->weight), mp->is_local_numa);
2084 static void vl_api_sw_interface_slave_details_t_handler_json
2085 (vl_api_sw_interface_slave_details_t * mp)
2087 vat_main_t *vam = &vat_main;
2088 vat_json_node_t *node = NULL;
2090 if (VAT_JSON_ARRAY != vam->json_tree.type)
2092 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2093 vat_json_init_array (&vam->json_tree);
2095 node = vat_json_array_add (&vam->json_tree);
2097 vat_json_init_object (node);
2098 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2099 vat_json_object_add_string_copy (node, "interface_name",
2100 mp->interface_name);
2101 vat_json_object_add_uint (node, "passive", mp->is_passive);
2102 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2103 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2104 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2108 api_sw_interface_slave_dump (vat_main_t * vam)
2110 unformat_input_t *i = vam->input;
2111 vl_api_sw_interface_slave_dump_t *mp;
2112 vl_api_control_ping_t *mp_ping;
2113 u32 sw_if_index = ~0;
2114 u8 sw_if_index_set = 0;
2117 /* Parse args required to build the message */
2118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2120 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2121 sw_if_index_set = 1;
2122 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2123 sw_if_index_set = 1;
2128 if (sw_if_index_set == 0)
2130 errmsg ("missing vpp interface name. ");
2135 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2136 "slave interface name", "sw_if_index", "passive", "long_timeout",
2137 "weight", "local numa");
2139 /* Get list of bond interfaces */
2140 M (SW_INTERFACE_SLAVE_DUMP, mp);
2141 mp->sw_if_index = ntohl (sw_if_index);
2144 /* Use a control ping for synchronization */
2145 MPING (CONTROL_PING, mp_ping);
2152 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2153 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2155 vat_main_t *vam = &vat_main;
2156 i32 retval = ntohl (mp->retval);
2157 if (vam->async_mode)
2159 vam->async_errors += (retval < 0);
2163 vam->retval = retval;
2164 vam->sw_if_index = ntohl (mp->sw_if_index);
2165 vam->result_ready = 1;
2167 vam->regenerate_interface_table = 1;
2170 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2171 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2173 vat_main_t *vam = &vat_main;
2174 vat_json_node_t node;
2176 vat_json_init_object (&node);
2177 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2178 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2179 ntohl (mp->sw_if_index));
2181 vat_json_print (vam->ofp, &node);
2182 vat_json_free (&node);
2184 vam->retval = ntohl (mp->retval);
2185 vam->result_ready = 1;
2188 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2189 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2191 vat_main_t *vam = &vat_main;
2192 i32 retval = ntohl (mp->retval);
2193 if (vam->async_mode)
2195 vam->async_errors += (retval < 0);
2199 vam->retval = retval;
2200 vam->sw_if_index = ntohl (mp->sw_if_index);
2201 vam->result_ready = 1;
2205 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2206 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2208 vat_main_t *vam = &vat_main;
2209 vat_json_node_t node;
2211 vat_json_init_object (&node);
2212 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2213 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2215 vat_json_print (vam->ofp, &node);
2216 vat_json_free (&node);
2218 vam->retval = ntohl (mp->retval);
2219 vam->result_ready = 1;
2222 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2223 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2225 vat_main_t *vam = &vat_main;
2226 i32 retval = ntohl (mp->retval);
2227 if (vam->async_mode)
2229 vam->async_errors += (retval < 0);
2233 vam->retval = retval;
2234 vam->result_ready = 1;
2238 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2239 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2241 vat_main_t *vam = &vat_main;
2242 vat_json_node_t node;
2244 vat_json_init_object (&node);
2245 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2246 vat_json_object_add_uint (&node, "fwd_entry_index",
2247 clib_net_to_host_u32 (mp->fwd_entry_index));
2249 vat_json_print (vam->ofp, &node);
2250 vat_json_free (&node);
2252 vam->retval = ntohl (mp->retval);
2253 vam->result_ready = 1;
2257 format_lisp_transport_protocol (u8 * s, va_list * args)
2259 u32 proto = va_arg (*args, u32);
2264 return format (s, "udp");
2266 return format (s, "api");
2273 static void vl_api_one_get_transport_protocol_reply_t_handler
2274 (vl_api_one_get_transport_protocol_reply_t * mp)
2276 vat_main_t *vam = &vat_main;
2277 i32 retval = ntohl (mp->retval);
2278 if (vam->async_mode)
2280 vam->async_errors += (retval < 0);
2284 u32 proto = mp->protocol;
2285 print (vam->ofp, "Transport protocol: %U",
2286 format_lisp_transport_protocol, proto);
2287 vam->retval = retval;
2288 vam->result_ready = 1;
2292 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2293 (vl_api_one_get_transport_protocol_reply_t * mp)
2295 vat_main_t *vam = &vat_main;
2296 vat_json_node_t node;
2299 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2302 vat_json_init_object (&node);
2303 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2304 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2307 vat_json_print (vam->ofp, &node);
2308 vat_json_free (&node);
2310 vam->retval = ntohl (mp->retval);
2311 vam->result_ready = 1;
2314 static void vl_api_one_add_del_locator_set_reply_t_handler
2315 (vl_api_one_add_del_locator_set_reply_t * mp)
2317 vat_main_t *vam = &vat_main;
2318 i32 retval = ntohl (mp->retval);
2319 if (vam->async_mode)
2321 vam->async_errors += (retval < 0);
2325 vam->retval = retval;
2326 vam->result_ready = 1;
2330 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2331 (vl_api_one_add_del_locator_set_reply_t * mp)
2333 vat_main_t *vam = &vat_main;
2334 vat_json_node_t node;
2336 vat_json_init_object (&node);
2337 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2338 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2340 vat_json_print (vam->ofp, &node);
2341 vat_json_free (&node);
2343 vam->retval = ntohl (mp->retval);
2344 vam->result_ready = 1;
2347 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2348 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2350 vat_main_t *vam = &vat_main;
2351 i32 retval = ntohl (mp->retval);
2352 if (vam->async_mode)
2354 vam->async_errors += (retval < 0);
2358 vam->retval = retval;
2359 vam->sw_if_index = ntohl (mp->sw_if_index);
2360 vam->result_ready = 1;
2362 vam->regenerate_interface_table = 1;
2365 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2366 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2368 vat_main_t *vam = &vat_main;
2369 vat_json_node_t node;
2371 vat_json_init_object (&node);
2372 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2373 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2375 vat_json_print (vam->ofp, &node);
2376 vat_json_free (&node);
2378 vam->retval = ntohl (mp->retval);
2379 vam->result_ready = 1;
2382 static void vl_api_vxlan_offload_rx_reply_t_handler
2383 (vl_api_vxlan_offload_rx_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 i32 retval = ntohl (mp->retval);
2387 if (vam->async_mode)
2389 vam->async_errors += (retval < 0);
2393 vam->retval = retval;
2394 vam->result_ready = 1;
2398 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2399 (vl_api_vxlan_offload_rx_reply_t * mp)
2401 vat_main_t *vam = &vat_main;
2402 vat_json_node_t node;
2404 vat_json_init_object (&node);
2405 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2407 vat_json_print (vam->ofp, &node);
2408 vat_json_free (&node);
2410 vam->retval = ntohl (mp->retval);
2411 vam->result_ready = 1;
2414 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2415 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2417 vat_main_t *vam = &vat_main;
2418 i32 retval = ntohl (mp->retval);
2419 if (vam->async_mode)
2421 vam->async_errors += (retval < 0);
2425 vam->retval = retval;
2426 vam->sw_if_index = ntohl (mp->sw_if_index);
2427 vam->result_ready = 1;
2431 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2432 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2434 vat_main_t *vam = &vat_main;
2435 vat_json_node_t node;
2437 vat_json_init_object (&node);
2438 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2439 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2441 vat_json_print (vam->ofp, &node);
2442 vat_json_free (&node);
2444 vam->retval = ntohl (mp->retval);
2445 vam->result_ready = 1;
2448 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2449 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2451 vat_main_t *vam = &vat_main;
2452 i32 retval = ntohl (mp->retval);
2453 if (vam->async_mode)
2455 vam->async_errors += (retval < 0);
2459 vam->retval = retval;
2460 vam->sw_if_index = ntohl (mp->sw_if_index);
2461 vam->result_ready = 1;
2463 vam->regenerate_interface_table = 1;
2466 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2467 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2469 vat_main_t *vam = &vat_main;
2470 vat_json_node_t node;
2472 vat_json_init_object (&node);
2473 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2474 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2476 vat_json_print (vam->ofp, &node);
2477 vat_json_free (&node);
2479 vam->retval = ntohl (mp->retval);
2480 vam->result_ready = 1;
2483 static void vl_api_gre_tunnel_add_del_reply_t_handler
2484 (vl_api_gre_tunnel_add_del_reply_t * mp)
2486 vat_main_t *vam = &vat_main;
2487 i32 retval = ntohl (mp->retval);
2488 if (vam->async_mode)
2490 vam->async_errors += (retval < 0);
2494 vam->retval = retval;
2495 vam->sw_if_index = ntohl (mp->sw_if_index);
2496 vam->result_ready = 1;
2500 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2501 (vl_api_gre_tunnel_add_del_reply_t * mp)
2503 vat_main_t *vam = &vat_main;
2504 vat_json_node_t node;
2506 vat_json_init_object (&node);
2507 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2508 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2510 vat_json_print (vam->ofp, &node);
2511 vat_json_free (&node);
2513 vam->retval = ntohl (mp->retval);
2514 vam->result_ready = 1;
2517 static void vl_api_create_vhost_user_if_reply_t_handler
2518 (vl_api_create_vhost_user_if_reply_t * mp)
2520 vat_main_t *vam = &vat_main;
2521 i32 retval = ntohl (mp->retval);
2522 if (vam->async_mode)
2524 vam->async_errors += (retval < 0);
2528 vam->retval = retval;
2529 vam->sw_if_index = ntohl (mp->sw_if_index);
2530 vam->result_ready = 1;
2532 vam->regenerate_interface_table = 1;
2535 static void vl_api_create_vhost_user_if_reply_t_handler_json
2536 (vl_api_create_vhost_user_if_reply_t * mp)
2538 vat_main_t *vam = &vat_main;
2539 vat_json_node_t node;
2541 vat_json_init_object (&node);
2542 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2543 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2545 vat_json_print (vam->ofp, &node);
2546 vat_json_free (&node);
2548 vam->retval = ntohl (mp->retval);
2549 vam->result_ready = 1;
2552 static void vl_api_ip_address_details_t_handler
2553 (vl_api_ip_address_details_t * mp)
2555 vat_main_t *vam = &vat_main;
2556 static ip_address_details_t empty_ip_address_details = { {0} };
2557 ip_address_details_t *address = NULL;
2558 ip_details_t *current_ip_details = NULL;
2559 ip_details_t *details = NULL;
2561 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2563 if (!details || vam->current_sw_if_index >= vec_len (details)
2564 || !details[vam->current_sw_if_index].present)
2566 errmsg ("ip address details arrived but not stored");
2567 errmsg ("ip_dump should be called first");
2571 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2573 #define addresses (current_ip_details->addr)
2575 vec_validate_init_empty (addresses, vec_len (addresses),
2576 empty_ip_address_details);
2578 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2580 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2581 address->prefix_length = mp->prefix.len;
2585 static void vl_api_ip_address_details_t_handler_json
2586 (vl_api_ip_address_details_t * mp)
2588 vat_main_t *vam = &vat_main;
2589 vat_json_node_t *node = NULL;
2591 if (VAT_JSON_ARRAY != vam->json_tree.type)
2593 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2594 vat_json_init_array (&vam->json_tree);
2596 node = vat_json_array_add (&vam->json_tree);
2598 vat_json_init_object (node);
2599 vat_json_object_add_prefix (node, &mp->prefix);
2603 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 static ip_details_t empty_ip_details = { 0 };
2607 ip_details_t *ip = NULL;
2608 u32 sw_if_index = ~0;
2610 sw_if_index = ntohl (mp->sw_if_index);
2612 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2613 sw_if_index, empty_ip_details);
2615 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2622 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2624 vat_main_t *vam = &vat_main;
2626 if (VAT_JSON_ARRAY != vam->json_tree.type)
2628 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2629 vat_json_init_array (&vam->json_tree);
2631 vat_json_array_add_uint (&vam->json_tree,
2632 clib_net_to_host_u32 (mp->sw_if_index));
2635 static void vl_api_get_first_msg_id_reply_t_handler
2636 (vl_api_get_first_msg_id_reply_t * mp)
2638 vat_main_t *vam = &vat_main;
2639 i32 retval = ntohl (mp->retval);
2641 if (vam->async_mode)
2643 vam->async_errors += (retval < 0);
2647 vam->retval = retval;
2648 vam->result_ready = 1;
2652 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2656 static void vl_api_get_first_msg_id_reply_t_handler_json
2657 (vl_api_get_first_msg_id_reply_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vat_json_node_t node;
2662 vat_json_init_object (&node);
2663 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2664 vat_json_object_add_uint (&node, "first_msg_id",
2665 (uint) ntohs (mp->first_msg_id));
2667 vat_json_print (vam->ofp, &node);
2668 vat_json_free (&node);
2670 vam->retval = ntohl (mp->retval);
2671 vam->result_ready = 1;
2674 static void vl_api_get_node_graph_reply_t_handler
2675 (vl_api_get_node_graph_reply_t * mp)
2677 vat_main_t *vam = &vat_main;
2678 i32 retval = ntohl (mp->retval);
2679 u8 *pvt_copy, *reply;
2684 if (vam->async_mode)
2686 vam->async_errors += (retval < 0);
2690 vam->retval = retval;
2691 vam->result_ready = 1;
2694 /* "Should never happen..." */
2698 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2699 pvt_copy = vec_dup (reply);
2701 /* Toss the shared-memory original... */
2702 oldheap = vl_msg_push_heap ();
2706 vl_msg_pop_heap (oldheap);
2708 if (vam->graph_nodes)
2710 hash_free (vam->graph_node_index_by_name);
2712 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2714 node = vam->graph_nodes[0][i];
2715 vec_free (node->name);
2716 vec_free (node->next_nodes);
2719 vec_free (vam->graph_nodes[0]);
2720 vec_free (vam->graph_nodes);
2723 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2724 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2725 vec_free (pvt_copy);
2727 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2729 node = vam->graph_nodes[0][i];
2730 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2734 static void vl_api_get_node_graph_reply_t_handler_json
2735 (vl_api_get_node_graph_reply_t * mp)
2737 vat_main_t *vam = &vat_main;
2739 vat_json_node_t node;
2742 /* $$$$ make this real? */
2743 vat_json_init_object (&node);
2744 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2745 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2747 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2749 /* Toss the shared-memory original... */
2750 oldheap = vl_msg_push_heap ();
2754 vl_msg_pop_heap (oldheap);
2756 vat_json_print (vam->ofp, &node);
2757 vat_json_free (&node);
2759 vam->retval = ntohl (mp->retval);
2760 vam->result_ready = 1;
2764 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2766 vat_main_t *vam = &vat_main;
2771 s = format (s, "%=16d%=16d%=16d",
2772 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2776 s = format (s, "%=16U%=16d%=16d",
2777 mp->is_ipv6 ? format_ip6_address :
2779 mp->ip_address, mp->priority, mp->weight);
2782 print (vam->ofp, "%v", s);
2787 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2789 vat_main_t *vam = &vat_main;
2790 vat_json_node_t *node = NULL;
2791 struct in6_addr ip6;
2794 if (VAT_JSON_ARRAY != vam->json_tree.type)
2796 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2797 vat_json_init_array (&vam->json_tree);
2799 node = vat_json_array_add (&vam->json_tree);
2800 vat_json_init_object (node);
2802 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2803 vat_json_object_add_uint (node, "priority", mp->priority);
2804 vat_json_object_add_uint (node, "weight", mp->weight);
2807 vat_json_object_add_uint (node, "sw_if_index",
2808 clib_net_to_host_u32 (mp->sw_if_index));
2813 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2814 vat_json_object_add_ip6 (node, "address", ip6);
2818 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2819 vat_json_object_add_ip4 (node, "address", ip4);
2825 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2828 vat_main_t *vam = &vat_main;
2831 ls_name = format (0, "%s", mp->ls_name);
2833 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2839 vl_api_one_locator_set_details_t_handler_json
2840 (vl_api_one_locator_set_details_t * mp)
2842 vat_main_t *vam = &vat_main;
2843 vat_json_node_t *node = 0;
2846 ls_name = format (0, "%s", mp->ls_name);
2847 vec_add1 (ls_name, 0);
2849 if (VAT_JSON_ARRAY != vam->json_tree.type)
2851 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2852 vat_json_init_array (&vam->json_tree);
2854 node = vat_json_array_add (&vam->json_tree);
2856 vat_json_init_object (node);
2857 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2858 vat_json_object_add_uint (node, "ls_index",
2859 clib_net_to_host_u32 (mp->ls_index));
2867 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2870 unformat_nsh_address (unformat_input_t * input, va_list * args)
2872 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2873 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2877 format_nsh_address_vat (u8 * s, va_list * args)
2879 nsh_t *a = va_arg (*args, nsh_t *);
2880 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2884 format_lisp_flat_eid (u8 * s, va_list * args)
2886 u32 type = va_arg (*args, u32);
2887 u8 *eid = va_arg (*args, u8 *);
2888 u32 eid_len = va_arg (*args, u32);
2893 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2895 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2897 return format (s, "%U", format_ethernet_address, eid);
2899 return format (s, "%U", format_nsh_address_vat, eid);
2905 format_lisp_eid_vat (u8 * s, va_list * args)
2907 u32 type = va_arg (*args, u32);
2908 u8 *eid = va_arg (*args, u8 *);
2909 u32 eid_len = va_arg (*args, u32);
2910 u8 *seid = va_arg (*args, u8 *);
2911 u32 seid_len = va_arg (*args, u32);
2912 u32 is_src_dst = va_arg (*args, u32);
2915 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2917 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2923 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2925 vat_main_t *vam = &vat_main;
2926 u8 *s = 0, *eid = 0;
2928 if (~0 == mp->locator_set_index)
2929 s = format (0, "action: %d", mp->action);
2931 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2933 eid = format (0, "%U", format_lisp_eid_vat,
2937 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2940 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2941 clib_net_to_host_u32 (mp->vni),
2943 mp->is_local ? "local" : "remote",
2944 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2945 clib_net_to_host_u16 (mp->key_id), mp->key);
2952 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2955 vat_main_t *vam = &vat_main;
2956 vat_json_node_t *node = 0;
2959 if (VAT_JSON_ARRAY != vam->json_tree.type)
2961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2962 vat_json_init_array (&vam->json_tree);
2964 node = vat_json_array_add (&vam->json_tree);
2966 vat_json_init_object (node);
2967 if (~0 == mp->locator_set_index)
2968 vat_json_object_add_uint (node, "action", mp->action);
2970 vat_json_object_add_uint (node, "locator_set_index",
2971 clib_net_to_host_u32 (mp->locator_set_index));
2973 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2974 if (mp->eid_type == 3)
2976 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
2977 vat_json_init_object (nsh_json);
2978 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
2979 vat_json_object_add_uint (nsh_json, "spi",
2980 clib_net_to_host_u32 (nsh->spi));
2981 vat_json_object_add_uint (nsh_json, "si", nsh->si);
2985 eid = format (0, "%U", format_lisp_eid_vat,
2989 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2991 vat_json_object_add_string_copy (node, "eid", eid);
2994 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2995 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2996 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3000 vat_json_object_add_uint (node, "key_id",
3001 clib_net_to_host_u16 (mp->key_id));
3002 vat_json_object_add_string_copy (node, "key", mp->key);
3007 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3009 vat_main_t *vam = &vat_main;
3010 u8 *seid = 0, *deid = 0;
3011 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3013 deid = format (0, "%U", format_lisp_eid_vat,
3014 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3016 seid = format (0, "%U", format_lisp_eid_vat,
3017 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3023 format_ip_address_fcn = format_ip4_address;
3025 format_ip_address_fcn = format_ip6_address;
3028 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3029 clib_net_to_host_u32 (mp->vni),
3031 format_ip_address_fcn, mp->lloc,
3032 format_ip_address_fcn, mp->rloc,
3033 clib_net_to_host_u32 (mp->pkt_count),
3034 clib_net_to_host_u32 (mp->bytes));
3041 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3043 struct in6_addr ip6;
3045 vat_main_t *vam = &vat_main;
3046 vat_json_node_t *node = 0;
3047 u8 *deid = 0, *seid = 0;
3049 if (VAT_JSON_ARRAY != vam->json_tree.type)
3051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3052 vat_json_init_array (&vam->json_tree);
3054 node = vat_json_array_add (&vam->json_tree);
3056 vat_json_init_object (node);
3057 deid = format (0, "%U", format_lisp_eid_vat,
3058 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3060 seid = format (0, "%U", format_lisp_eid_vat,
3061 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3066 vat_json_object_add_string_copy (node, "seid", seid);
3067 vat_json_object_add_string_copy (node, "deid", deid);
3068 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3072 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3073 vat_json_object_add_ip4 (node, "lloc", ip4);
3074 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3075 vat_json_object_add_ip4 (node, "rloc", ip4);
3079 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3080 vat_json_object_add_ip6 (node, "lloc", ip6);
3081 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3082 vat_json_object_add_ip6 (node, "rloc", ip6);
3084 vat_json_object_add_uint (node, "pkt_count",
3085 clib_net_to_host_u32 (mp->pkt_count));
3086 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3093 vl_api_one_eid_table_map_details_t_handler
3094 (vl_api_one_eid_table_map_details_t * mp)
3096 vat_main_t *vam = &vat_main;
3098 u8 *line = format (0, "%=10d%=10d",
3099 clib_net_to_host_u32 (mp->vni),
3100 clib_net_to_host_u32 (mp->dp_table));
3101 print (vam->ofp, "%v", line);
3106 vl_api_one_eid_table_map_details_t_handler_json
3107 (vl_api_one_eid_table_map_details_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t *node = NULL;
3112 if (VAT_JSON_ARRAY != vam->json_tree.type)
3114 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3115 vat_json_init_array (&vam->json_tree);
3117 node = vat_json_array_add (&vam->json_tree);
3118 vat_json_init_object (node);
3119 vat_json_object_add_uint (node, "dp_table",
3120 clib_net_to_host_u32 (mp->dp_table));
3121 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3125 vl_api_one_eid_table_vni_details_t_handler
3126 (vl_api_one_eid_table_vni_details_t * mp)
3128 vat_main_t *vam = &vat_main;
3130 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3131 print (vam->ofp, "%v", line);
3136 vl_api_one_eid_table_vni_details_t_handler_json
3137 (vl_api_one_eid_table_vni_details_t * mp)
3139 vat_main_t *vam = &vat_main;
3140 vat_json_node_t *node = NULL;
3142 if (VAT_JSON_ARRAY != vam->json_tree.type)
3144 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3145 vat_json_init_array (&vam->json_tree);
3147 node = vat_json_array_add (&vam->json_tree);
3148 vat_json_init_object (node);
3149 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3153 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3154 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3156 vat_main_t *vam = &vat_main;
3157 int retval = clib_net_to_host_u32 (mp->retval);
3159 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3160 print (vam->ofp, "fallback threshold value: %d", mp->value);
3162 vam->retval = retval;
3163 vam->result_ready = 1;
3167 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3168 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3170 vat_main_t *vam = &vat_main;
3171 vat_json_node_t _node, *node = &_node;
3172 int retval = clib_net_to_host_u32 (mp->retval);
3174 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3175 vat_json_init_object (node);
3176 vat_json_object_add_uint (node, "value", mp->value);
3178 vat_json_print (vam->ofp, node);
3179 vat_json_free (node);
3181 vam->retval = retval;
3182 vam->result_ready = 1;
3186 vl_api_show_one_map_register_state_reply_t_handler
3187 (vl_api_show_one_map_register_state_reply_t * mp)
3189 vat_main_t *vam = &vat_main;
3190 int retval = clib_net_to_host_u32 (mp->retval);
3192 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3194 vam->retval = retval;
3195 vam->result_ready = 1;
3199 vl_api_show_one_map_register_state_reply_t_handler_json
3200 (vl_api_show_one_map_register_state_reply_t * mp)
3202 vat_main_t *vam = &vat_main;
3203 vat_json_node_t _node, *node = &_node;
3204 int retval = clib_net_to_host_u32 (mp->retval);
3206 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3208 vat_json_init_object (node);
3209 vat_json_object_add_string_copy (node, "state", s);
3211 vat_json_print (vam->ofp, node);
3212 vat_json_free (node);
3214 vam->retval = retval;
3215 vam->result_ready = 1;
3220 vl_api_show_one_rloc_probe_state_reply_t_handler
3221 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3223 vat_main_t *vam = &vat_main;
3224 int retval = clib_net_to_host_u32 (mp->retval);
3229 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3231 vam->retval = retval;
3232 vam->result_ready = 1;
3236 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3237 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3239 vat_main_t *vam = &vat_main;
3240 vat_json_node_t _node, *node = &_node;
3241 int retval = clib_net_to_host_u32 (mp->retval);
3243 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3244 vat_json_init_object (node);
3245 vat_json_object_add_string_copy (node, "state", s);
3247 vat_json_print (vam->ofp, node);
3248 vat_json_free (node);
3250 vam->retval = retval;
3251 vam->result_ready = 1;
3256 vl_api_show_one_stats_enable_disable_reply_t_handler
3257 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3259 vat_main_t *vam = &vat_main;
3260 int retval = clib_net_to_host_u32 (mp->retval);
3265 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3267 vam->retval = retval;
3268 vam->result_ready = 1;
3272 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3273 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3275 vat_main_t *vam = &vat_main;
3276 vat_json_node_t _node, *node = &_node;
3277 int retval = clib_net_to_host_u32 (mp->retval);
3279 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3280 vat_json_init_object (node);
3281 vat_json_object_add_string_copy (node, "state", s);
3283 vat_json_print (vam->ofp, node);
3284 vat_json_free (node);
3286 vam->retval = retval;
3287 vam->result_ready = 1;
3292 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3294 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3295 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3296 e->vni = clib_net_to_host_u32 (e->vni);
3300 gpe_fwd_entries_get_reply_t_net_to_host
3301 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3305 mp->count = clib_net_to_host_u32 (mp->count);
3306 for (i = 0; i < mp->count; i++)
3308 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3313 format_gpe_encap_mode (u8 * s, va_list * args)
3315 u32 mode = va_arg (*args, u32);
3320 return format (s, "lisp");
3322 return format (s, "vxlan");
3328 vl_api_gpe_get_encap_mode_reply_t_handler
3329 (vl_api_gpe_get_encap_mode_reply_t * mp)
3331 vat_main_t *vam = &vat_main;
3333 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3334 vam->retval = ntohl (mp->retval);
3335 vam->result_ready = 1;
3339 vl_api_gpe_get_encap_mode_reply_t_handler_json
3340 (vl_api_gpe_get_encap_mode_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 vat_json_node_t node;
3345 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3346 vec_add1 (encap_mode, 0);
3348 vat_json_init_object (&node);
3349 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3351 vec_free (encap_mode);
3352 vat_json_print (vam->ofp, &node);
3353 vat_json_free (&node);
3355 vam->retval = ntohl (mp->retval);
3356 vam->result_ready = 1;
3360 vl_api_gpe_fwd_entry_path_details_t_handler
3361 (vl_api_gpe_fwd_entry_path_details_t * mp)
3363 vat_main_t *vam = &vat_main;
3364 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3366 if (mp->lcl_loc.is_ip4)
3367 format_ip_address_fcn = format_ip4_address;
3369 format_ip_address_fcn = format_ip6_address;
3371 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3372 format_ip_address_fcn, &mp->lcl_loc,
3373 format_ip_address_fcn, &mp->rmt_loc);
3377 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3379 struct in6_addr ip6;
3384 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3385 vat_json_object_add_ip4 (n, "address", ip4);
3389 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3390 vat_json_object_add_ip6 (n, "address", ip6);
3392 vat_json_object_add_uint (n, "weight", loc->weight);
3396 vl_api_gpe_fwd_entry_path_details_t_handler_json
3397 (vl_api_gpe_fwd_entry_path_details_t * mp)
3399 vat_main_t *vam = &vat_main;
3400 vat_json_node_t *node = NULL;
3401 vat_json_node_t *loc_node;
3403 if (VAT_JSON_ARRAY != vam->json_tree.type)
3405 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3406 vat_json_init_array (&vam->json_tree);
3408 node = vat_json_array_add (&vam->json_tree);
3409 vat_json_init_object (node);
3411 loc_node = vat_json_object_add (node, "local_locator");
3412 vat_json_init_object (loc_node);
3413 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3415 loc_node = vat_json_object_add (node, "remote_locator");
3416 vat_json_init_object (loc_node);
3417 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3421 vl_api_gpe_fwd_entries_get_reply_t_handler
3422 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3424 vat_main_t *vam = &vat_main;
3426 int retval = clib_net_to_host_u32 (mp->retval);
3427 vl_api_gpe_fwd_entry_t *e;
3432 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3434 for (i = 0; i < mp->count; i++)
3436 e = &mp->entries[i];
3437 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3438 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3439 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3443 vam->retval = retval;
3444 vam->result_ready = 1;
3448 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3449 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3452 vat_main_t *vam = &vat_main;
3453 vat_json_node_t *e = 0, root;
3455 int retval = clib_net_to_host_u32 (mp->retval);
3456 vl_api_gpe_fwd_entry_t *fwd;
3461 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3462 vat_json_init_array (&root);
3464 for (i = 0; i < mp->count; i++)
3466 e = vat_json_array_add (&root);
3467 fwd = &mp->entries[i];
3469 vat_json_init_object (e);
3470 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3471 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3472 vat_json_object_add_int (e, "vni", fwd->vni);
3473 vat_json_object_add_int (e, "action", fwd->action);
3475 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3476 fwd->leid_prefix_len);
3478 vat_json_object_add_string_copy (e, "leid", s);
3481 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3482 fwd->reid_prefix_len);
3484 vat_json_object_add_string_copy (e, "reid", s);
3488 vat_json_print (vam->ofp, &root);
3489 vat_json_free (&root);
3492 vam->retval = retval;
3493 vam->result_ready = 1;
3497 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3498 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3500 vat_main_t *vam = &vat_main;
3502 int retval = clib_net_to_host_u32 (mp->retval);
3503 vl_api_gpe_native_fwd_rpath_t *r;
3508 n = clib_net_to_host_u32 (mp->count);
3510 for (i = 0; i < n; i++)
3512 r = &mp->entries[i];
3513 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3514 clib_net_to_host_u32 (r->fib_index),
3515 clib_net_to_host_u32 (r->nh_sw_if_index),
3516 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3520 vam->retval = retval;
3521 vam->result_ready = 1;
3525 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3526 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3528 vat_main_t *vam = &vat_main;
3529 vat_json_node_t root, *e;
3531 int retval = clib_net_to_host_u32 (mp->retval);
3532 vl_api_gpe_native_fwd_rpath_t *r;
3538 n = clib_net_to_host_u32 (mp->count);
3539 vat_json_init_array (&root);
3541 for (i = 0; i < n; i++)
3543 e = vat_json_array_add (&root);
3544 vat_json_init_object (e);
3545 r = &mp->entries[i];
3547 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3550 vat_json_object_add_string_copy (e, "ip4", s);
3553 vat_json_object_add_uint (e, "fib_index",
3554 clib_net_to_host_u32 (r->fib_index));
3555 vat_json_object_add_uint (e, "nh_sw_if_index",
3556 clib_net_to_host_u32 (r->nh_sw_if_index));
3559 vat_json_print (vam->ofp, &root);
3560 vat_json_free (&root);
3563 vam->retval = retval;
3564 vam->result_ready = 1;
3568 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3569 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3571 vat_main_t *vam = &vat_main;
3573 int retval = clib_net_to_host_u32 (mp->retval);
3578 n = clib_net_to_host_u32 (mp->count);
3580 for (i = 0; i < n; i++)
3581 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3584 vam->retval = retval;
3585 vam->result_ready = 1;
3589 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3590 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3592 vat_main_t *vam = &vat_main;
3593 vat_json_node_t root;
3595 int retval = clib_net_to_host_u32 (mp->retval);
3600 n = clib_net_to_host_u32 (mp->count);
3601 vat_json_init_array (&root);
3603 for (i = 0; i < n; i++)
3604 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3606 vat_json_print (vam->ofp, &root);
3607 vat_json_free (&root);
3610 vam->retval = retval;
3611 vam->result_ready = 1;
3615 vl_api_one_ndp_entries_get_reply_t_handler
3616 (vl_api_one_ndp_entries_get_reply_t * mp)
3618 vat_main_t *vam = &vat_main;
3620 int retval = clib_net_to_host_u32 (mp->retval);
3625 n = clib_net_to_host_u32 (mp->count);
3627 for (i = 0; i < n; i++)
3628 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3629 format_ethernet_address, mp->entries[i].mac);
3632 vam->retval = retval;
3633 vam->result_ready = 1;
3637 vl_api_one_ndp_entries_get_reply_t_handler_json
3638 (vl_api_one_ndp_entries_get_reply_t * mp)
3641 vat_main_t *vam = &vat_main;
3642 vat_json_node_t *e = 0, root;
3644 int retval = clib_net_to_host_u32 (mp->retval);
3645 vl_api_one_ndp_entry_t *arp_entry;
3650 n = clib_net_to_host_u32 (mp->count);
3651 vat_json_init_array (&root);
3653 for (i = 0; i < n; i++)
3655 e = vat_json_array_add (&root);
3656 arp_entry = &mp->entries[i];
3658 vat_json_init_object (e);
3659 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3662 vat_json_object_add_string_copy (e, "mac", s);
3665 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3667 vat_json_object_add_string_copy (e, "ip6", s);
3671 vat_json_print (vam->ofp, &root);
3672 vat_json_free (&root);
3675 vam->retval = retval;
3676 vam->result_ready = 1;
3680 vl_api_one_l2_arp_entries_get_reply_t_handler
3681 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3683 vat_main_t *vam = &vat_main;
3685 int retval = clib_net_to_host_u32 (mp->retval);
3690 n = clib_net_to_host_u32 (mp->count);
3692 for (i = 0; i < n; i++)
3693 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3694 format_ethernet_address, mp->entries[i].mac);
3697 vam->retval = retval;
3698 vam->result_ready = 1;
3702 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3703 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 vat_json_node_t *e = 0, root;
3709 int retval = clib_net_to_host_u32 (mp->retval);
3710 vl_api_one_l2_arp_entry_t *arp_entry;
3715 n = clib_net_to_host_u32 (mp->count);
3716 vat_json_init_array (&root);
3718 for (i = 0; i < n; i++)
3720 e = vat_json_array_add (&root);
3721 arp_entry = &mp->entries[i];
3723 vat_json_init_object (e);
3724 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3727 vat_json_object_add_string_copy (e, "mac", s);
3730 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3732 vat_json_object_add_string_copy (e, "ip4", s);
3736 vat_json_print (vam->ofp, &root);
3737 vat_json_free (&root);
3740 vam->retval = retval;
3741 vam->result_ready = 1;
3745 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3747 vat_main_t *vam = &vat_main;
3749 int retval = clib_net_to_host_u32 (mp->retval);
3754 n = clib_net_to_host_u32 (mp->count);
3756 for (i = 0; i < n; i++)
3758 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3762 vam->retval = retval;
3763 vam->result_ready = 1;
3767 vl_api_one_ndp_bd_get_reply_t_handler_json
3768 (vl_api_one_ndp_bd_get_reply_t * mp)
3770 vat_main_t *vam = &vat_main;
3771 vat_json_node_t root;
3773 int retval = clib_net_to_host_u32 (mp->retval);
3778 n = clib_net_to_host_u32 (mp->count);
3779 vat_json_init_array (&root);
3781 for (i = 0; i < n; i++)
3783 vat_json_array_add_uint (&root,
3784 clib_net_to_host_u32 (mp->bridge_domains[i]));
3787 vat_json_print (vam->ofp, &root);
3788 vat_json_free (&root);
3791 vam->retval = retval;
3792 vam->result_ready = 1;
3796 vl_api_one_l2_arp_bd_get_reply_t_handler
3797 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3799 vat_main_t *vam = &vat_main;
3801 int retval = clib_net_to_host_u32 (mp->retval);
3806 n = clib_net_to_host_u32 (mp->count);
3808 for (i = 0; i < n; i++)
3810 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3814 vam->retval = retval;
3815 vam->result_ready = 1;
3819 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3820 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3822 vat_main_t *vam = &vat_main;
3823 vat_json_node_t root;
3825 int retval = clib_net_to_host_u32 (mp->retval);
3830 n = clib_net_to_host_u32 (mp->count);
3831 vat_json_init_array (&root);
3833 for (i = 0; i < n; i++)
3835 vat_json_array_add_uint (&root,
3836 clib_net_to_host_u32 (mp->bridge_domains[i]));
3839 vat_json_print (vam->ofp, &root);
3840 vat_json_free (&root);
3843 vam->retval = retval;
3844 vam->result_ready = 1;
3848 vl_api_one_adjacencies_get_reply_t_handler
3849 (vl_api_one_adjacencies_get_reply_t * mp)
3851 vat_main_t *vam = &vat_main;
3853 int retval = clib_net_to_host_u32 (mp->retval);
3854 vl_api_one_adjacency_t *a;
3859 n = clib_net_to_host_u32 (mp->count);
3861 for (i = 0; i < n; i++)
3863 a = &mp->adjacencies[i];
3864 print (vam->ofp, "%U %40U",
3865 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3866 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3870 vam->retval = retval;
3871 vam->result_ready = 1;
3875 vl_api_one_adjacencies_get_reply_t_handler_json
3876 (vl_api_one_adjacencies_get_reply_t * mp)
3879 vat_main_t *vam = &vat_main;
3880 vat_json_node_t *e = 0, root;
3882 int retval = clib_net_to_host_u32 (mp->retval);
3883 vl_api_one_adjacency_t *a;
3888 n = clib_net_to_host_u32 (mp->count);
3889 vat_json_init_array (&root);
3891 for (i = 0; i < n; i++)
3893 e = vat_json_array_add (&root);
3894 a = &mp->adjacencies[i];
3896 vat_json_init_object (e);
3897 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3898 a->leid_prefix_len);
3900 vat_json_object_add_string_copy (e, "leid", s);
3903 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3904 a->reid_prefix_len);
3906 vat_json_object_add_string_copy (e, "reid", s);
3910 vat_json_print (vam->ofp, &root);
3911 vat_json_free (&root);
3914 vam->retval = retval;
3915 vam->result_ready = 1;
3919 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3921 vat_main_t *vam = &vat_main;
3923 print (vam->ofp, "%=20U",
3924 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3929 vl_api_one_map_server_details_t_handler_json
3930 (vl_api_one_map_server_details_t * mp)
3932 vat_main_t *vam = &vat_main;
3933 vat_json_node_t *node = NULL;
3934 struct in6_addr ip6;
3937 if (VAT_JSON_ARRAY != vam->json_tree.type)
3939 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3940 vat_json_init_array (&vam->json_tree);
3942 node = vat_json_array_add (&vam->json_tree);
3944 vat_json_init_object (node);
3947 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3948 vat_json_object_add_ip6 (node, "map-server", ip6);
3952 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3953 vat_json_object_add_ip4 (node, "map-server", ip4);
3958 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3961 vat_main_t *vam = &vat_main;
3963 print (vam->ofp, "%=20U",
3964 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3969 vl_api_one_map_resolver_details_t_handler_json
3970 (vl_api_one_map_resolver_details_t * mp)
3972 vat_main_t *vam = &vat_main;
3973 vat_json_node_t *node = NULL;
3974 struct in6_addr ip6;
3977 if (VAT_JSON_ARRAY != vam->json_tree.type)
3979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3980 vat_json_init_array (&vam->json_tree);
3982 node = vat_json_array_add (&vam->json_tree);
3984 vat_json_init_object (node);
3987 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3988 vat_json_object_add_ip6 (node, "map resolver", ip6);
3992 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3993 vat_json_object_add_ip4 (node, "map resolver", ip4);
3998 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4000 vat_main_t *vam = &vat_main;
4001 i32 retval = ntohl (mp->retval);
4005 print (vam->ofp, "feature: %s\ngpe: %s",
4006 mp->feature_status ? "enabled" : "disabled",
4007 mp->gpe_status ? "enabled" : "disabled");
4010 vam->retval = retval;
4011 vam->result_ready = 1;
4015 vl_api_show_one_status_reply_t_handler_json
4016 (vl_api_show_one_status_reply_t * mp)
4018 vat_main_t *vam = &vat_main;
4019 vat_json_node_t node;
4020 u8 *gpe_status = NULL;
4021 u8 *feature_status = NULL;
4023 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4024 feature_status = format (0, "%s",
4025 mp->feature_status ? "enabled" : "disabled");
4026 vec_add1 (gpe_status, 0);
4027 vec_add1 (feature_status, 0);
4029 vat_json_init_object (&node);
4030 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4031 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4033 vec_free (gpe_status);
4034 vec_free (feature_status);
4036 vat_json_print (vam->ofp, &node);
4037 vat_json_free (&node);
4039 vam->retval = ntohl (mp->retval);
4040 vam->result_ready = 1;
4044 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4045 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4047 vat_main_t *vam = &vat_main;
4048 i32 retval = ntohl (mp->retval);
4052 print (vam->ofp, "%=20s", mp->locator_set_name);
4055 vam->retval = retval;
4056 vam->result_ready = 1;
4060 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4061 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4063 vat_main_t *vam = &vat_main;
4064 vat_json_node_t *node = NULL;
4066 if (VAT_JSON_ARRAY != vam->json_tree.type)
4068 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4069 vat_json_init_array (&vam->json_tree);
4071 node = vat_json_array_add (&vam->json_tree);
4073 vat_json_init_object (node);
4074 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4076 vat_json_print (vam->ofp, node);
4077 vat_json_free (node);
4079 vam->retval = ntohl (mp->retval);
4080 vam->result_ready = 1;
4084 format_lisp_map_request_mode (u8 * s, va_list * args)
4086 u32 mode = va_arg (*args, u32);
4091 return format (0, "dst-only");
4093 return format (0, "src-dst");
4099 vl_api_show_one_map_request_mode_reply_t_handler
4100 (vl_api_show_one_map_request_mode_reply_t * mp)
4102 vat_main_t *vam = &vat_main;
4103 i32 retval = ntohl (mp->retval);
4107 u32 mode = mp->mode;
4108 print (vam->ofp, "map_request_mode: %U",
4109 format_lisp_map_request_mode, mode);
4112 vam->retval = retval;
4113 vam->result_ready = 1;
4117 vl_api_show_one_map_request_mode_reply_t_handler_json
4118 (vl_api_show_one_map_request_mode_reply_t * mp)
4120 vat_main_t *vam = &vat_main;
4121 vat_json_node_t node;
4126 s = format (0, "%U", format_lisp_map_request_mode, mode);
4129 vat_json_init_object (&node);
4130 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4131 vat_json_print (vam->ofp, &node);
4132 vat_json_free (&node);
4135 vam->retval = ntohl (mp->retval);
4136 vam->result_ready = 1;
4140 vl_api_one_show_xtr_mode_reply_t_handler
4141 (vl_api_one_show_xtr_mode_reply_t * mp)
4143 vat_main_t *vam = &vat_main;
4144 i32 retval = ntohl (mp->retval);
4148 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4151 vam->retval = retval;
4152 vam->result_ready = 1;
4156 vl_api_one_show_xtr_mode_reply_t_handler_json
4157 (vl_api_one_show_xtr_mode_reply_t * mp)
4159 vat_main_t *vam = &vat_main;
4160 vat_json_node_t node;
4163 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4164 vec_add1 (status, 0);
4166 vat_json_init_object (&node);
4167 vat_json_object_add_string_copy (&node, "status", status);
4171 vat_json_print (vam->ofp, &node);
4172 vat_json_free (&node);
4174 vam->retval = ntohl (mp->retval);
4175 vam->result_ready = 1;
4179 vl_api_one_show_pitr_mode_reply_t_handler
4180 (vl_api_one_show_pitr_mode_reply_t * mp)
4182 vat_main_t *vam = &vat_main;
4183 i32 retval = ntohl (mp->retval);
4187 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4190 vam->retval = retval;
4191 vam->result_ready = 1;
4195 vl_api_one_show_pitr_mode_reply_t_handler_json
4196 (vl_api_one_show_pitr_mode_reply_t * mp)
4198 vat_main_t *vam = &vat_main;
4199 vat_json_node_t node;
4202 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4203 vec_add1 (status, 0);
4205 vat_json_init_object (&node);
4206 vat_json_object_add_string_copy (&node, "status", status);
4210 vat_json_print (vam->ofp, &node);
4211 vat_json_free (&node);
4213 vam->retval = ntohl (mp->retval);
4214 vam->result_ready = 1;
4218 vl_api_one_show_petr_mode_reply_t_handler
4219 (vl_api_one_show_petr_mode_reply_t * mp)
4221 vat_main_t *vam = &vat_main;
4222 i32 retval = ntohl (mp->retval);
4226 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4229 vam->retval = retval;
4230 vam->result_ready = 1;
4234 vl_api_one_show_petr_mode_reply_t_handler_json
4235 (vl_api_one_show_petr_mode_reply_t * mp)
4237 vat_main_t *vam = &vat_main;
4238 vat_json_node_t node;
4241 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4242 vec_add1 (status, 0);
4244 vat_json_init_object (&node);
4245 vat_json_object_add_string_copy (&node, "status", status);
4249 vat_json_print (vam->ofp, &node);
4250 vat_json_free (&node);
4252 vam->retval = ntohl (mp->retval);
4253 vam->result_ready = 1;
4257 vl_api_show_one_use_petr_reply_t_handler
4258 (vl_api_show_one_use_petr_reply_t * mp)
4260 vat_main_t *vam = &vat_main;
4261 i32 retval = ntohl (mp->retval);
4265 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4268 print (vam->ofp, "Proxy-ETR address; %U",
4269 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4274 vam->retval = retval;
4275 vam->result_ready = 1;
4279 vl_api_show_one_use_petr_reply_t_handler_json
4280 (vl_api_show_one_use_petr_reply_t * mp)
4282 vat_main_t *vam = &vat_main;
4283 vat_json_node_t node;
4286 struct in6_addr ip6;
4288 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4289 vec_add1 (status, 0);
4291 vat_json_init_object (&node);
4292 vat_json_object_add_string_copy (&node, "status", status);
4297 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4298 vat_json_object_add_ip6 (&node, "address", ip6);
4302 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4303 vat_json_object_add_ip4 (&node, "address", ip4);
4309 vat_json_print (vam->ofp, &node);
4310 vat_json_free (&node);
4312 vam->retval = ntohl (mp->retval);
4313 vam->result_ready = 1;
4317 vl_api_show_one_nsh_mapping_reply_t_handler
4318 (vl_api_show_one_nsh_mapping_reply_t * mp)
4320 vat_main_t *vam = &vat_main;
4321 i32 retval = ntohl (mp->retval);
4325 print (vam->ofp, "%-20s%-16s",
4326 mp->is_set ? "set" : "not-set",
4327 mp->is_set ? (char *) mp->locator_set_name : "");
4330 vam->retval = retval;
4331 vam->result_ready = 1;
4335 vl_api_show_one_nsh_mapping_reply_t_handler_json
4336 (vl_api_show_one_nsh_mapping_reply_t * mp)
4338 vat_main_t *vam = &vat_main;
4339 vat_json_node_t node;
4342 status = format (0, "%s", mp->is_set ? "yes" : "no");
4343 vec_add1 (status, 0);
4345 vat_json_init_object (&node);
4346 vat_json_object_add_string_copy (&node, "is_set", status);
4349 vat_json_object_add_string_copy (&node, "locator_set",
4350 mp->locator_set_name);
4355 vat_json_print (vam->ofp, &node);
4356 vat_json_free (&node);
4358 vam->retval = ntohl (mp->retval);
4359 vam->result_ready = 1;
4363 vl_api_show_one_map_register_ttl_reply_t_handler
4364 (vl_api_show_one_map_register_ttl_reply_t * mp)
4366 vat_main_t *vam = &vat_main;
4367 i32 retval = ntohl (mp->retval);
4369 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4373 print (vam->ofp, "ttl: %u", mp->ttl);
4376 vam->retval = retval;
4377 vam->result_ready = 1;
4381 vl_api_show_one_map_register_ttl_reply_t_handler_json
4382 (vl_api_show_one_map_register_ttl_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 vat_json_node_t node;
4387 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4388 vat_json_init_object (&node);
4389 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4391 vat_json_print (vam->ofp, &node);
4392 vat_json_free (&node);
4394 vam->retval = ntohl (mp->retval);
4395 vam->result_ready = 1;
4399 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4401 vat_main_t *vam = &vat_main;
4402 i32 retval = ntohl (mp->retval);
4406 print (vam->ofp, "%-20s%-16s",
4407 mp->status ? "enabled" : "disabled",
4408 mp->status ? (char *) mp->locator_set_name : "");
4411 vam->retval = retval;
4412 vam->result_ready = 1;
4416 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4418 vat_main_t *vam = &vat_main;
4419 vat_json_node_t node;
4422 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4423 vec_add1 (status, 0);
4425 vat_json_init_object (&node);
4426 vat_json_object_add_string_copy (&node, "status", status);
4429 vat_json_object_add_string_copy (&node, "locator_set",
4430 mp->locator_set_name);
4435 vat_json_print (vam->ofp, &node);
4436 vat_json_free (&node);
4438 vam->retval = ntohl (mp->retval);
4439 vam->result_ready = 1;
4443 format_policer_type (u8 * s, va_list * va)
4445 u32 i = va_arg (*va, u32);
4447 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4448 s = format (s, "1r2c");
4449 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4450 s = format (s, "1r3c");
4451 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4452 s = format (s, "2r3c-2698");
4453 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4454 s = format (s, "2r3c-4115");
4455 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4456 s = format (s, "2r3c-mef5cf1");
4458 s = format (s, "ILLEGAL");
4463 format_policer_rate_type (u8 * s, va_list * va)
4465 u32 i = va_arg (*va, u32);
4467 if (i == SSE2_QOS_RATE_KBPS)
4468 s = format (s, "kbps");
4469 else if (i == SSE2_QOS_RATE_PPS)
4470 s = format (s, "pps");
4472 s = format (s, "ILLEGAL");
4477 format_policer_round_type (u8 * s, va_list * va)
4479 u32 i = va_arg (*va, u32);
4481 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4482 s = format (s, "closest");
4483 else if (i == SSE2_QOS_ROUND_TO_UP)
4484 s = format (s, "up");
4485 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4486 s = format (s, "down");
4488 s = format (s, "ILLEGAL");
4493 format_policer_action_type (u8 * s, va_list * va)
4495 u32 i = va_arg (*va, u32);
4497 if (i == SSE2_QOS_ACTION_DROP)
4498 s = format (s, "drop");
4499 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4500 s = format (s, "transmit");
4501 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4502 s = format (s, "mark-and-transmit");
4504 s = format (s, "ILLEGAL");
4509 format_dscp (u8 * s, va_list * va)
4511 u32 i = va_arg (*va, u32);
4516 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4520 return format (s, "ILLEGAL");
4522 s = format (s, "%s", t);
4527 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4529 vat_main_t *vam = &vat_main;
4530 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4532 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4533 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4535 conform_dscp_str = format (0, "");
4537 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4538 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4540 exceed_dscp_str = format (0, "");
4542 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4543 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4545 violate_dscp_str = format (0, "");
4547 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4548 "rate type %U, round type %U, %s rate, %s color-aware, "
4549 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4550 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4551 "conform action %U%s, exceed action %U%s, violate action %U%s",
4553 format_policer_type, mp->type,
4556 clib_net_to_host_u64 (mp->cb),
4557 clib_net_to_host_u64 (mp->eb),
4558 format_policer_rate_type, mp->rate_type,
4559 format_policer_round_type, mp->round_type,
4560 mp->single_rate ? "single" : "dual",
4561 mp->color_aware ? "is" : "not",
4562 ntohl (mp->cir_tokens_per_period),
4563 ntohl (mp->pir_tokens_per_period),
4565 ntohl (mp->current_limit),
4566 ntohl (mp->current_bucket),
4567 ntohl (mp->extended_limit),
4568 ntohl (mp->extended_bucket),
4569 clib_net_to_host_u64 (mp->last_update_time),
4570 format_policer_action_type, mp->conform_action_type,
4572 format_policer_action_type, mp->exceed_action_type,
4574 format_policer_action_type, mp->violate_action_type,
4577 vec_free (conform_dscp_str);
4578 vec_free (exceed_dscp_str);
4579 vec_free (violate_dscp_str);
4582 static void vl_api_policer_details_t_handler_json
4583 (vl_api_policer_details_t * mp)
4585 vat_main_t *vam = &vat_main;
4586 vat_json_node_t *node;
4587 u8 *rate_type_str, *round_type_str, *type_str;
4588 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4590 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4592 format (0, "%U", format_policer_round_type, mp->round_type);
4593 type_str = format (0, "%U", format_policer_type, mp->type);
4594 conform_action_str = format (0, "%U", format_policer_action_type,
4595 mp->conform_action_type);
4596 exceed_action_str = format (0, "%U", format_policer_action_type,
4597 mp->exceed_action_type);
4598 violate_action_str = format (0, "%U", format_policer_action_type,
4599 mp->violate_action_type);
4601 if (VAT_JSON_ARRAY != vam->json_tree.type)
4603 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4604 vat_json_init_array (&vam->json_tree);
4606 node = vat_json_array_add (&vam->json_tree);
4608 vat_json_init_object (node);
4609 vat_json_object_add_string_copy (node, "name", mp->name);
4610 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4611 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4612 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4613 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4614 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4615 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4616 vat_json_object_add_string_copy (node, "type", type_str);
4617 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4618 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4619 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4620 vat_json_object_add_uint (node, "cir_tokens_per_period",
4621 ntohl (mp->cir_tokens_per_period));
4622 vat_json_object_add_uint (node, "eir_tokens_per_period",
4623 ntohl (mp->pir_tokens_per_period));
4624 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4625 vat_json_object_add_uint (node, "current_bucket",
4626 ntohl (mp->current_bucket));
4627 vat_json_object_add_uint (node, "extended_limit",
4628 ntohl (mp->extended_limit));
4629 vat_json_object_add_uint (node, "extended_bucket",
4630 ntohl (mp->extended_bucket));
4631 vat_json_object_add_uint (node, "last_update_time",
4632 ntohl (mp->last_update_time));
4633 vat_json_object_add_string_copy (node, "conform_action",
4634 conform_action_str);
4635 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4637 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4638 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4639 vec_free (dscp_str);
4641 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4642 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4644 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4645 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4646 vec_free (dscp_str);
4648 vat_json_object_add_string_copy (node, "violate_action",
4649 violate_action_str);
4650 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4652 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4653 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4654 vec_free (dscp_str);
4657 vec_free (rate_type_str);
4658 vec_free (round_type_str);
4659 vec_free (type_str);
4660 vec_free (conform_action_str);
4661 vec_free (exceed_action_str);
4662 vec_free (violate_action_str);
4666 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4669 vat_main_t *vam = &vat_main;
4670 int i, count = ntohl (mp->count);
4673 print (vam->ofp, "classify table ids (%d) : ", count);
4674 for (i = 0; i < count; i++)
4676 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4677 print (vam->ofp, (i < count - 1) ? "," : "");
4679 vam->retval = ntohl (mp->retval);
4680 vam->result_ready = 1;
4684 vl_api_classify_table_ids_reply_t_handler_json
4685 (vl_api_classify_table_ids_reply_t * mp)
4687 vat_main_t *vam = &vat_main;
4688 int i, count = ntohl (mp->count);
4692 vat_json_node_t node;
4694 vat_json_init_object (&node);
4695 for (i = 0; i < count; i++)
4697 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4699 vat_json_print (vam->ofp, &node);
4700 vat_json_free (&node);
4702 vam->retval = ntohl (mp->retval);
4703 vam->result_ready = 1;
4707 vl_api_classify_table_by_interface_reply_t_handler
4708 (vl_api_classify_table_by_interface_reply_t * mp)
4710 vat_main_t *vam = &vat_main;
4713 table_id = ntohl (mp->l2_table_id);
4715 print (vam->ofp, "l2 table id : %d", table_id);
4717 print (vam->ofp, "l2 table id : No input ACL tables configured");
4718 table_id = ntohl (mp->ip4_table_id);
4720 print (vam->ofp, "ip4 table id : %d", table_id);
4722 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4723 table_id = ntohl (mp->ip6_table_id);
4725 print (vam->ofp, "ip6 table id : %d", table_id);
4727 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4728 vam->retval = ntohl (mp->retval);
4729 vam->result_ready = 1;
4733 vl_api_classify_table_by_interface_reply_t_handler_json
4734 (vl_api_classify_table_by_interface_reply_t * mp)
4736 vat_main_t *vam = &vat_main;
4737 vat_json_node_t node;
4739 vat_json_init_object (&node);
4741 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4742 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4743 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4745 vat_json_print (vam->ofp, &node);
4746 vat_json_free (&node);
4748 vam->retval = ntohl (mp->retval);
4749 vam->result_ready = 1;
4752 static void vl_api_policer_add_del_reply_t_handler
4753 (vl_api_policer_add_del_reply_t * mp)
4755 vat_main_t *vam = &vat_main;
4756 i32 retval = ntohl (mp->retval);
4757 if (vam->async_mode)
4759 vam->async_errors += (retval < 0);
4763 vam->retval = retval;
4764 vam->result_ready = 1;
4765 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4767 * Note: this is just barely thread-safe, depends on
4768 * the main thread spinning waiting for an answer...
4770 errmsg ("policer index %d", ntohl (mp->policer_index));
4774 static void vl_api_policer_add_del_reply_t_handler_json
4775 (vl_api_policer_add_del_reply_t * mp)
4777 vat_main_t *vam = &vat_main;
4778 vat_json_node_t node;
4780 vat_json_init_object (&node);
4781 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4782 vat_json_object_add_uint (&node, "policer_index",
4783 ntohl (mp->policer_index));
4785 vat_json_print (vam->ofp, &node);
4786 vat_json_free (&node);
4788 vam->retval = ntohl (mp->retval);
4789 vam->result_ready = 1;
4792 /* Format hex dump. */
4794 format_hex_bytes (u8 * s, va_list * va)
4796 u8 *bytes = va_arg (*va, u8 *);
4797 int n_bytes = va_arg (*va, int);
4800 /* Print short or long form depending on byte count. */
4801 uword short_form = n_bytes <= 32;
4802 u32 indent = format_get_indent (s);
4807 for (i = 0; i < n_bytes; i++)
4809 if (!short_form && (i % 32) == 0)
4810 s = format (s, "%08x: ", i);
4811 s = format (s, "%02x", bytes[i]);
4812 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4813 s = format (s, "\n%U", format_white_space, indent);
4820 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4823 vat_main_t *vam = &vat_main;
4824 i32 retval = ntohl (mp->retval);
4827 print (vam->ofp, "classify table info :");
4828 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4829 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4830 ntohl (mp->miss_next_index));
4831 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4832 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4833 ntohl (mp->match_n_vectors));
4834 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4835 ntohl (mp->mask_length));
4837 vam->retval = retval;
4838 vam->result_ready = 1;
4842 vl_api_classify_table_info_reply_t_handler_json
4843 (vl_api_classify_table_info_reply_t * mp)
4845 vat_main_t *vam = &vat_main;
4846 vat_json_node_t node;
4848 i32 retval = ntohl (mp->retval);
4851 vat_json_init_object (&node);
4853 vat_json_object_add_int (&node, "sessions",
4854 ntohl (mp->active_sessions));
4855 vat_json_object_add_int (&node, "nexttbl",
4856 ntohl (mp->next_table_index));
4857 vat_json_object_add_int (&node, "nextnode",
4858 ntohl (mp->miss_next_index));
4859 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4860 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4861 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4862 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4863 ntohl (mp->mask_length), 0);
4864 vat_json_object_add_string_copy (&node, "mask", s);
4866 vat_json_print (vam->ofp, &node);
4867 vat_json_free (&node);
4869 vam->retval = ntohl (mp->retval);
4870 vam->result_ready = 1;
4874 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4877 vat_main_t *vam = &vat_main;
4879 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4880 ntohl (mp->hit_next_index), ntohl (mp->advance),
4881 ntohl (mp->opaque_index));
4882 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4883 ntohl (mp->match_length));
4887 vl_api_classify_session_details_t_handler_json
4888 (vl_api_classify_session_details_t * mp)
4890 vat_main_t *vam = &vat_main;
4891 vat_json_node_t *node = NULL;
4893 if (VAT_JSON_ARRAY != vam->json_tree.type)
4895 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4896 vat_json_init_array (&vam->json_tree);
4898 node = vat_json_array_add (&vam->json_tree);
4900 vat_json_init_object (node);
4901 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4902 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4903 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4905 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4907 vat_json_object_add_string_copy (node, "match", s);
4910 static void vl_api_pg_create_interface_reply_t_handler
4911 (vl_api_pg_create_interface_reply_t * mp)
4913 vat_main_t *vam = &vat_main;
4915 vam->retval = ntohl (mp->retval);
4916 vam->result_ready = 1;
4919 static void vl_api_pg_create_interface_reply_t_handler_json
4920 (vl_api_pg_create_interface_reply_t * mp)
4922 vat_main_t *vam = &vat_main;
4923 vat_json_node_t node;
4925 i32 retval = ntohl (mp->retval);
4928 vat_json_init_object (&node);
4930 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4932 vat_json_print (vam->ofp, &node);
4933 vat_json_free (&node);
4935 vam->retval = ntohl (mp->retval);
4936 vam->result_ready = 1;
4939 static void vl_api_policer_classify_details_t_handler
4940 (vl_api_policer_classify_details_t * mp)
4942 vat_main_t *vam = &vat_main;
4944 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4945 ntohl (mp->table_index));
4948 static void vl_api_policer_classify_details_t_handler_json
4949 (vl_api_policer_classify_details_t * mp)
4951 vat_main_t *vam = &vat_main;
4952 vat_json_node_t *node;
4954 if (VAT_JSON_ARRAY != vam->json_tree.type)
4956 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4957 vat_json_init_array (&vam->json_tree);
4959 node = vat_json_array_add (&vam->json_tree);
4961 vat_json_init_object (node);
4962 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4963 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4966 static void vl_api_flow_classify_details_t_handler
4967 (vl_api_flow_classify_details_t * mp)
4969 vat_main_t *vam = &vat_main;
4971 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4972 ntohl (mp->table_index));
4975 static void vl_api_flow_classify_details_t_handler_json
4976 (vl_api_flow_classify_details_t * mp)
4978 vat_main_t *vam = &vat_main;
4979 vat_json_node_t *node;
4981 if (VAT_JSON_ARRAY != vam->json_tree.type)
4983 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4984 vat_json_init_array (&vam->json_tree);
4986 node = vat_json_array_add (&vam->json_tree);
4988 vat_json_init_object (node);
4989 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4990 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4993 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
4994 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
4995 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
4996 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
4997 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
4998 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
4999 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5000 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5001 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5002 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5005 * Generate boilerplate reply handlers, which
5006 * dig the return value out of the xxx_reply_t API message,
5007 * stick it into vam->retval, and set vam->result_ready
5009 * Could also do this by pointing N message decode slots at
5010 * a single function, but that could break in subtle ways.
5013 #define foreach_standard_reply_retval_handler \
5014 _(sw_interface_set_flags_reply) \
5015 _(sw_interface_add_del_address_reply) \
5016 _(sw_interface_set_rx_mode_reply) \
5017 _(sw_interface_set_rx_placement_reply) \
5018 _(sw_interface_set_table_reply) \
5019 _(sw_interface_set_mpls_enable_reply) \
5020 _(sw_interface_set_vpath_reply) \
5021 _(sw_interface_set_vxlan_bypass_reply) \
5022 _(sw_interface_set_geneve_bypass_reply) \
5023 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5024 _(sw_interface_set_l2_bridge_reply) \
5025 _(sw_interface_set_bond_weight_reply) \
5026 _(bridge_domain_add_del_reply) \
5027 _(sw_interface_set_l2_xconnect_reply) \
5028 _(l2fib_add_del_reply) \
5029 _(l2fib_flush_int_reply) \
5030 _(l2fib_flush_bd_reply) \
5031 _(ip_route_add_del_reply) \
5032 _(ip_table_add_del_reply) \
5033 _(ip_table_replace_begin_reply) \
5034 _(ip_table_flush_reply) \
5035 _(ip_table_replace_end_reply) \
5036 _(ip_mroute_add_del_reply) \
5037 _(mpls_route_add_del_reply) \
5038 _(mpls_table_add_del_reply) \
5039 _(mpls_ip_bind_unbind_reply) \
5040 _(bier_route_add_del_reply) \
5041 _(bier_table_add_del_reply) \
5042 _(sw_interface_set_unnumbered_reply) \
5043 _(set_ip_flow_hash_reply) \
5044 _(sw_interface_ip6_enable_disable_reply) \
5045 _(l2_patch_add_del_reply) \
5046 _(sr_mpls_policy_add_reply) \
5047 _(sr_mpls_policy_mod_reply) \
5048 _(sr_mpls_policy_del_reply) \
5049 _(sr_policy_add_reply) \
5050 _(sr_policy_mod_reply) \
5051 _(sr_policy_del_reply) \
5052 _(sr_localsid_add_del_reply) \
5053 _(sr_steering_add_del_reply) \
5054 _(classify_add_del_session_reply) \
5055 _(classify_set_interface_ip_table_reply) \
5056 _(classify_set_interface_l2_tables_reply) \
5057 _(l2tpv3_set_tunnel_cookies_reply) \
5058 _(l2tpv3_interface_enable_disable_reply) \
5059 _(l2tpv3_set_lookup_key_reply) \
5060 _(l2_fib_clear_table_reply) \
5061 _(l2_interface_efp_filter_reply) \
5062 _(l2_interface_vlan_tag_rewrite_reply) \
5063 _(modify_vhost_user_if_reply) \
5064 _(delete_vhost_user_if_reply) \
5065 _(want_l2_macs_events_reply) \
5066 _(input_acl_set_interface_reply) \
5067 _(ipsec_spd_add_del_reply) \
5068 _(ipsec_interface_add_del_spd_reply) \
5069 _(ipsec_spd_entry_add_del_reply) \
5070 _(ipsec_sad_entry_add_del_reply) \
5071 _(ipsec_tunnel_if_add_del_reply) \
5072 _(ipsec_tunnel_if_set_sa_reply) \
5073 _(delete_loopback_reply) \
5074 _(bd_ip_mac_add_del_reply) \
5075 _(bd_ip_mac_flush_reply) \
5076 _(want_interface_events_reply) \
5077 _(cop_interface_enable_disable_reply) \
5078 _(cop_whitelist_enable_disable_reply) \
5079 _(sw_interface_clear_stats_reply) \
5080 _(ioam_enable_reply) \
5081 _(ioam_disable_reply) \
5082 _(one_add_del_locator_reply) \
5083 _(one_add_del_local_eid_reply) \
5084 _(one_add_del_remote_mapping_reply) \
5085 _(one_add_del_adjacency_reply) \
5086 _(one_add_del_map_resolver_reply) \
5087 _(one_add_del_map_server_reply) \
5088 _(one_enable_disable_reply) \
5089 _(one_rloc_probe_enable_disable_reply) \
5090 _(one_map_register_enable_disable_reply) \
5091 _(one_map_register_set_ttl_reply) \
5092 _(one_set_transport_protocol_reply) \
5093 _(one_map_register_fallback_threshold_reply) \
5094 _(one_pitr_set_locator_set_reply) \
5095 _(one_map_request_mode_reply) \
5096 _(one_add_del_map_request_itr_rlocs_reply) \
5097 _(one_eid_table_add_del_map_reply) \
5098 _(one_use_petr_reply) \
5099 _(one_stats_enable_disable_reply) \
5100 _(one_add_del_l2_arp_entry_reply) \
5101 _(one_add_del_ndp_entry_reply) \
5102 _(one_stats_flush_reply) \
5103 _(one_enable_disable_xtr_mode_reply) \
5104 _(one_enable_disable_pitr_mode_reply) \
5105 _(one_enable_disable_petr_mode_reply) \
5106 _(gpe_enable_disable_reply) \
5107 _(gpe_set_encap_mode_reply) \
5108 _(gpe_add_del_iface_reply) \
5109 _(gpe_add_del_native_fwd_rpath_reply) \
5110 _(af_packet_delete_reply) \
5111 _(policer_classify_set_interface_reply) \
5112 _(set_ipfix_exporter_reply) \
5113 _(set_ipfix_classify_stream_reply) \
5114 _(ipfix_classify_table_add_del_reply) \
5115 _(flow_classify_set_interface_reply) \
5116 _(sw_interface_span_enable_disable_reply) \
5117 _(pg_capture_reply) \
5118 _(pg_enable_disable_reply) \
5119 _(ip_source_and_port_range_check_add_del_reply) \
5120 _(ip_source_and_port_range_check_interface_add_del_reply)\
5121 _(delete_subif_reply) \
5122 _(l2_interface_pbb_tag_rewrite_reply) \
5124 _(feature_enable_disable_reply) \
5125 _(feature_gso_enable_disable_reply) \
5126 _(sw_interface_tag_add_del_reply) \
5127 _(sw_interface_add_del_mac_address_reply) \
5128 _(hw_interface_set_mtu_reply) \
5129 _(p2p_ethernet_add_reply) \
5130 _(p2p_ethernet_del_reply) \
5131 _(lldp_config_reply) \
5132 _(sw_interface_set_lldp_reply) \
5133 _(tcp_configure_src_addresses_reply) \
5134 _(session_rule_add_del_reply) \
5135 _(ip_container_proxy_add_del_reply) \
5136 _(output_acl_set_interface_reply) \
5137 _(qos_record_enable_disable_reply)
5140 static void vl_api_##n##_t_handler \
5141 (vl_api_##n##_t * mp) \
5143 vat_main_t * vam = &vat_main; \
5144 i32 retval = ntohl(mp->retval); \
5145 if (vam->async_mode) { \
5146 vam->async_errors += (retval < 0); \
5148 vam->retval = retval; \
5149 vam->result_ready = 1; \
5152 foreach_standard_reply_retval_handler;
5156 static void vl_api_##n##_t_handler_json \
5157 (vl_api_##n##_t * mp) \
5159 vat_main_t * vam = &vat_main; \
5160 vat_json_node_t node; \
5161 vat_json_init_object(&node); \
5162 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5163 vat_json_print(vam->ofp, &node); \
5164 vam->retval = ntohl(mp->retval); \
5165 vam->result_ready = 1; \
5167 foreach_standard_reply_retval_handler;
5171 * Table of message reply handlers, must include boilerplate handlers
5175 #define foreach_vpe_api_reply_msg \
5176 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5177 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5178 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5179 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5180 _(CONTROL_PING_REPLY, control_ping_reply) \
5181 _(CLI_REPLY, cli_reply) \
5182 _(CLI_INBAND_REPLY, cli_inband_reply) \
5183 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5184 sw_interface_add_del_address_reply) \
5185 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5186 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5187 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5188 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5189 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5190 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5191 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5192 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5193 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5194 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5195 sw_interface_set_l2_xconnect_reply) \
5196 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5197 sw_interface_set_l2_bridge_reply) \
5198 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5199 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5200 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5201 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5202 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5203 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5204 _(L2_FLAGS_REPLY, l2_flags_reply) \
5205 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5206 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5207 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5208 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5209 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5210 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5211 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5212 _(BOND_CREATE_REPLY, bond_create_reply) \
5213 _(BOND_DELETE_REPLY, bond_delete_reply) \
5214 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5215 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5216 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5217 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5218 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5219 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5220 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5221 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5222 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5223 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5224 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5225 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5226 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5227 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5228 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5229 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5230 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5231 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5232 sw_interface_set_unnumbered_reply) \
5233 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5234 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5235 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5236 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5237 sw_interface_ip6_enable_disable_reply) \
5238 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5239 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5240 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5241 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5242 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5243 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5244 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5245 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5246 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5247 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5248 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5249 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5250 classify_set_interface_ip_table_reply) \
5251 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5252 classify_set_interface_l2_tables_reply) \
5253 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5254 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5255 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5256 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5257 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5258 l2tpv3_interface_enable_disable_reply) \
5259 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5260 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5261 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5262 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5263 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5264 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5265 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5266 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5267 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5268 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5269 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5270 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5271 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5272 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5273 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5274 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5275 _(SHOW_VERSION_REPLY, show_version_reply) \
5276 _(SHOW_THREADS_REPLY, show_threads_reply) \
5277 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5278 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5279 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5280 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5281 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5282 _(L2_MACS_EVENT, l2_macs_event) \
5283 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5284 _(IP_ADDRESS_DETAILS, ip_address_details) \
5285 _(IP_DETAILS, ip_details) \
5286 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5287 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5288 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5289 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5290 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5291 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5292 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5293 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5294 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5295 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5296 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5297 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5298 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5299 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5300 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5301 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5302 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5303 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5304 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5305 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5306 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5307 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5308 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5309 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5310 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5311 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5312 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5313 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5314 one_map_register_enable_disable_reply) \
5315 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5316 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5317 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5318 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5319 one_map_register_fallback_threshold_reply) \
5320 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5321 one_rloc_probe_enable_disable_reply) \
5322 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5323 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5324 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5325 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5326 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5327 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5328 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5329 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5330 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5331 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5332 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5333 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5334 _(ONE_STATS_DETAILS, one_stats_details) \
5335 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5336 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5337 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5338 show_one_stats_enable_disable_reply) \
5339 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5340 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5341 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5342 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5343 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5344 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5345 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5346 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5347 one_enable_disable_pitr_mode_reply) \
5348 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5349 one_enable_disable_petr_mode_reply) \
5350 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5351 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5352 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5353 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5354 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5355 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5356 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5357 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5358 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5359 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5360 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5361 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5362 gpe_add_del_native_fwd_rpath_reply) \
5363 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5364 gpe_fwd_entry_path_details) \
5365 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5366 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5367 one_add_del_map_request_itr_rlocs_reply) \
5368 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5369 one_get_map_request_itr_rlocs_reply) \
5370 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5371 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5372 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5373 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5374 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5375 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5376 show_one_map_register_state_reply) \
5377 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5378 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5379 show_one_map_register_fallback_threshold_reply) \
5380 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5381 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5382 _(AF_PACKET_DETAILS, af_packet_details) \
5383 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5384 _(POLICER_DETAILS, policer_details) \
5385 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5386 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5387 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5388 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5389 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5390 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5391 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5392 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5393 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5394 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5395 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5396 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5397 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5398 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5399 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5400 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5401 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5402 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5403 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5404 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5405 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5406 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5407 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5408 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5409 ip_source_and_port_range_check_add_del_reply) \
5410 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5411 ip_source_and_port_range_check_interface_add_del_reply) \
5412 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5413 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5414 _(SET_PUNT_REPLY, set_punt_reply) \
5415 _(IP_TABLE_DETAILS, ip_table_details) \
5416 _(IP_ROUTE_DETAILS, ip_route_details) \
5417 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5418 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5419 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5420 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5421 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5422 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5423 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5424 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5425 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5426 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5427 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5428 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5429 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5430 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5431 _(SESSION_RULES_DETAILS, session_rules_details) \
5432 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5433 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5434 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5436 #define foreach_standalone_reply_msg \
5437 _(SW_INTERFACE_EVENT, sw_interface_event)
5445 #define STR_VTR_OP_CASE(op) \
5446 case L2_VTR_ ## op: \
5450 str_vtr_op (u32 vtr_op)
5454 STR_VTR_OP_CASE (DISABLED);
5455 STR_VTR_OP_CASE (PUSH_1);
5456 STR_VTR_OP_CASE (PUSH_2);
5457 STR_VTR_OP_CASE (POP_1);
5458 STR_VTR_OP_CASE (POP_2);
5459 STR_VTR_OP_CASE (TRANSLATE_1_1);
5460 STR_VTR_OP_CASE (TRANSLATE_1_2);
5461 STR_VTR_OP_CASE (TRANSLATE_2_1);
5462 STR_VTR_OP_CASE (TRANSLATE_2_2);
5469 dump_sub_interface_table (vat_main_t * vam)
5471 const sw_interface_subif_t *sub = NULL;
5473 if (vam->json_output)
5476 ("JSON output supported only for VPE API calls and dump_stats_table");
5481 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5482 "Interface", "sw_if_index",
5483 "sub id", "dot1ad", "tags", "outer id",
5484 "inner id", "exact", "default", "outer any", "inner any");
5486 vec_foreach (sub, vam->sw_if_subif_table)
5489 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5490 sub->interface_name,
5492 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5493 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5494 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5495 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5496 if (sub->vtr_op != L2_VTR_DISABLED)
5499 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5500 "tag1: %d tag2: %d ]",
5501 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5502 sub->vtr_tag1, sub->vtr_tag2);
5510 name_sort_cmp (void *a1, void *a2)
5512 name_sort_t *n1 = a1;
5513 name_sort_t *n2 = a2;
5515 return strcmp ((char *) n1->name, (char *) n2->name);
5519 dump_interface_table (vat_main_t * vam)
5522 name_sort_t *nses = 0, *ns;
5524 if (vam->json_output)
5527 ("JSON output supported only for VPE API calls and dump_stats_table");
5532 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5534 vec_add2 (nses, ns, 1);
5535 ns->name = (u8 *)(p->key);
5536 ns->value = (u32) p->value[0];
5540 vec_sort_with_function (nses, name_sort_cmp);
5542 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5543 vec_foreach (ns, nses)
5545 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5552 dump_ip_table (vat_main_t * vam, int is_ipv6)
5554 const ip_details_t *det = NULL;
5555 const ip_address_details_t *address = NULL;
5558 print (vam->ofp, "%-12s", "sw_if_index");
5560 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5567 print (vam->ofp, "%-12d", i);
5568 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5573 vec_foreach (address, det->addr)
5577 is_ipv6 ? format_ip6_address : format_ip4_address,
5578 address->ip, address->prefix_length);
5586 dump_ipv4_table (vat_main_t * vam)
5588 if (vam->json_output)
5591 ("JSON output supported only for VPE API calls and dump_stats_table");
5595 return dump_ip_table (vam, 0);
5599 dump_ipv6_table (vat_main_t * vam)
5601 if (vam->json_output)
5604 ("JSON output supported only for VPE API calls and dump_stats_table");
5608 return dump_ip_table (vam, 1);
5612 * Pass CLI buffers directly in the CLI_INBAND API message,
5613 * instead of an additional shared memory area.
5616 exec_inband (vat_main_t * vam)
5618 vl_api_cli_inband_t *mp;
5619 unformat_input_t *i = vam->input;
5622 if (vec_len (i->buffer) == 0)
5625 if (vam->exec_mode == 0 && unformat (i, "mode"))
5630 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5637 * In order for the CLI command to work, it
5638 * must be a vector ending in \n, not a C-string ending
5641 u32 len = vec_len (vam->input->buffer);
5642 M2 (CLI_INBAND, mp, len);
5643 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5647 /* json responses may or may not include a useful reply... */
5648 if (vec_len (vam->cmd_reply))
5649 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5654 exec (vat_main_t * vam)
5656 return exec_inband (vam);
5660 api_create_loopback (vat_main_t * vam)
5662 unformat_input_t *i = vam->input;
5663 vl_api_create_loopback_t *mp;
5664 vl_api_create_loopback_instance_t *mp_lbi;
5667 u8 is_specified = 0;
5668 u32 user_instance = 0;
5671 clib_memset (mac_address, 0, sizeof (mac_address));
5673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5675 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5677 if (unformat (i, "instance %d", &user_instance))
5685 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5686 mp_lbi->is_specified = is_specified;
5688 mp_lbi->user_instance = htonl (user_instance);
5690 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5695 /* Construct the API message */
5696 M (CREATE_LOOPBACK, mp);
5698 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5707 api_delete_loopback (vat_main_t * vam)
5709 unformat_input_t *i = vam->input;
5710 vl_api_delete_loopback_t *mp;
5711 u32 sw_if_index = ~0;
5714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5716 if (unformat (i, "sw_if_index %d", &sw_if_index))
5722 if (sw_if_index == ~0)
5724 errmsg ("missing sw_if_index");
5728 /* Construct the API message */
5729 M (DELETE_LOOPBACK, mp);
5730 mp->sw_if_index = ntohl (sw_if_index);
5738 api_want_interface_events (vat_main_t * vam)
5740 unformat_input_t *i = vam->input;
5741 vl_api_want_interface_events_t *mp;
5745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5747 if (unformat (i, "enable"))
5749 else if (unformat (i, "disable"))
5757 errmsg ("missing enable|disable");
5761 M (WANT_INTERFACE_EVENTS, mp);
5762 mp->enable_disable = enable;
5764 vam->interface_event_display = enable;
5772 /* Note: non-static, called once to set up the initial intfc table */
5774 api_sw_interface_dump (vat_main_t * vam)
5776 vl_api_sw_interface_dump_t *mp;
5777 vl_api_control_ping_t *mp_ping;
5779 name_sort_t *nses = 0, *ns;
5780 sw_interface_subif_t *sub = NULL;
5783 /* Toss the old name table */
5785 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5787 vec_add2 (nses, ns, 1);
5788 ns->name = (u8 *)(p->key);
5789 ns->value = (u32) p->value[0];
5793 hash_free (vam->sw_if_index_by_interface_name);
5795 vec_foreach (ns, nses) vec_free (ns->name);
5799 vec_foreach (sub, vam->sw_if_subif_table)
5801 vec_free (sub->interface_name);
5803 vec_free (vam->sw_if_subif_table);
5805 /* recreate the interface name hash table */
5806 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5809 * Ask for all interface names. Otherwise, the epic catalog of
5810 * name filters becomes ridiculously long, and vat ends up needing
5811 * to be taught about new interface types.
5813 M (SW_INTERFACE_DUMP, mp);
5816 /* Use a control ping for synchronization */
5817 MPING (CONTROL_PING, mp_ping);
5825 api_sw_interface_set_flags (vat_main_t * vam)
5827 unformat_input_t *i = vam->input;
5828 vl_api_sw_interface_set_flags_t *mp;
5830 u8 sw_if_index_set = 0;
5834 /* Parse args required to build the message */
5835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5837 if (unformat (i, "admin-up"))
5839 else if (unformat (i, "admin-down"))
5842 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5843 sw_if_index_set = 1;
5844 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5845 sw_if_index_set = 1;
5850 if (sw_if_index_set == 0)
5852 errmsg ("missing interface name or sw_if_index");
5856 /* Construct the API message */
5857 M (SW_INTERFACE_SET_FLAGS, mp);
5858 mp->sw_if_index = ntohl (sw_if_index);
5859 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5864 /* Wait for a reply, return the good/bad news... */
5870 api_sw_interface_set_rx_mode (vat_main_t * vam)
5872 unformat_input_t *i = vam->input;
5873 vl_api_sw_interface_set_rx_mode_t *mp;
5875 u8 sw_if_index_set = 0;
5877 u8 queue_id_valid = 0;
5879 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5881 /* Parse args required to build the message */
5882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5884 if (unformat (i, "queue %d", &queue_id))
5886 else if (unformat (i, "polling"))
5887 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5888 else if (unformat (i, "interrupt"))
5889 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5890 else if (unformat (i, "adaptive"))
5891 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5893 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5894 sw_if_index_set = 1;
5895 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5896 sw_if_index_set = 1;
5901 if (sw_if_index_set == 0)
5903 errmsg ("missing interface name or sw_if_index");
5906 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5908 errmsg ("missing rx-mode");
5912 /* Construct the API message */
5913 M (SW_INTERFACE_SET_RX_MODE, mp);
5914 mp->sw_if_index = ntohl (sw_if_index);
5915 mp->mode = (vl_api_rx_mode_t) mode;
5916 mp->queue_id_valid = queue_id_valid;
5917 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5922 /* Wait for a reply, return the good/bad news... */
5928 api_sw_interface_set_rx_placement (vat_main_t * vam)
5930 unformat_input_t *i = vam->input;
5931 vl_api_sw_interface_set_rx_placement_t *mp;
5933 u8 sw_if_index_set = 0;
5936 u32 queue_id, thread_index;
5938 /* Parse args required to build the message */
5939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5941 if (unformat (i, "queue %d", &queue_id))
5943 else if (unformat (i, "main"))
5945 else if (unformat (i, "worker %d", &thread_index))
5948 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5949 sw_if_index_set = 1;
5950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5951 sw_if_index_set = 1;
5956 if (sw_if_index_set == 0)
5958 errmsg ("missing interface name or sw_if_index");
5964 /* Construct the API message */
5965 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5966 mp->sw_if_index = ntohl (sw_if_index);
5967 mp->worker_id = ntohl (thread_index);
5968 mp->queue_id = ntohl (queue_id);
5969 mp->is_main = is_main;
5973 /* Wait for a reply, return the good/bad news... */
5978 static void vl_api_sw_interface_rx_placement_details_t_handler
5979 (vl_api_sw_interface_rx_placement_details_t * mp)
5981 vat_main_t *vam = &vat_main;
5982 u32 worker_id = ntohl (mp->worker_id);
5985 "\n%-11d %-11s %-6d %-5d %-9s",
5986 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
5987 worker_id, ntohl (mp->queue_id),
5989 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
5992 static void vl_api_sw_interface_rx_placement_details_t_handler_json
5993 (vl_api_sw_interface_rx_placement_details_t * mp)
5995 vat_main_t *vam = &vat_main;
5996 vat_json_node_t *node = NULL;
5998 if (VAT_JSON_ARRAY != vam->json_tree.type)
6000 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6001 vat_json_init_array (&vam->json_tree);
6003 node = vat_json_array_add (&vam->json_tree);
6005 vat_json_init_object (node);
6006 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6007 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6008 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6009 vat_json_object_add_uint (node, "mode", mp->mode);
6013 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6015 unformat_input_t *i = vam->input;
6016 vl_api_sw_interface_rx_placement_dump_t *mp;
6017 vl_api_control_ping_t *mp_ping;
6020 u8 sw_if_index_set = 0;
6022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6024 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6026 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6033 "\n%-11s %-11s %-6s %-5s %-4s",
6034 "sw_if_index", "main/worker", "thread", "queue", "mode");
6036 /* Dump Interface rx placement */
6037 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6039 if (sw_if_index_set)
6040 mp->sw_if_index = htonl (sw_if_index);
6042 mp->sw_if_index = ~0;
6046 /* Use a control ping for synchronization */
6047 MPING (CONTROL_PING, mp_ping);
6055 api_sw_interface_clear_stats (vat_main_t * vam)
6057 unformat_input_t *i = vam->input;
6058 vl_api_sw_interface_clear_stats_t *mp;
6060 u8 sw_if_index_set = 0;
6063 /* Parse args required to build the message */
6064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6066 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6067 sw_if_index_set = 1;
6068 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6069 sw_if_index_set = 1;
6074 /* Construct the API message */
6075 M (SW_INTERFACE_CLEAR_STATS, mp);
6077 if (sw_if_index_set == 1)
6078 mp->sw_if_index = ntohl (sw_if_index);
6080 mp->sw_if_index = ~0;
6085 /* Wait for a reply, return the good/bad news... */
6091 api_sw_interface_add_del_address (vat_main_t * vam)
6093 unformat_input_t *i = vam->input;
6094 vl_api_sw_interface_add_del_address_t *mp;
6096 u8 sw_if_index_set = 0;
6097 u8 is_add = 1, del_all = 0;
6098 u32 address_length = 0;
6099 u8 v4_address_set = 0;
6100 u8 v6_address_set = 0;
6101 ip4_address_t v4address;
6102 ip6_address_t v6address;
6105 /* Parse args required to build the message */
6106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6108 if (unformat (i, "del-all"))
6110 else if (unformat (i, "del"))
6113 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6114 sw_if_index_set = 1;
6115 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6116 sw_if_index_set = 1;
6117 else if (unformat (i, "%U/%d",
6118 unformat_ip4_address, &v4address, &address_length))
6120 else if (unformat (i, "%U/%d",
6121 unformat_ip6_address, &v6address, &address_length))
6127 if (sw_if_index_set == 0)
6129 errmsg ("missing interface name or sw_if_index");
6132 if (v4_address_set && v6_address_set)
6134 errmsg ("both v4 and v6 addresses set");
6137 if (!v4_address_set && !v6_address_set && !del_all)
6139 errmsg ("no addresses set");
6143 /* Construct the API message */
6144 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6146 mp->sw_if_index = ntohl (sw_if_index);
6147 mp->is_add = is_add;
6148 mp->del_all = del_all;
6151 mp->prefix.address.af = ADDRESS_IP6;
6152 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6156 mp->prefix.address.af = ADDRESS_IP4;
6157 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6159 mp->prefix.len = address_length;
6164 /* Wait for a reply, return good/bad news */
6170 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6172 unformat_input_t *i = vam->input;
6173 vl_api_sw_interface_set_mpls_enable_t *mp;
6175 u8 sw_if_index_set = 0;
6179 /* Parse args required to build the message */
6180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6182 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6183 sw_if_index_set = 1;
6184 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6185 sw_if_index_set = 1;
6186 else if (unformat (i, "disable"))
6188 else if (unformat (i, "dis"))
6194 if (sw_if_index_set == 0)
6196 errmsg ("missing interface name or sw_if_index");
6200 /* Construct the API message */
6201 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6203 mp->sw_if_index = ntohl (sw_if_index);
6204 mp->enable = enable;
6209 /* Wait for a reply... */
6215 api_sw_interface_set_table (vat_main_t * vam)
6217 unformat_input_t *i = vam->input;
6218 vl_api_sw_interface_set_table_t *mp;
6219 u32 sw_if_index, vrf_id = 0;
6220 u8 sw_if_index_set = 0;
6224 /* Parse args required to build the message */
6225 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6227 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6228 sw_if_index_set = 1;
6229 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6230 sw_if_index_set = 1;
6231 else if (unformat (i, "vrf %d", &vrf_id))
6233 else if (unformat (i, "ipv6"))
6239 if (sw_if_index_set == 0)
6241 errmsg ("missing interface name or sw_if_index");
6245 /* Construct the API message */
6246 M (SW_INTERFACE_SET_TABLE, mp);
6248 mp->sw_if_index = ntohl (sw_if_index);
6249 mp->is_ipv6 = is_ipv6;
6250 mp->vrf_id = ntohl (vrf_id);
6255 /* Wait for a reply... */
6260 static void vl_api_sw_interface_get_table_reply_t_handler
6261 (vl_api_sw_interface_get_table_reply_t * mp)
6263 vat_main_t *vam = &vat_main;
6265 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6267 vam->retval = ntohl (mp->retval);
6268 vam->result_ready = 1;
6272 static void vl_api_sw_interface_get_table_reply_t_handler_json
6273 (vl_api_sw_interface_get_table_reply_t * mp)
6275 vat_main_t *vam = &vat_main;
6276 vat_json_node_t node;
6278 vat_json_init_object (&node);
6279 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6280 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6282 vat_json_print (vam->ofp, &node);
6283 vat_json_free (&node);
6285 vam->retval = ntohl (mp->retval);
6286 vam->result_ready = 1;
6290 api_sw_interface_get_table (vat_main_t * vam)
6292 unformat_input_t *i = vam->input;
6293 vl_api_sw_interface_get_table_t *mp;
6295 u8 sw_if_index_set = 0;
6299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6301 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6302 sw_if_index_set = 1;
6303 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6304 sw_if_index_set = 1;
6305 else if (unformat (i, "ipv6"))
6311 if (sw_if_index_set == 0)
6313 errmsg ("missing interface name or sw_if_index");
6317 M (SW_INTERFACE_GET_TABLE, mp);
6318 mp->sw_if_index = htonl (sw_if_index);
6319 mp->is_ipv6 = is_ipv6;
6327 api_sw_interface_set_vpath (vat_main_t * vam)
6329 unformat_input_t *i = vam->input;
6330 vl_api_sw_interface_set_vpath_t *mp;
6331 u32 sw_if_index = 0;
6332 u8 sw_if_index_set = 0;
6336 /* Parse args required to build the message */
6337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6340 sw_if_index_set = 1;
6341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6342 sw_if_index_set = 1;
6343 else if (unformat (i, "enable"))
6345 else if (unformat (i, "disable"))
6351 if (sw_if_index_set == 0)
6353 errmsg ("missing interface name or sw_if_index");
6357 /* Construct the API message */
6358 M (SW_INTERFACE_SET_VPATH, mp);
6360 mp->sw_if_index = ntohl (sw_if_index);
6361 mp->enable = is_enable;
6366 /* Wait for a reply... */
6372 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6374 unformat_input_t *i = vam->input;
6375 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6376 u32 sw_if_index = 0;
6377 u8 sw_if_index_set = 0;
6382 /* Parse args required to build the message */
6383 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6385 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6386 sw_if_index_set = 1;
6387 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6388 sw_if_index_set = 1;
6389 else if (unformat (i, "enable"))
6391 else if (unformat (i, "disable"))
6393 else if (unformat (i, "ip4"))
6395 else if (unformat (i, "ip6"))
6401 if (sw_if_index_set == 0)
6403 errmsg ("missing interface name or sw_if_index");
6407 /* Construct the API message */
6408 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6410 mp->sw_if_index = ntohl (sw_if_index);
6411 mp->enable = is_enable;
6412 mp->is_ipv6 = is_ipv6;
6417 /* Wait for a reply... */
6423 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6425 unformat_input_t *i = vam->input;
6426 vl_api_sw_interface_set_geneve_bypass_t *mp;
6427 u32 sw_if_index = 0;
6428 u8 sw_if_index_set = 0;
6433 /* Parse args required to build the message */
6434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6436 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6437 sw_if_index_set = 1;
6438 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6439 sw_if_index_set = 1;
6440 else if (unformat (i, "enable"))
6442 else if (unformat (i, "disable"))
6444 else if (unformat (i, "ip4"))
6446 else if (unformat (i, "ip6"))
6452 if (sw_if_index_set == 0)
6454 errmsg ("missing interface name or sw_if_index");
6458 /* Construct the API message */
6459 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6461 mp->sw_if_index = ntohl (sw_if_index);
6462 mp->enable = is_enable;
6463 mp->is_ipv6 = is_ipv6;
6468 /* Wait for a reply... */
6474 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6476 unformat_input_t *i = vam->input;
6477 vl_api_sw_interface_set_l2_xconnect_t *mp;
6479 u8 rx_sw_if_index_set = 0;
6481 u8 tx_sw_if_index_set = 0;
6485 /* Parse args required to build the message */
6486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6488 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6489 rx_sw_if_index_set = 1;
6490 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6491 tx_sw_if_index_set = 1;
6492 else if (unformat (i, "rx"))
6494 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6496 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6498 rx_sw_if_index_set = 1;
6503 else if (unformat (i, "tx"))
6505 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6507 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6509 tx_sw_if_index_set = 1;
6514 else if (unformat (i, "enable"))
6516 else if (unformat (i, "disable"))
6522 if (rx_sw_if_index_set == 0)
6524 errmsg ("missing rx interface name or rx_sw_if_index");
6528 if (enable && (tx_sw_if_index_set == 0))
6530 errmsg ("missing tx interface name or tx_sw_if_index");
6534 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6536 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6537 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6538 mp->enable = enable;
6546 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6548 unformat_input_t *i = vam->input;
6549 vl_api_sw_interface_set_l2_bridge_t *mp;
6550 vl_api_l2_port_type_t port_type;
6552 u8 rx_sw_if_index_set = 0;
6559 port_type = L2_API_PORT_TYPE_NORMAL;
6561 /* Parse args required to build the message */
6562 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6564 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6565 rx_sw_if_index_set = 1;
6566 else if (unformat (i, "bd_id %d", &bd_id))
6570 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6571 rx_sw_if_index_set = 1;
6572 else if (unformat (i, "shg %d", &shg))
6574 else if (unformat (i, "bvi"))
6575 port_type = L2_API_PORT_TYPE_BVI;
6576 else if (unformat (i, "uu-fwd"))
6577 port_type = L2_API_PORT_TYPE_UU_FWD;
6578 else if (unformat (i, "enable"))
6580 else if (unformat (i, "disable"))
6586 if (rx_sw_if_index_set == 0)
6588 errmsg ("missing rx interface name or sw_if_index");
6592 if (enable && (bd_id_set == 0))
6594 errmsg ("missing bridge domain");
6598 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6600 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6601 mp->bd_id = ntohl (bd_id);
6603 mp->port_type = ntohl (port_type);
6604 mp->enable = enable;
6612 api_bridge_domain_dump (vat_main_t * vam)
6614 unformat_input_t *i = vam->input;
6615 vl_api_bridge_domain_dump_t *mp;
6616 vl_api_control_ping_t *mp_ping;
6620 /* Parse args required to build the message */
6621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6623 if (unformat (i, "bd_id %d", &bd_id))
6629 M (BRIDGE_DOMAIN_DUMP, mp);
6630 mp->bd_id = ntohl (bd_id);
6633 /* Use a control ping for synchronization */
6634 MPING (CONTROL_PING, mp_ping);
6642 api_bridge_domain_add_del (vat_main_t * vam)
6644 unformat_input_t *i = vam->input;
6645 vl_api_bridge_domain_add_del_t *mp;
6648 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6653 /* Parse args required to build the message */
6654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6656 if (unformat (i, "bd_id %d", &bd_id))
6658 else if (unformat (i, "flood %d", &flood))
6660 else if (unformat (i, "uu-flood %d", &uu_flood))
6662 else if (unformat (i, "forward %d", &forward))
6664 else if (unformat (i, "learn %d", &learn))
6666 else if (unformat (i, "arp-term %d", &arp_term))
6668 else if (unformat (i, "mac-age %d", &mac_age))
6670 else if (unformat (i, "bd-tag %s", &bd_tag))
6672 else if (unformat (i, "del"))
6675 flood = uu_flood = forward = learn = 0;
6683 errmsg ("missing bridge domain");
6690 errmsg ("mac age must be less than 256 ");
6695 if ((bd_tag) && (vec_len (bd_tag) > 63))
6697 errmsg ("bd-tag cannot be longer than 63");
6702 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6704 mp->bd_id = ntohl (bd_id);
6706 mp->uu_flood = uu_flood;
6707 mp->forward = forward;
6709 mp->arp_term = arp_term;
6710 mp->is_add = is_add;
6711 mp->mac_age = (u8) mac_age;
6714 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6715 mp->bd_tag[vec_len (bd_tag)] = 0;
6726 api_l2fib_flush_bd (vat_main_t * vam)
6728 unformat_input_t *i = vam->input;
6729 vl_api_l2fib_flush_bd_t *mp;
6733 /* Parse args required to build the message */
6734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6736 if (unformat (i, "bd_id %d", &bd_id));
6743 errmsg ("missing bridge domain");
6747 M (L2FIB_FLUSH_BD, mp);
6749 mp->bd_id = htonl (bd_id);
6757 api_l2fib_flush_int (vat_main_t * vam)
6759 unformat_input_t *i = vam->input;
6760 vl_api_l2fib_flush_int_t *mp;
6761 u32 sw_if_index = ~0;
6764 /* Parse args required to build the message */
6765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6767 if (unformat (i, "sw_if_index %d", &sw_if_index));
6769 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6774 if (sw_if_index == ~0)
6776 errmsg ("missing interface name or sw_if_index");
6780 M (L2FIB_FLUSH_INT, mp);
6782 mp->sw_if_index = ntohl (sw_if_index);
6790 api_l2fib_add_del (vat_main_t * vam)
6792 unformat_input_t *i = vam->input;
6793 vl_api_l2fib_add_del_t *mp;
6799 u32 sw_if_index = 0;
6800 u8 sw_if_index_set = 0;
6809 /* Parse args required to build the message */
6810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6812 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6814 else if (unformat (i, "bd_id %d", &bd_id))
6816 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6817 sw_if_index_set = 1;
6818 else if (unformat (i, "sw_if"))
6820 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6823 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6824 sw_if_index_set = 1;
6829 else if (unformat (i, "static"))
6831 else if (unformat (i, "filter"))
6836 else if (unformat (i, "bvi"))
6841 else if (unformat (i, "del"))
6843 else if (unformat (i, "count %d", &count))
6851 errmsg ("missing mac address");
6857 errmsg ("missing bridge domain");
6861 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6863 errmsg ("missing interface name or sw_if_index");
6869 /* Turn on async mode */
6870 vam->async_mode = 1;
6871 vam->async_errors = 0;
6872 before = vat_time_now (vam);
6875 for (j = 0; j < count; j++)
6877 M (L2FIB_ADD_DEL, mp);
6879 clib_memcpy (mp->mac, mac, 6);
6880 mp->bd_id = ntohl (bd_id);
6881 mp->is_add = is_add;
6882 mp->sw_if_index = ntohl (sw_if_index);
6886 mp->static_mac = static_mac;
6887 mp->filter_mac = filter_mac;
6888 mp->bvi_mac = bvi_mac;
6890 increment_mac_address (mac);
6897 vl_api_control_ping_t *mp_ping;
6900 /* Shut off async mode */
6901 vam->async_mode = 0;
6903 MPING (CONTROL_PING, mp_ping);
6906 timeout = vat_time_now (vam) + 1.0;
6907 while (vat_time_now (vam) < timeout)
6908 if (vam->result_ready == 1)
6913 if (vam->retval == -99)
6916 if (vam->async_errors > 0)
6918 errmsg ("%d asynchronous errors", vam->async_errors);
6921 vam->async_errors = 0;
6922 after = vat_time_now (vam);
6924 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6925 count, after - before, count / (after - before));
6931 /* Wait for a reply... */
6935 /* Return the good/bad news */
6936 return (vam->retval);
6940 api_bridge_domain_set_mac_age (vat_main_t * vam)
6942 unformat_input_t *i = vam->input;
6943 vl_api_bridge_domain_set_mac_age_t *mp;
6948 /* Parse args required to build the message */
6949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6951 if (unformat (i, "bd_id %d", &bd_id));
6952 else if (unformat (i, "mac-age %d", &mac_age));
6959 errmsg ("missing bridge domain");
6965 errmsg ("mac age must be less than 256 ");
6969 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6971 mp->bd_id = htonl (bd_id);
6972 mp->mac_age = (u8) mac_age;
6980 api_l2_flags (vat_main_t * vam)
6982 unformat_input_t *i = vam->input;
6983 vl_api_l2_flags_t *mp;
6986 u8 sw_if_index_set = 0;
6990 /* Parse args required to build the message */
6991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6993 if (unformat (i, "sw_if_index %d", &sw_if_index))
6994 sw_if_index_set = 1;
6995 else if (unformat (i, "sw_if"))
6997 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7000 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7001 sw_if_index_set = 1;
7006 else if (unformat (i, "learn"))
7008 else if (unformat (i, "forward"))
7010 else if (unformat (i, "flood"))
7012 else if (unformat (i, "uu-flood"))
7013 flags |= L2_UU_FLOOD;
7014 else if (unformat (i, "arp-term"))
7015 flags |= L2_ARP_TERM;
7016 else if (unformat (i, "off"))
7018 else if (unformat (i, "disable"))
7024 if (sw_if_index_set == 0)
7026 errmsg ("missing interface name or sw_if_index");
7032 mp->sw_if_index = ntohl (sw_if_index);
7033 mp->feature_bitmap = ntohl (flags);
7034 mp->is_set = is_set;
7042 api_bridge_flags (vat_main_t * vam)
7044 unformat_input_t *i = vam->input;
7045 vl_api_bridge_flags_t *mp;
7049 bd_flags_t flags = 0;
7052 /* Parse args required to build the message */
7053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7055 if (unformat (i, "bd_id %d", &bd_id))
7057 else if (unformat (i, "learn"))
7058 flags |= BRIDGE_API_FLAG_LEARN;
7059 else if (unformat (i, "forward"))
7060 flags |= BRIDGE_API_FLAG_FWD;
7061 else if (unformat (i, "flood"))
7062 flags |= BRIDGE_API_FLAG_FLOOD;
7063 else if (unformat (i, "uu-flood"))
7064 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7065 else if (unformat (i, "arp-term"))
7066 flags |= BRIDGE_API_FLAG_ARP_TERM;
7067 else if (unformat (i, "off"))
7069 else if (unformat (i, "disable"))
7077 errmsg ("missing bridge domain");
7081 M (BRIDGE_FLAGS, mp);
7083 mp->bd_id = ntohl (bd_id);
7084 mp->flags = ntohl (flags);
7085 mp->is_set = is_set;
7093 api_bd_ip_mac_add_del (vat_main_t * vam)
7095 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7096 vl_api_mac_address_t mac = { 0 };
7097 unformat_input_t *i = vam->input;
7098 vl_api_bd_ip_mac_add_del_t *mp;
7107 /* Parse args required to build the message */
7108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7110 if (unformat (i, "bd_id %d", &bd_id))
7114 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7118 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7122 else if (unformat (i, "del"))
7130 errmsg ("missing bridge domain");
7133 else if (ip_set == 0)
7135 errmsg ("missing IP address");
7138 else if (mac_set == 0)
7140 errmsg ("missing MAC address");
7144 M (BD_IP_MAC_ADD_DEL, mp);
7146 mp->entry.bd_id = ntohl (bd_id);
7147 mp->is_add = is_add;
7149 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7150 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7158 api_bd_ip_mac_flush (vat_main_t * vam)
7160 unformat_input_t *i = vam->input;
7161 vl_api_bd_ip_mac_flush_t *mp;
7166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7168 if (unformat (i, "bd_id %d", &bd_id))
7178 errmsg ("missing bridge domain");
7182 M (BD_IP_MAC_FLUSH, mp);
7184 mp->bd_id = ntohl (bd_id);
7191 static void vl_api_bd_ip_mac_details_t_handler
7192 (vl_api_bd_ip_mac_details_t * mp)
7194 vat_main_t *vam = &vat_main;
7198 ntohl (mp->entry.bd_id),
7199 format_vl_api_mac_address, mp->entry.mac,
7200 format_vl_api_address, &mp->entry.ip);
7203 static void vl_api_bd_ip_mac_details_t_handler_json
7204 (vl_api_bd_ip_mac_details_t * mp)
7206 vat_main_t *vam = &vat_main;
7207 vat_json_node_t *node = NULL;
7209 if (VAT_JSON_ARRAY != vam->json_tree.type)
7211 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7212 vat_json_init_array (&vam->json_tree);
7214 node = vat_json_array_add (&vam->json_tree);
7216 vat_json_init_object (node);
7217 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7218 vat_json_object_add_string_copy (node, "mac_address",
7219 format (0, "%U", format_vl_api_mac_address,
7223 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7224 vat_json_object_add_string_copy (node, "ip_address", ip);
7229 api_bd_ip_mac_dump (vat_main_t * vam)
7231 unformat_input_t *i = vam->input;
7232 vl_api_bd_ip_mac_dump_t *mp;
7233 vl_api_control_ping_t *mp_ping;
7238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7240 if (unformat (i, "bd_id %d", &bd_id))
7249 "\n%-5s %-7s %-20s %-30s",
7250 "bd_id", "is_ipv6", "mac_address", "ip_address");
7252 /* Dump Bridge Domain Ip to Mac entries */
7253 M (BD_IP_MAC_DUMP, mp);
7256 mp->bd_id = htonl (bd_id);
7262 /* Use a control ping for synchronization */
7263 MPING (CONTROL_PING, mp_ping);
7271 api_tap_create_v2 (vat_main_t * vam)
7273 unformat_input_t *i = vam->input;
7274 vl_api_tap_create_v2_t *mp;
7278 u32 num_rx_queues = 0;
7279 u8 *host_if_name = 0;
7280 u8 host_if_name_set = 0;
7283 u8 host_mac_addr[6];
7284 u8 host_mac_addr_set = 0;
7285 u8 *host_bridge = 0;
7286 u8 host_bridge_set = 0;
7287 u8 host_ip4_prefix_set = 0;
7288 u8 host_ip6_prefix_set = 0;
7289 ip4_address_t host_ip4_addr;
7290 ip4_address_t host_ip4_gw;
7291 u8 host_ip4_gw_set = 0;
7292 u32 host_ip4_prefix_len = 0;
7293 ip6_address_t host_ip6_addr;
7294 ip6_address_t host_ip6_gw;
7295 u8 host_ip6_gw_set = 0;
7296 u32 host_ip6_prefix_len = 0;
7297 u32 host_mtu_size = 0;
7298 u8 host_mtu_set = 0;
7301 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7303 clib_memset (mac_address, 0, sizeof (mac_address));
7305 /* Parse args required to build the message */
7306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7308 if (unformat (i, "id %u", &id))
7312 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7314 else if (unformat (i, "host-if-name %s", &host_if_name))
7315 host_if_name_set = 1;
7316 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
7318 else if (unformat (i, "host-ns %s", &host_ns))
7320 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7322 host_mac_addr_set = 1;
7323 else if (unformat (i, "host-bridge %s", &host_bridge))
7324 host_bridge_set = 1;
7325 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
7326 &host_ip4_addr, &host_ip4_prefix_len))
7327 host_ip4_prefix_set = 1;
7328 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
7329 &host_ip6_addr, &host_ip6_prefix_len))
7330 host_ip6_prefix_set = 1;
7331 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7333 host_ip4_gw_set = 1;
7334 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7336 host_ip6_gw_set = 1;
7337 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7339 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7341 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
7343 else if (unformat (i, "no-gso"))
7344 tap_flags &= ~TAP_FLAG_GSO;
7345 else if (unformat (i, "gso"))
7346 tap_flags |= TAP_FLAG_GSO;
7347 else if (unformat (i, "csum-offload"))
7348 tap_flags |= TAP_FLAG_CSUM_OFFLOAD;
7353 if (vec_len (host_if_name) > 63)
7355 errmsg ("tap name too long. ");
7358 if (vec_len (host_ns) > 63)
7360 errmsg ("host name space too long. ");
7363 if (vec_len (host_bridge) > 63)
7365 errmsg ("host bridge name too long. ");
7368 if (host_ip4_prefix_len > 32)
7370 errmsg ("host ip4 prefix length not valid. ");
7373 if (host_ip6_prefix_len > 128)
7375 errmsg ("host ip6 prefix length not valid. ");
7378 if (!is_pow2 (rx_ring_sz))
7380 errmsg ("rx ring size must be power of 2. ");
7383 if (rx_ring_sz > 32768)
7385 errmsg ("rx ring size must be 32768 or lower. ");
7388 if (!is_pow2 (tx_ring_sz))
7390 errmsg ("tx ring size must be power of 2. ");
7393 if (tx_ring_sz > 32768)
7395 errmsg ("tx ring size must be 32768 or lower. ");
7398 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7400 errmsg ("host MTU size must be in between 64 and 65355. ");
7404 /* Construct the API message */
7405 M (TAP_CREATE_V2, mp);
7407 mp->id = ntohl (id);
7408 mp->use_random_mac = random_mac;
7409 mp->num_rx_queues = (u8) num_rx_queues;
7410 mp->tx_ring_sz = ntohs (tx_ring_sz);
7411 mp->rx_ring_sz = ntohs (rx_ring_sz);
7412 mp->host_mtu_set = host_mtu_set;
7413 mp->host_mtu_size = ntohl (host_mtu_size);
7414 mp->host_mac_addr_set = host_mac_addr_set;
7415 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7416 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7417 mp->host_ip4_gw_set = host_ip4_gw_set;
7418 mp->host_ip6_gw_set = host_ip6_gw_set;
7419 mp->tap_flags = ntohl (tap_flags);
7420 mp->host_namespace_set = host_ns_set;
7421 mp->host_if_name_set = host_if_name_set;
7422 mp->host_bridge_set = host_bridge_set;
7424 if (random_mac == 0)
7425 clib_memcpy (mp->mac_address, mac_address, 6);
7426 if (host_mac_addr_set)
7427 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7428 if (host_if_name_set)
7429 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7431 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7432 if (host_bridge_set)
7433 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7434 if (host_ip4_prefix_set)
7436 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7437 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7439 if (host_ip6_prefix_set)
7441 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7442 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7444 if (host_ip4_gw_set)
7445 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7446 if (host_ip6_gw_set)
7447 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7450 vec_free (host_if_name);
7451 vec_free (host_bridge);
7456 /* Wait for a reply... */
7462 api_tap_delete_v2 (vat_main_t * vam)
7464 unformat_input_t *i = vam->input;
7465 vl_api_tap_delete_v2_t *mp;
7466 u32 sw_if_index = ~0;
7467 u8 sw_if_index_set = 0;
7470 /* Parse args required to build the message */
7471 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7473 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7474 sw_if_index_set = 1;
7475 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7476 sw_if_index_set = 1;
7481 if (sw_if_index_set == 0)
7483 errmsg ("missing vpp interface name. ");
7487 /* Construct the API message */
7488 M (TAP_DELETE_V2, mp);
7490 mp->sw_if_index = ntohl (sw_if_index);
7495 /* Wait for a reply... */
7501 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7503 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7506 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7509 addr->domain = x[0];
7512 addr->function = x[3];
7518 api_virtio_pci_create (vat_main_t * vam)
7520 unformat_input_t *i = vam->input;
7521 vl_api_virtio_pci_create_t *mp;
7525 u8 checksum_offload_enabled = 0;
7527 u64 features = (u64) ~ (0ULL);
7530 clib_memset (mac_address, 0, sizeof (mac_address));
7532 /* Parse args required to build the message */
7533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7535 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7539 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7541 else if (unformat (i, "features 0x%llx", &features))
7543 else if (unformat (i, "gso-enabled"))
7545 else if (unformat (i, "csum-offload-enabled"))
7546 checksum_offload_enabled = 1;
7553 errmsg ("pci address must be non zero. ");
7557 /* Construct the API message */
7558 M (VIRTIO_PCI_CREATE, mp);
7560 mp->use_random_mac = random_mac;
7562 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7563 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7564 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7565 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7567 mp->features = clib_host_to_net_u64 (features);
7568 mp->gso_enabled = gso_enabled;
7569 mp->checksum_offload_enabled = checksum_offload_enabled;
7571 if (random_mac == 0)
7572 clib_memcpy (mp->mac_address, mac_address, 6);
7577 /* Wait for a reply... */
7583 api_virtio_pci_delete (vat_main_t * vam)
7585 unformat_input_t *i = vam->input;
7586 vl_api_virtio_pci_delete_t *mp;
7587 u32 sw_if_index = ~0;
7588 u8 sw_if_index_set = 0;
7591 /* Parse args required to build the message */
7592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7594 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7595 sw_if_index_set = 1;
7596 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7597 sw_if_index_set = 1;
7602 if (sw_if_index_set == 0)
7604 errmsg ("missing vpp interface name. ");
7608 /* Construct the API message */
7609 M (VIRTIO_PCI_DELETE, mp);
7611 mp->sw_if_index = htonl (sw_if_index);
7616 /* Wait for a reply... */
7622 api_bond_create (vat_main_t * vam)
7624 unformat_input_t *i = vam->input;
7625 vl_api_bond_create_t *mp;
7635 clib_memset (mac_address, 0, sizeof (mac_address));
7638 /* Parse args required to build the message */
7639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7641 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7643 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7644 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7646 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7649 else if (unformat (i, "numa-only"))
7651 else if (unformat (i, "id %u", &id))
7657 if (mode_is_set == 0)
7659 errmsg ("Missing bond mode. ");
7663 /* Construct the API message */
7664 M (BOND_CREATE, mp);
7666 mp->use_custom_mac = custom_mac;
7668 mp->mode = htonl (mode);
7669 mp->lb = htonl (lb);
7670 mp->id = htonl (id);
7671 mp->numa_only = numa_only;
7674 clib_memcpy (mp->mac_address, mac_address, 6);
7679 /* Wait for a reply... */
7685 api_bond_delete (vat_main_t * vam)
7687 unformat_input_t *i = vam->input;
7688 vl_api_bond_delete_t *mp;
7689 u32 sw_if_index = ~0;
7690 u8 sw_if_index_set = 0;
7693 /* Parse args required to build the message */
7694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7696 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7697 sw_if_index_set = 1;
7698 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7699 sw_if_index_set = 1;
7704 if (sw_if_index_set == 0)
7706 errmsg ("missing vpp interface name. ");
7710 /* Construct the API message */
7711 M (BOND_DELETE, mp);
7713 mp->sw_if_index = ntohl (sw_if_index);
7718 /* Wait for a reply... */
7724 api_bond_enslave (vat_main_t * vam)
7726 unformat_input_t *i = vam->input;
7727 vl_api_bond_enslave_t *mp;
7728 u32 bond_sw_if_index;
7732 u32 bond_sw_if_index_is_set = 0;
7734 u8 sw_if_index_is_set = 0;
7736 /* Parse args required to build the message */
7737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7739 if (unformat (i, "sw_if_index %d", &sw_if_index))
7740 sw_if_index_is_set = 1;
7741 else if (unformat (i, "bond %u", &bond_sw_if_index))
7742 bond_sw_if_index_is_set = 1;
7743 else if (unformat (i, "passive %d", &is_passive))
7745 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7751 if (bond_sw_if_index_is_set == 0)
7753 errmsg ("Missing bond sw_if_index. ");
7756 if (sw_if_index_is_set == 0)
7758 errmsg ("Missing slave sw_if_index. ");
7762 /* Construct the API message */
7763 M (BOND_ENSLAVE, mp);
7765 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7766 mp->sw_if_index = ntohl (sw_if_index);
7767 mp->is_long_timeout = is_long_timeout;
7768 mp->is_passive = is_passive;
7773 /* Wait for a reply... */
7779 api_bond_detach_slave (vat_main_t * vam)
7781 unformat_input_t *i = vam->input;
7782 vl_api_bond_detach_slave_t *mp;
7783 u32 sw_if_index = ~0;
7784 u8 sw_if_index_set = 0;
7787 /* Parse args required to build the message */
7788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7790 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7791 sw_if_index_set = 1;
7792 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7793 sw_if_index_set = 1;
7798 if (sw_if_index_set == 0)
7800 errmsg ("missing vpp interface name. ");
7804 /* Construct the API message */
7805 M (BOND_DETACH_SLAVE, mp);
7807 mp->sw_if_index = ntohl (sw_if_index);
7812 /* Wait for a reply... */
7818 api_ip_table_add_del (vat_main_t * vam)
7820 unformat_input_t *i = vam->input;
7821 vl_api_ip_table_add_del_t *mp;
7827 /* Parse args required to build the message */
7828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7830 if (unformat (i, "ipv6"))
7832 else if (unformat (i, "del"))
7834 else if (unformat (i, "add"))
7836 else if (unformat (i, "table %d", &table_id))
7840 clib_warning ("parse error '%U'", format_unformat_error, i);
7847 errmsg ("missing table-ID");
7851 /* Construct the API message */
7852 M (IP_TABLE_ADD_DEL, mp);
7854 mp->table.table_id = ntohl (table_id);
7855 mp->table.is_ip6 = is_ipv6;
7856 mp->is_add = is_add;
7861 /* Wait for a reply... */
7868 unformat_fib_path (unformat_input_t * input, va_list * args)
7870 vat_main_t *vam = va_arg (*args, vat_main_t *);
7871 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7872 u32 weight, preference;
7873 mpls_label_t out_label;
7875 clib_memset (path, 0, sizeof (*path));
7877 path->sw_if_index = ~0;
7881 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7883 if (unformat (input, "%U %U",
7884 unformat_vl_api_ip4_address,
7885 &path->nh.address.ip4,
7886 api_unformat_sw_if_index, vam, &path->sw_if_index))
7888 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7890 else if (unformat (input, "%U %U",
7891 unformat_vl_api_ip6_address,
7892 &path->nh.address.ip6,
7893 api_unformat_sw_if_index, vam, &path->sw_if_index))
7895 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7897 else if (unformat (input, "weight %u", &weight))
7899 path->weight = weight;
7901 else if (unformat (input, "preference %u", &preference))
7903 path->preference = preference;
7905 else if (unformat (input, "%U next-hop-table %d",
7906 unformat_vl_api_ip4_address,
7907 &path->nh.address.ip4, &path->table_id))
7909 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7911 else if (unformat (input, "%U next-hop-table %d",
7912 unformat_vl_api_ip6_address,
7913 &path->nh.address.ip6, &path->table_id))
7915 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7917 else if (unformat (input, "%U",
7918 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7921 * the recursive next-hops are by default in the default table
7924 path->sw_if_index = ~0;
7925 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7927 else if (unformat (input, "%U",
7928 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7931 * the recursive next-hops are by default in the default table
7934 path->sw_if_index = ~0;
7935 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7937 else if (unformat (input, "resolve-via-host"))
7939 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7941 else if (unformat (input, "resolve-via-attached"))
7943 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7945 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7947 path->type = FIB_API_PATH_TYPE_LOCAL;
7948 path->sw_if_index = ~0;
7949 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7951 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7953 path->type = FIB_API_PATH_TYPE_LOCAL;
7954 path->sw_if_index = ~0;
7955 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7957 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7959 else if (unformat (input, "via-label %d", &path->nh.via_label))
7961 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7962 path->sw_if_index = ~0;
7964 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7966 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7967 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7969 else if (unformat (input, "local"))
7971 path->type = FIB_API_PATH_TYPE_LOCAL;
7973 else if (unformat (input, "out-labels"))
7975 while (unformat (input, "%d", &out_label))
7977 path->label_stack[path->n_labels].label = out_label;
7978 path->label_stack[path->n_labels].is_uniform = 0;
7979 path->label_stack[path->n_labels].ttl = 64;
7983 else if (unformat (input, "via"))
7985 /* new path, back up and return */
7986 unformat_put_input (input);
7987 unformat_put_input (input);
7988 unformat_put_input (input);
7989 unformat_put_input (input);
7998 path->proto = ntohl (path->proto);
7999 path->type = ntohl (path->type);
8000 path->flags = ntohl (path->flags);
8001 path->table_id = ntohl (path->table_id);
8002 path->sw_if_index = ntohl (path->sw_if_index);
8008 api_ip_route_add_del (vat_main_t * vam)
8010 unformat_input_t *i = vam->input;
8011 vl_api_ip_route_add_del_t *mp;
8014 u8 is_multipath = 0;
8017 vl_api_prefix_t pfx = { };
8018 vl_api_fib_path_t paths[8];
8022 u32 random_add_del = 0;
8023 u32 *random_vector = 0;
8024 u32 random_seed = 0xdeaddabe;
8026 /* Parse args required to build the message */
8027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8029 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8031 else if (unformat (i, "del"))
8033 else if (unformat (i, "add"))
8035 else if (unformat (i, "vrf %d", &vrf_id))
8037 else if (unformat (i, "count %d", &count))
8039 else if (unformat (i, "random"))
8041 else if (unformat (i, "multipath"))
8043 else if (unformat (i, "seed %d", &random_seed))
8047 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8050 if (8 == path_count)
8052 errmsg ("max 8 paths");
8058 clib_warning ("parse error '%U'", format_unformat_error, i);
8065 errmsg ("specify a path; via ...");
8068 if (prefix_set == 0)
8070 errmsg ("missing prefix");
8074 /* Generate a pile of unique, random routes */
8077 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8078 u32 this_random_address;
8081 random_hash = hash_create (count, sizeof (uword));
8083 hash_set (random_hash, i->as_u32, 1);
8084 for (j = 0; j <= count; j++)
8088 this_random_address = random_u32 (&random_seed);
8089 this_random_address =
8090 clib_host_to_net_u32 (this_random_address);
8092 while (hash_get (random_hash, this_random_address));
8093 vec_add1 (random_vector, this_random_address);
8094 hash_set (random_hash, this_random_address, 1);
8096 hash_free (random_hash);
8097 set_ip4_address (&pfx.address, random_vector[0]);
8102 /* Turn on async mode */
8103 vam->async_mode = 1;
8104 vam->async_errors = 0;
8105 before = vat_time_now (vam);
8108 for (j = 0; j < count; j++)
8110 /* Construct the API message */
8111 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8113 mp->is_add = is_add;
8114 mp->is_multipath = is_multipath;
8116 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8117 mp->route.table_id = ntohl (vrf_id);
8118 mp->route.n_paths = path_count;
8120 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8123 set_ip4_address (&pfx.address, random_vector[j + 1]);
8125 increment_address (&pfx.address);
8128 /* If we receive SIGTERM, stop now... */
8133 /* When testing multiple add/del ops, use a control-ping to sync */
8136 vl_api_control_ping_t *mp_ping;
8140 /* Shut off async mode */
8141 vam->async_mode = 0;
8143 MPING (CONTROL_PING, mp_ping);
8146 timeout = vat_time_now (vam) + 1.0;
8147 while (vat_time_now (vam) < timeout)
8148 if (vam->result_ready == 1)
8153 if (vam->retval == -99)
8156 if (vam->async_errors > 0)
8158 errmsg ("%d asynchronous errors", vam->async_errors);
8161 vam->async_errors = 0;
8162 after = vat_time_now (vam);
8164 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8168 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8169 count, after - before, count / (after - before));
8175 /* Wait for a reply... */
8180 /* Return the good/bad news */
8181 return (vam->retval);
8185 api_ip_mroute_add_del (vat_main_t * vam)
8187 unformat_input_t *i = vam->input;
8188 u8 path_set = 0, prefix_set = 0, is_add = 1;
8189 vl_api_ip_mroute_add_del_t *mp;
8190 mfib_entry_flags_t eflags = 0;
8191 vl_api_mfib_path_t path;
8192 vl_api_mprefix_t pfx = { };
8196 /* Parse args required to build the message */
8197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8199 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8202 pfx.grp_address_length = htons (pfx.grp_address_length);
8204 else if (unformat (i, "del"))
8206 else if (unformat (i, "add"))
8208 else if (unformat (i, "vrf %d", &vrf_id))
8210 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8211 path.itf_flags = htonl (path.itf_flags);
8212 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8214 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8218 clib_warning ("parse error '%U'", format_unformat_error, i);
8223 if (prefix_set == 0)
8225 errmsg ("missing addresses\n");
8230 errmsg ("missing path\n");
8234 /* Construct the API message */
8235 M (IP_MROUTE_ADD_DEL, mp);
8237 mp->is_add = is_add;
8238 mp->is_multipath = 1;
8240 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8241 mp->route.table_id = htonl (vrf_id);
8242 mp->route.n_paths = 1;
8243 mp->route.entry_flags = htonl (eflags);
8245 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8249 /* Wait for a reply... */
8255 api_mpls_table_add_del (vat_main_t * vam)
8257 unformat_input_t *i = vam->input;
8258 vl_api_mpls_table_add_del_t *mp;
8263 /* Parse args required to build the message */
8264 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8266 if (unformat (i, "table %d", &table_id))
8268 else if (unformat (i, "del"))
8270 else if (unformat (i, "add"))
8274 clib_warning ("parse error '%U'", format_unformat_error, i);
8281 errmsg ("missing table-ID");
8285 /* Construct the API message */
8286 M (MPLS_TABLE_ADD_DEL, mp);
8288 mp->mt_table.mt_table_id = ntohl (table_id);
8289 mp->mt_is_add = is_add;
8294 /* Wait for a reply... */
8301 api_mpls_route_add_del (vat_main_t * vam)
8303 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8304 mpls_label_t local_label = MPLS_LABEL_INVALID;
8305 unformat_input_t *i = vam->input;
8306 vl_api_mpls_route_add_del_t *mp;
8307 vl_api_fib_path_t paths[8];
8311 /* Parse args required to build the message */
8312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8314 if (unformat (i, "%d", &local_label))
8316 else if (unformat (i, "eos"))
8318 else if (unformat (i, "non-eos"))
8320 else if (unformat (i, "del"))
8322 else if (unformat (i, "add"))
8324 else if (unformat (i, "multipath"))
8326 else if (unformat (i, "count %d", &count))
8330 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8333 if (8 == path_count)
8335 errmsg ("max 8 paths");
8341 clib_warning ("parse error '%U'", format_unformat_error, i);
8348 errmsg ("specify a path; via ...");
8352 if (MPLS_LABEL_INVALID == local_label)
8354 errmsg ("missing label");
8360 /* Turn on async mode */
8361 vam->async_mode = 1;
8362 vam->async_errors = 0;
8363 before = vat_time_now (vam);
8366 for (j = 0; j < count; j++)
8368 /* Construct the API message */
8369 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8371 mp->mr_is_add = is_add;
8372 mp->mr_is_multipath = is_multipath;
8374 mp->mr_route.mr_label = local_label;
8375 mp->mr_route.mr_eos = is_eos;
8376 mp->mr_route.mr_table_id = 0;
8377 mp->mr_route.mr_n_paths = path_count;
8379 clib_memcpy (&mp->mr_route.mr_paths, paths,
8380 sizeof (paths[0]) * path_count);
8386 /* If we receive SIGTERM, stop now... */
8391 /* When testing multiple add/del ops, use a control-ping to sync */
8394 vl_api_control_ping_t *mp_ping;
8398 /* Shut off async mode */
8399 vam->async_mode = 0;
8401 MPING (CONTROL_PING, mp_ping);
8404 timeout = vat_time_now (vam) + 1.0;
8405 while (vat_time_now (vam) < timeout)
8406 if (vam->result_ready == 1)
8411 if (vam->retval == -99)
8414 if (vam->async_errors > 0)
8416 errmsg ("%d asynchronous errors", vam->async_errors);
8419 vam->async_errors = 0;
8420 after = vat_time_now (vam);
8422 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8426 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8427 count, after - before, count / (after - before));
8433 /* Wait for a reply... */
8438 /* Return the good/bad news */
8439 return (vam->retval);
8444 api_mpls_ip_bind_unbind (vat_main_t * vam)
8446 unformat_input_t *i = vam->input;
8447 vl_api_mpls_ip_bind_unbind_t *mp;
8448 u32 ip_table_id = 0;
8450 vl_api_prefix_t pfx;
8452 mpls_label_t local_label = MPLS_LABEL_INVALID;
8455 /* Parse args required to build the message */
8456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8458 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8460 else if (unformat (i, "%d", &local_label))
8462 else if (unformat (i, "table-id %d", &ip_table_id))
8464 else if (unformat (i, "unbind"))
8466 else if (unformat (i, "bind"))
8470 clib_warning ("parse error '%U'", format_unformat_error, i);
8477 errmsg ("IP prefix not set");
8481 if (MPLS_LABEL_INVALID == local_label)
8483 errmsg ("missing label");
8487 /* Construct the API message */
8488 M (MPLS_IP_BIND_UNBIND, mp);
8490 mp->mb_is_bind = is_bind;
8491 mp->mb_ip_table_id = ntohl (ip_table_id);
8492 mp->mb_mpls_table_id = 0;
8493 mp->mb_label = ntohl (local_label);
8494 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8499 /* Wait for a reply... */
8506 api_sr_mpls_policy_add (vat_main_t * vam)
8508 unformat_input_t *i = vam->input;
8509 vl_api_sr_mpls_policy_add_t *mp;
8515 u32 *segments = NULL;
8518 /* Parse args required to build the message */
8519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8521 if (unformat (i, "bsid %d", &bsid))
8523 else if (unformat (i, "weight %d", &weight))
8525 else if (unformat (i, "spray"))
8527 else if (unformat (i, "next %d", &sid))
8530 vec_add1 (segments, htonl (sid));
8534 clib_warning ("parse error '%U'", format_unformat_error, i);
8541 errmsg ("bsid not set");
8545 if (n_segments == 0)
8547 errmsg ("no sid in segment stack");
8551 /* Construct the API message */
8552 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8554 mp->bsid = htonl (bsid);
8555 mp->weight = htonl (weight);
8557 mp->n_segments = n_segments;
8558 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8559 vec_free (segments);
8564 /* Wait for a reply... */
8570 api_sr_mpls_policy_del (vat_main_t * vam)
8572 unformat_input_t *i = vam->input;
8573 vl_api_sr_mpls_policy_del_t *mp;
8577 /* Parse args required to build the message */
8578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8580 if (unformat (i, "bsid %d", &bsid))
8584 clib_warning ("parse error '%U'", format_unformat_error, i);
8591 errmsg ("bsid not set");
8595 /* Construct the API message */
8596 M (SR_MPLS_POLICY_DEL, mp);
8598 mp->bsid = htonl (bsid);
8603 /* Wait for a reply... */
8609 api_bier_table_add_del (vat_main_t * vam)
8611 unformat_input_t *i = vam->input;
8612 vl_api_bier_table_add_del_t *mp;
8614 u32 set = 0, sub_domain = 0, hdr_len = 3;
8615 mpls_label_t local_label = MPLS_LABEL_INVALID;
8618 /* Parse args required to build the message */
8619 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8621 if (unformat (i, "sub-domain %d", &sub_domain))
8623 else if (unformat (i, "set %d", &set))
8625 else if (unformat (i, "label %d", &local_label))
8627 else if (unformat (i, "hdr-len %d", &hdr_len))
8629 else if (unformat (i, "add"))
8631 else if (unformat (i, "del"))
8635 clib_warning ("parse error '%U'", format_unformat_error, i);
8640 if (MPLS_LABEL_INVALID == local_label)
8642 errmsg ("missing label\n");
8646 /* Construct the API message */
8647 M (BIER_TABLE_ADD_DEL, mp);
8649 mp->bt_is_add = is_add;
8650 mp->bt_label = ntohl (local_label);
8651 mp->bt_tbl_id.bt_set = set;
8652 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8653 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8658 /* Wait for a reply... */
8665 api_bier_route_add_del (vat_main_t * vam)
8667 unformat_input_t *i = vam->input;
8668 vl_api_bier_route_add_del_t *mp;
8670 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8671 ip4_address_t v4_next_hop_address;
8672 ip6_address_t v6_next_hop_address;
8673 u8 next_hop_set = 0;
8674 u8 next_hop_proto_is_ip4 = 1;
8675 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8678 /* Parse args required to build the message */
8679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8681 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8683 next_hop_proto_is_ip4 = 1;
8686 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8688 next_hop_proto_is_ip4 = 0;
8691 if (unformat (i, "sub-domain %d", &sub_domain))
8693 else if (unformat (i, "set %d", &set))
8695 else if (unformat (i, "hdr-len %d", &hdr_len))
8697 else if (unformat (i, "bp %d", &bp))
8699 else if (unformat (i, "add"))
8701 else if (unformat (i, "del"))
8703 else if (unformat (i, "out-label %d", &next_hop_out_label))
8707 clib_warning ("parse error '%U'", format_unformat_error, i);
8712 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8714 errmsg ("next hop / label set\n");
8719 errmsg ("bit=position not set\n");
8723 /* Construct the API message */
8724 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8726 mp->br_is_add = is_add;
8727 mp->br_route.br_tbl_id.bt_set = set;
8728 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8729 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8730 mp->br_route.br_bp = ntohs (bp);
8731 mp->br_route.br_n_paths = 1;
8732 mp->br_route.br_paths[0].n_labels = 1;
8733 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8734 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8735 FIB_API_PATH_NH_PROTO_IP4 :
8736 FIB_API_PATH_NH_PROTO_IP6);
8738 if (next_hop_proto_is_ip4)
8740 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8741 &v4_next_hop_address, sizeof (v4_next_hop_address));
8745 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8746 &v6_next_hop_address, sizeof (v6_next_hop_address));
8752 /* Wait for a reply... */
8759 api_mpls_tunnel_add_del (vat_main_t * vam)
8761 unformat_input_t *i = vam->input;
8762 vl_api_mpls_tunnel_add_del_t *mp;
8764 vl_api_fib_path_t paths[8];
8765 u32 sw_if_index = ~0;
8771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8773 if (unformat (i, "add"))
8777 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8779 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8781 else if (unformat (i, "l2-only"))
8785 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8788 if (8 == path_count)
8790 errmsg ("max 8 paths");
8796 clib_warning ("parse error '%U'", format_unformat_error, i);
8801 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8803 mp->mt_is_add = is_add;
8804 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8805 mp->mt_tunnel.mt_l2_only = l2_only;
8806 mp->mt_tunnel.mt_is_multicast = 0;
8807 mp->mt_tunnel.mt_n_paths = path_count;
8809 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8810 sizeof (paths[0]) * path_count);
8818 api_sw_interface_set_unnumbered (vat_main_t * vam)
8820 unformat_input_t *i = vam->input;
8821 vl_api_sw_interface_set_unnumbered_t *mp;
8823 u32 unnum_sw_index = ~0;
8825 u8 sw_if_index_set = 0;
8828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8830 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8831 sw_if_index_set = 1;
8832 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8833 sw_if_index_set = 1;
8834 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8836 else if (unformat (i, "del"))
8840 clib_warning ("parse error '%U'", format_unformat_error, i);
8845 if (sw_if_index_set == 0)
8847 errmsg ("missing interface name or sw_if_index");
8851 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8853 mp->sw_if_index = ntohl (sw_if_index);
8854 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8855 mp->is_add = is_add;
8864 api_create_vlan_subif (vat_main_t * vam)
8866 unformat_input_t *i = vam->input;
8867 vl_api_create_vlan_subif_t *mp;
8869 u8 sw_if_index_set = 0;
8874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8876 if (unformat (i, "sw_if_index %d", &sw_if_index))
8877 sw_if_index_set = 1;
8879 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8880 sw_if_index_set = 1;
8881 else if (unformat (i, "vlan %d", &vlan_id))
8885 clib_warning ("parse error '%U'", format_unformat_error, i);
8890 if (sw_if_index_set == 0)
8892 errmsg ("missing interface name or sw_if_index");
8896 if (vlan_id_set == 0)
8898 errmsg ("missing vlan_id");
8901 M (CREATE_VLAN_SUBIF, mp);
8903 mp->sw_if_index = ntohl (sw_if_index);
8904 mp->vlan_id = ntohl (vlan_id);
8911 #define foreach_create_subif_bit \
8918 _(outer_vlan_id_any) \
8919 _(inner_vlan_id_any)
8921 #define foreach_create_subif_flag \
8926 _(4, "exact_match") \
8927 _(5, "default_sub") \
8928 _(6, "outer_vlan_id_any") \
8929 _(7, "inner_vlan_id_any")
8932 api_create_subif (vat_main_t * vam)
8934 unformat_input_t *i = vam->input;
8935 vl_api_create_subif_t *mp;
8937 u8 sw_if_index_set = 0;
8940 u32 __attribute__ ((unused)) no_tags = 0;
8941 u32 __attribute__ ((unused)) one_tag = 0;
8942 u32 __attribute__ ((unused)) two_tags = 0;
8943 u32 __attribute__ ((unused)) dot1ad = 0;
8944 u32 __attribute__ ((unused)) exact_match = 0;
8945 u32 __attribute__ ((unused)) default_sub = 0;
8946 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8947 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8949 u16 outer_vlan_id = 0;
8950 u16 inner_vlan_id = 0;
8953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8955 if (unformat (i, "sw_if_index %d", &sw_if_index))
8956 sw_if_index_set = 1;
8958 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8959 sw_if_index_set = 1;
8960 else if (unformat (i, "sub_id %d", &sub_id))
8962 else if (unformat (i, "outer_vlan_id %d", &tmp))
8963 outer_vlan_id = tmp;
8964 else if (unformat (i, "inner_vlan_id %d", &tmp))
8965 inner_vlan_id = tmp;
8967 #define _(a) else if (unformat (i, #a)) a = 1 ;
8968 foreach_create_subif_bit
8972 clib_warning ("parse error '%U'", format_unformat_error, i);
8977 if (sw_if_index_set == 0)
8979 errmsg ("missing interface name or sw_if_index");
8983 if (sub_id_set == 0)
8985 errmsg ("missing sub_id");
8988 M (CREATE_SUBIF, mp);
8990 mp->sw_if_index = ntohl (sw_if_index);
8991 mp->sub_id = ntohl (sub_id);
8993 #define _(a,b) mp->sub_if_flags |= (1 << a);
8994 foreach_create_subif_flag;
8997 mp->outer_vlan_id = ntohs (outer_vlan_id);
8998 mp->inner_vlan_id = ntohs (inner_vlan_id);
9006 api_ip_table_replace_begin (vat_main_t * vam)
9008 unformat_input_t *i = vam->input;
9009 vl_api_ip_table_replace_begin_t *mp;
9014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9016 if (unformat (i, "table %d", &table_id))
9018 else if (unformat (i, "ipv6"))
9022 clib_warning ("parse error '%U'", format_unformat_error, i);
9027 M (IP_TABLE_REPLACE_BEGIN, mp);
9029 mp->table.table_id = ntohl (table_id);
9030 mp->table.is_ip6 = is_ipv6;
9038 api_ip_table_flush (vat_main_t * vam)
9040 unformat_input_t *i = vam->input;
9041 vl_api_ip_table_flush_t *mp;
9046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9048 if (unformat (i, "table %d", &table_id))
9050 else if (unformat (i, "ipv6"))
9054 clib_warning ("parse error '%U'", format_unformat_error, i);
9059 M (IP_TABLE_FLUSH, mp);
9061 mp->table.table_id = ntohl (table_id);
9062 mp->table.is_ip6 = is_ipv6;
9070 api_ip_table_replace_end (vat_main_t * vam)
9072 unformat_input_t *i = vam->input;
9073 vl_api_ip_table_replace_end_t *mp;
9078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9080 if (unformat (i, "table %d", &table_id))
9082 else if (unformat (i, "ipv6"))
9086 clib_warning ("parse error '%U'", format_unformat_error, i);
9091 M (IP_TABLE_REPLACE_END, mp);
9093 mp->table.table_id = ntohl (table_id);
9094 mp->table.is_ip6 = is_ipv6;
9102 api_set_ip_flow_hash (vat_main_t * vam)
9104 unformat_input_t *i = vam->input;
9105 vl_api_set_ip_flow_hash_t *mp;
9117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9119 if (unformat (i, "vrf %d", &vrf_id))
9121 else if (unformat (i, "ipv6"))
9123 else if (unformat (i, "src"))
9125 else if (unformat (i, "dst"))
9127 else if (unformat (i, "sport"))
9129 else if (unformat (i, "dport"))
9131 else if (unformat (i, "proto"))
9133 else if (unformat (i, "reverse"))
9138 clib_warning ("parse error '%U'", format_unformat_error, i);
9143 if (vrf_id_set == 0)
9145 errmsg ("missing vrf id");
9149 M (SET_IP_FLOW_HASH, mp);
9155 mp->reverse = reverse;
9156 mp->vrf_id = ntohl (vrf_id);
9157 mp->is_ipv6 = is_ipv6;
9165 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9167 unformat_input_t *i = vam->input;
9168 vl_api_sw_interface_ip6_enable_disable_t *mp;
9170 u8 sw_if_index_set = 0;
9174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9176 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9177 sw_if_index_set = 1;
9178 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9179 sw_if_index_set = 1;
9180 else if (unformat (i, "enable"))
9182 else if (unformat (i, "disable"))
9186 clib_warning ("parse error '%U'", format_unformat_error, i);
9191 if (sw_if_index_set == 0)
9193 errmsg ("missing interface name or sw_if_index");
9197 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9199 mp->sw_if_index = ntohl (sw_if_index);
9200 mp->enable = enable;
9209 api_l2_patch_add_del (vat_main_t * vam)
9211 unformat_input_t *i = vam->input;
9212 vl_api_l2_patch_add_del_t *mp;
9214 u8 rx_sw_if_index_set = 0;
9216 u8 tx_sw_if_index_set = 0;
9220 /* Parse args required to build the message */
9221 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9223 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9224 rx_sw_if_index_set = 1;
9225 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9226 tx_sw_if_index_set = 1;
9227 else if (unformat (i, "rx"))
9229 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9231 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9233 rx_sw_if_index_set = 1;
9238 else if (unformat (i, "tx"))
9240 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9242 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9244 tx_sw_if_index_set = 1;
9249 else if (unformat (i, "del"))
9255 if (rx_sw_if_index_set == 0)
9257 errmsg ("missing rx interface name or rx_sw_if_index");
9261 if (tx_sw_if_index_set == 0)
9263 errmsg ("missing tx interface name or tx_sw_if_index");
9267 M (L2_PATCH_ADD_DEL, mp);
9269 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9270 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9271 mp->is_add = is_add;
9279 u8 localsid_addr[16];
9288 api_sr_localsid_add_del (vat_main_t * vam)
9290 unformat_input_t *i = vam->input;
9291 vl_api_sr_localsid_add_del_t *mp;
9294 ip6_address_t localsid;
9298 u32 fib_table = ~(u32) 0;
9299 ip6_address_t nh_addr6;
9300 ip4_address_t nh_addr4;
9301 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9302 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9304 bool nexthop_set = 0;
9308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9310 if (unformat (i, "del"))
9312 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9313 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9315 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9317 else if (unformat (i, "behavior %u", &behavior));
9318 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9319 else if (unformat (i, "fib-table %u", &fib_table));
9320 else if (unformat (i, "end.psp %u", &behavior));
9325 M (SR_LOCALSID_ADD_DEL, mp);
9327 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9331 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9332 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9334 mp->behavior = behavior;
9335 mp->sw_if_index = ntohl (sw_if_index);
9336 mp->fib_table = ntohl (fib_table);
9337 mp->end_psp = end_psp;
9338 mp->is_del = is_del;
9346 api_ioam_enable (vat_main_t * vam)
9348 unformat_input_t *input = vam->input;
9349 vl_api_ioam_enable_t *mp;
9351 int has_trace_option = 0;
9352 int has_pot_option = 0;
9353 int has_seqno_option = 0;
9354 int has_analyse_option = 0;
9357 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9359 if (unformat (input, "trace"))
9360 has_trace_option = 1;
9361 else if (unformat (input, "pot"))
9363 else if (unformat (input, "seqno"))
9364 has_seqno_option = 1;
9365 else if (unformat (input, "analyse"))
9366 has_analyse_option = 1;
9370 M (IOAM_ENABLE, mp);
9371 mp->id = htons (id);
9372 mp->seqno = has_seqno_option;
9373 mp->analyse = has_analyse_option;
9374 mp->pot_enable = has_pot_option;
9375 mp->trace_enable = has_trace_option;
9384 api_ioam_disable (vat_main_t * vam)
9386 vl_api_ioam_disable_t *mp;
9389 M (IOAM_DISABLE, mp);
9395 #define foreach_tcp_proto_field \
9399 #define foreach_udp_proto_field \
9403 #define foreach_ip4_proto_field \
9415 u16 src_port, dst_port;
9418 #if VPP_API_TEST_BUILTIN == 0
9420 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9422 u8 **maskp = va_arg (*args, u8 **);
9424 u8 found_something = 0;
9427 #define _(a) u8 a=0;
9428 foreach_tcp_proto_field;
9431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9434 #define _(a) else if (unformat (input, #a)) a=1;
9435 foreach_tcp_proto_field
9441 #define _(a) found_something += a;
9442 foreach_tcp_proto_field;
9445 if (found_something == 0)
9448 vec_validate (mask, sizeof (*tcp) - 1);
9450 tcp = (tcp_header_t *) mask;
9452 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9453 foreach_tcp_proto_field;
9461 unformat_udp_mask (unformat_input_t * input, va_list * args)
9463 u8 **maskp = va_arg (*args, u8 **);
9465 u8 found_something = 0;
9468 #define _(a) u8 a=0;
9469 foreach_udp_proto_field;
9472 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9475 #define _(a) else if (unformat (input, #a)) a=1;
9476 foreach_udp_proto_field
9482 #define _(a) found_something += a;
9483 foreach_udp_proto_field;
9486 if (found_something == 0)
9489 vec_validate (mask, sizeof (*udp) - 1);
9491 udp = (udp_header_t *) mask;
9493 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9494 foreach_udp_proto_field;
9502 unformat_l4_mask (unformat_input_t * input, va_list * args)
9504 u8 **maskp = va_arg (*args, u8 **);
9505 u16 src_port = 0, dst_port = 0;
9506 tcpudp_header_t *tcpudp;
9508 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9510 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9512 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9514 else if (unformat (input, "src_port"))
9516 else if (unformat (input, "dst_port"))
9522 if (!src_port && !dst_port)
9526 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9528 tcpudp = (tcpudp_header_t *) mask;
9529 tcpudp->src_port = src_port;
9530 tcpudp->dst_port = dst_port;
9538 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9540 u8 **maskp = va_arg (*args, u8 **);
9542 u8 found_something = 0;
9545 #define _(a) u8 a=0;
9546 foreach_ip4_proto_field;
9552 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9554 if (unformat (input, "version"))
9556 else if (unformat (input, "hdr_length"))
9558 else if (unformat (input, "src"))
9560 else if (unformat (input, "dst"))
9562 else if (unformat (input, "proto"))
9565 #define _(a) else if (unformat (input, #a)) a=1;
9566 foreach_ip4_proto_field
9572 #define _(a) found_something += a;
9573 foreach_ip4_proto_field;
9576 if (found_something == 0)
9579 vec_validate (mask, sizeof (*ip) - 1);
9581 ip = (ip4_header_t *) mask;
9583 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9584 foreach_ip4_proto_field;
9587 ip->ip_version_and_header_length = 0;
9590 ip->ip_version_and_header_length |= 0xF0;
9593 ip->ip_version_and_header_length |= 0x0F;
9599 #define foreach_ip6_proto_field \
9607 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9609 u8 **maskp = va_arg (*args, u8 **);
9611 u8 found_something = 0;
9613 u32 ip_version_traffic_class_and_flow_label;
9615 #define _(a) u8 a=0;
9616 foreach_ip6_proto_field;
9619 u8 traffic_class = 0;
9622 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9624 if (unformat (input, "version"))
9626 else if (unformat (input, "traffic-class"))
9628 else if (unformat (input, "flow-label"))
9630 else if (unformat (input, "src"))
9632 else if (unformat (input, "dst"))
9634 else if (unformat (input, "proto"))
9637 #define _(a) else if (unformat (input, #a)) a=1;
9638 foreach_ip6_proto_field
9644 #define _(a) found_something += a;
9645 foreach_ip6_proto_field;
9648 if (found_something == 0)
9651 vec_validate (mask, sizeof (*ip) - 1);
9653 ip = (ip6_header_t *) mask;
9655 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9656 foreach_ip6_proto_field;
9659 ip_version_traffic_class_and_flow_label = 0;
9662 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9665 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9668 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9670 ip->ip_version_traffic_class_and_flow_label =
9671 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9678 unformat_l3_mask (unformat_input_t * input, va_list * args)
9680 u8 **maskp = va_arg (*args, u8 **);
9682 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9684 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9686 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9695 unformat_l2_mask (unformat_input_t * input, va_list * args)
9697 u8 **maskp = va_arg (*args, u8 **);
9712 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9714 if (unformat (input, "src"))
9716 else if (unformat (input, "dst"))
9718 else if (unformat (input, "proto"))
9720 else if (unformat (input, "tag1"))
9722 else if (unformat (input, "tag2"))
9724 else if (unformat (input, "ignore-tag1"))
9726 else if (unformat (input, "ignore-tag2"))
9728 else if (unformat (input, "cos1"))
9730 else if (unformat (input, "cos2"))
9732 else if (unformat (input, "dot1q"))
9734 else if (unformat (input, "dot1ad"))
9739 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9740 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9743 if (tag1 || ignore_tag1 || cos1 || dot1q)
9745 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9748 vec_validate (mask, len - 1);
9751 clib_memset (mask, 0xff, 6);
9754 clib_memset (mask + 6, 0xff, 6);
9758 /* inner vlan tag */
9767 mask[21] = mask[20] = 0xff;
9788 mask[16] = mask[17] = 0xff;
9798 mask[12] = mask[13] = 0xff;
9805 unformat_classify_mask (unformat_input_t * input, va_list * args)
9807 u8 **maskp = va_arg (*args, u8 **);
9808 u32 *skipp = va_arg (*args, u32 *);
9809 u32 *matchp = va_arg (*args, u32 *);
9817 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9819 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9821 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9823 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9825 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9839 if (mask || l2 || l3 || l4)
9843 /* "With a free Ethernet header in every package" */
9845 vec_validate (l2, 13);
9849 vec_append (mask, l3);
9854 vec_append (mask, l4);
9859 /* Scan forward looking for the first significant mask octet */
9860 for (i = 0; i < vec_len (mask); i++)
9864 /* compute (skip, match) params */
9865 *skipp = i / sizeof (u32x4);
9866 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9868 /* Pad mask to an even multiple of the vector size */
9869 while (vec_len (mask) % sizeof (u32x4))
9872 match = vec_len (mask) / sizeof (u32x4);
9874 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9876 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9877 if (*tmp || *(tmp + 1))
9882 clib_warning ("BUG: match 0");
9884 _vec_len (mask) = match * sizeof (u32x4);
9894 #endif /* VPP_API_TEST_BUILTIN */
9896 #define foreach_l2_next \
9898 _(ethernet, ETHERNET_INPUT) \
9903 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9905 u32 *miss_next_indexp = va_arg (*args, u32 *);
9910 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9914 if (unformat (input, "%d", &tmp))
9923 *miss_next_indexp = next_index;
9927 #define foreach_ip_next \
9933 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9935 u32 *miss_next_indexp = va_arg (*args, u32 *);
9940 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9944 if (unformat (input, "%d", &tmp))
9953 *miss_next_indexp = next_index;
9957 #define foreach_acl_next \
9961 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9963 u32 *miss_next_indexp = va_arg (*args, u32 *);
9968 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9972 if (unformat (input, "permit"))
9977 else if (unformat (input, "%d", &tmp))
9986 *miss_next_indexp = next_index;
9991 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9993 u32 *r = va_arg (*args, u32 *);
9995 if (unformat (input, "conform-color"))
9996 *r = POLICE_CONFORM;
9997 else if (unformat (input, "exceed-color"))
10006 api_classify_add_del_table (vat_main_t * vam)
10008 unformat_input_t *i = vam->input;
10009 vl_api_classify_add_del_table_t *mp;
10016 u32 table_index = ~0;
10017 u32 next_table_index = ~0;
10018 u32 miss_next_index = ~0;
10019 u32 memory_size = 32 << 20;
10021 u32 current_data_flag = 0;
10022 int current_data_offset = 0;
10025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10027 if (unformat (i, "del"))
10029 else if (unformat (i, "del-chain"))
10034 else if (unformat (i, "buckets %d", &nbuckets))
10036 else if (unformat (i, "memory_size %d", &memory_size))
10038 else if (unformat (i, "skip %d", &skip))
10040 else if (unformat (i, "match %d", &match))
10042 else if (unformat (i, "table %d", &table_index))
10044 else if (unformat (i, "mask %U", unformat_classify_mask,
10045 &mask, &skip, &match))
10047 else if (unformat (i, "next-table %d", &next_table_index))
10049 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10052 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10055 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10058 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10060 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10066 if (is_add && mask == 0)
10068 errmsg ("Mask required");
10072 if (is_add && skip == ~0)
10074 errmsg ("skip count required");
10078 if (is_add && match == ~0)
10080 errmsg ("match count required");
10084 if (!is_add && table_index == ~0)
10086 errmsg ("table index required for delete");
10090 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10092 mp->is_add = is_add;
10093 mp->del_chain = del_chain;
10094 mp->table_index = ntohl (table_index);
10095 mp->nbuckets = ntohl (nbuckets);
10096 mp->memory_size = ntohl (memory_size);
10097 mp->skip_n_vectors = ntohl (skip);
10098 mp->match_n_vectors = ntohl (match);
10099 mp->next_table_index = ntohl (next_table_index);
10100 mp->miss_next_index = ntohl (miss_next_index);
10101 mp->current_data_flag = ntohl (current_data_flag);
10102 mp->current_data_offset = ntohl (current_data_offset);
10103 mp->mask_len = ntohl (vec_len (mask));
10104 clib_memcpy (mp->mask, mask, vec_len (mask));
10113 #if VPP_API_TEST_BUILTIN == 0
10115 unformat_l4_match (unformat_input_t * input, va_list * args)
10117 u8 **matchp = va_arg (*args, u8 **);
10119 u8 *proto_header = 0;
10125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10127 if (unformat (input, "src_port %d", &src_port))
10129 else if (unformat (input, "dst_port %d", &dst_port))
10135 h.src_port = clib_host_to_net_u16 (src_port);
10136 h.dst_port = clib_host_to_net_u16 (dst_port);
10137 vec_validate (proto_header, sizeof (h) - 1);
10138 memcpy (proto_header, &h, sizeof (h));
10140 *matchp = proto_header;
10146 unformat_ip4_match (unformat_input_t * input, va_list * args)
10148 u8 **matchp = va_arg (*args, u8 **);
10153 int hdr_length = 0;
10154 u32 hdr_length_val;
10155 int src = 0, dst = 0;
10156 ip4_address_t src_val, dst_val;
10163 int fragment_id = 0;
10164 u32 fragment_id_val;
10170 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10172 if (unformat (input, "version %d", &version_val))
10174 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10176 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10178 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10180 else if (unformat (input, "proto %d", &proto_val))
10182 else if (unformat (input, "tos %d", &tos_val))
10184 else if (unformat (input, "length %d", &length_val))
10186 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10188 else if (unformat (input, "ttl %d", &ttl_val))
10190 else if (unformat (input, "checksum %d", &checksum_val))
10196 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10197 + ttl + checksum == 0)
10201 * Aligned because we use the real comparison functions
10203 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10205 ip = (ip4_header_t *) match;
10207 /* These are realistically matched in practice */
10209 ip->src_address.as_u32 = src_val.as_u32;
10212 ip->dst_address.as_u32 = dst_val.as_u32;
10215 ip->protocol = proto_val;
10218 /* These are not, but they're included for completeness */
10220 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10223 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10229 ip->length = clib_host_to_net_u16 (length_val);
10235 ip->checksum = clib_host_to_net_u16 (checksum_val);
10242 unformat_ip6_match (unformat_input_t * input, va_list * args)
10244 u8 **matchp = va_arg (*args, u8 **);
10249 u8 traffic_class = 0;
10250 u32 traffic_class_val = 0;
10253 int src = 0, dst = 0;
10254 ip6_address_t src_val, dst_val;
10257 int payload_length = 0;
10258 u32 payload_length_val;
10261 u32 ip_version_traffic_class_and_flow_label;
10263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10265 if (unformat (input, "version %d", &version_val))
10267 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10269 else if (unformat (input, "flow_label %d", &flow_label_val))
10271 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10273 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10275 else if (unformat (input, "proto %d", &proto_val))
10277 else if (unformat (input, "payload_length %d", &payload_length_val))
10278 payload_length = 1;
10279 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10285 if (version + traffic_class + flow_label + src + dst + proto +
10286 payload_length + hop_limit == 0)
10290 * Aligned because we use the real comparison functions
10292 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10294 ip = (ip6_header_t *) match;
10297 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10300 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10303 ip->protocol = proto_val;
10305 ip_version_traffic_class_and_flow_label = 0;
10308 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10311 ip_version_traffic_class_and_flow_label |=
10312 (traffic_class_val & 0xFF) << 20;
10315 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10317 ip->ip_version_traffic_class_and_flow_label =
10318 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10320 if (payload_length)
10321 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10324 ip->hop_limit = hop_limit_val;
10331 unformat_l3_match (unformat_input_t * input, va_list * args)
10333 u8 **matchp = va_arg (*args, u8 **);
10335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10337 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10339 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10348 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10350 u8 *tagp = va_arg (*args, u8 *);
10353 if (unformat (input, "%d", &tag))
10355 tagp[0] = (tag >> 8) & 0x0F;
10356 tagp[1] = tag & 0xFF;
10364 unformat_l2_match (unformat_input_t * input, va_list * args)
10366 u8 **matchp = va_arg (*args, u8 **);
10379 u8 ignore_tag1 = 0;
10380 u8 ignore_tag2 = 0;
10386 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10388 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10391 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10393 else if (unformat (input, "proto %U",
10394 unformat_ethernet_type_host_byte_order, &proto_val))
10396 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10398 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10400 else if (unformat (input, "ignore-tag1"))
10402 else if (unformat (input, "ignore-tag2"))
10404 else if (unformat (input, "cos1 %d", &cos1_val))
10406 else if (unformat (input, "cos2 %d", &cos2_val))
10411 if ((src + dst + proto + tag1 + tag2 +
10412 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10415 if (tag1 || ignore_tag1 || cos1)
10417 if (tag2 || ignore_tag2 || cos2)
10420 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10423 clib_memcpy (match, dst_val, 6);
10426 clib_memcpy (match + 6, src_val, 6);
10430 /* inner vlan tag */
10431 match[19] = tag2_val[1];
10432 match[18] = tag2_val[0];
10434 match[18] |= (cos2_val & 0x7) << 5;
10437 match[21] = proto_val & 0xff;
10438 match[20] = proto_val >> 8;
10442 match[15] = tag1_val[1];
10443 match[14] = tag1_val[0];
10446 match[14] |= (cos1_val & 0x7) << 5;
10452 match[15] = tag1_val[1];
10453 match[14] = tag1_val[0];
10456 match[17] = proto_val & 0xff;
10457 match[16] = proto_val >> 8;
10460 match[14] |= (cos1_val & 0x7) << 5;
10466 match[18] |= (cos2_val & 0x7) << 5;
10468 match[14] |= (cos1_val & 0x7) << 5;
10471 match[13] = proto_val & 0xff;
10472 match[12] = proto_val >> 8;
10480 unformat_qos_source (unformat_input_t * input, va_list * args)
10482 int *qs = va_arg (*args, int *);
10484 if (unformat (input, "ip"))
10485 *qs = QOS_SOURCE_IP;
10486 else if (unformat (input, "mpls"))
10487 *qs = QOS_SOURCE_MPLS;
10488 else if (unformat (input, "ext"))
10489 *qs = QOS_SOURCE_EXT;
10490 else if (unformat (input, "vlan"))
10491 *qs = QOS_SOURCE_VLAN;
10500 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10502 u8 **matchp = va_arg (*args, u8 **);
10503 u32 skip_n_vectors = va_arg (*args, u32);
10504 u32 match_n_vectors = va_arg (*args, u32);
10511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10513 if (unformat (input, "hex %U", unformat_hex_string, &match))
10515 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10517 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10519 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10533 if (match || l2 || l3 || l4)
10535 if (l2 || l3 || l4)
10537 /* "Win a free Ethernet header in every packet" */
10539 vec_validate_aligned (l2, 13, sizeof (u32x4));
10543 vec_append_aligned (match, l3, sizeof (u32x4));
10548 vec_append_aligned (match, l4, sizeof (u32x4));
10553 /* Make sure the vector is big enough even if key is all 0's */
10554 vec_validate_aligned
10555 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10558 /* Set size, include skipped vectors */
10559 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10570 api_classify_add_del_session (vat_main_t * vam)
10572 unformat_input_t *i = vam->input;
10573 vl_api_classify_add_del_session_t *mp;
10575 u32 table_index = ~0;
10576 u32 hit_next_index = ~0;
10577 u32 opaque_index = ~0;
10580 u32 skip_n_vectors = 0;
10581 u32 match_n_vectors = 0;
10587 * Warning: you have to supply skip_n and match_n
10588 * because the API client cant simply look at the classify
10592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10594 if (unformat (i, "del"))
10596 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10599 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10602 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10605 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10607 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10609 else if (unformat (i, "opaque-index %d", &opaque_index))
10611 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10613 else if (unformat (i, "match_n %d", &match_n_vectors))
10615 else if (unformat (i, "match %U", api_unformat_classify_match,
10616 &match, skip_n_vectors, match_n_vectors))
10618 else if (unformat (i, "advance %d", &advance))
10620 else if (unformat (i, "table-index %d", &table_index))
10622 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10624 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10626 else if (unformat (i, "action %d", &action))
10628 else if (unformat (i, "metadata %d", &metadata))
10634 if (table_index == ~0)
10636 errmsg ("Table index required");
10640 if (is_add && match == 0)
10642 errmsg ("Match value required");
10646 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10648 mp->is_add = is_add;
10649 mp->table_index = ntohl (table_index);
10650 mp->hit_next_index = ntohl (hit_next_index);
10651 mp->opaque_index = ntohl (opaque_index);
10652 mp->advance = ntohl (advance);
10653 mp->action = action;
10654 mp->metadata = ntohl (metadata);
10655 mp->match_len = ntohl (vec_len (match));
10656 clib_memcpy (mp->match, match, vec_len (match));
10665 api_classify_set_interface_ip_table (vat_main_t * vam)
10667 unformat_input_t *i = vam->input;
10668 vl_api_classify_set_interface_ip_table_t *mp;
10670 int sw_if_index_set;
10671 u32 table_index = ~0;
10675 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10677 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10678 sw_if_index_set = 1;
10679 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10680 sw_if_index_set = 1;
10681 else if (unformat (i, "table %d", &table_index))
10685 clib_warning ("parse error '%U'", format_unformat_error, i);
10690 if (sw_if_index_set == 0)
10692 errmsg ("missing interface name or sw_if_index");
10697 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10699 mp->sw_if_index = ntohl (sw_if_index);
10700 mp->table_index = ntohl (table_index);
10701 mp->is_ipv6 = is_ipv6;
10709 api_classify_set_interface_l2_tables (vat_main_t * vam)
10711 unformat_input_t *i = vam->input;
10712 vl_api_classify_set_interface_l2_tables_t *mp;
10714 int sw_if_index_set;
10715 u32 ip4_table_index = ~0;
10716 u32 ip6_table_index = ~0;
10717 u32 other_table_index = ~0;
10721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10723 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10724 sw_if_index_set = 1;
10725 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10726 sw_if_index_set = 1;
10727 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10729 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10731 else if (unformat (i, "other-table %d", &other_table_index))
10733 else if (unformat (i, "is-input %d", &is_input))
10737 clib_warning ("parse error '%U'", format_unformat_error, i);
10742 if (sw_if_index_set == 0)
10744 errmsg ("missing interface name or sw_if_index");
10749 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10751 mp->sw_if_index = ntohl (sw_if_index);
10752 mp->ip4_table_index = ntohl (ip4_table_index);
10753 mp->ip6_table_index = ntohl (ip6_table_index);
10754 mp->other_table_index = ntohl (other_table_index);
10755 mp->is_input = (u8) is_input;
10763 api_set_ipfix_exporter (vat_main_t * vam)
10765 unformat_input_t *i = vam->input;
10766 vl_api_set_ipfix_exporter_t *mp;
10767 ip4_address_t collector_address;
10768 u8 collector_address_set = 0;
10769 u32 collector_port = ~0;
10770 ip4_address_t src_address;
10771 u8 src_address_set = 0;
10774 u32 template_interval = ~0;
10775 u8 udp_checksum = 0;
10778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10780 if (unformat (i, "collector_address %U", unformat_ip4_address,
10781 &collector_address))
10782 collector_address_set = 1;
10783 else if (unformat (i, "collector_port %d", &collector_port))
10785 else if (unformat (i, "src_address %U", unformat_ip4_address,
10787 src_address_set = 1;
10788 else if (unformat (i, "vrf_id %d", &vrf_id))
10790 else if (unformat (i, "path_mtu %d", &path_mtu))
10792 else if (unformat (i, "template_interval %d", &template_interval))
10794 else if (unformat (i, "udp_checksum"))
10800 if (collector_address_set == 0)
10802 errmsg ("collector_address required");
10806 if (src_address_set == 0)
10808 errmsg ("src_address required");
10812 M (SET_IPFIX_EXPORTER, mp);
10814 memcpy (mp->collector_address.un.ip4, collector_address.data,
10815 sizeof (collector_address.data));
10816 mp->collector_port = htons ((u16) collector_port);
10817 memcpy (mp->src_address.un.ip4, src_address.data,
10818 sizeof (src_address.data));
10819 mp->vrf_id = htonl (vrf_id);
10820 mp->path_mtu = htonl (path_mtu);
10821 mp->template_interval = htonl (template_interval);
10822 mp->udp_checksum = udp_checksum;
10830 api_set_ipfix_classify_stream (vat_main_t * vam)
10832 unformat_input_t *i = vam->input;
10833 vl_api_set_ipfix_classify_stream_t *mp;
10835 u32 src_port = UDP_DST_PORT_ipfix;
10838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10840 if (unformat (i, "domain %d", &domain_id))
10842 else if (unformat (i, "src_port %d", &src_port))
10846 errmsg ("unknown input `%U'", format_unformat_error, i);
10851 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10853 mp->domain_id = htonl (domain_id);
10854 mp->src_port = htons ((u16) src_port);
10862 api_ipfix_classify_table_add_del (vat_main_t * vam)
10864 unformat_input_t *i = vam->input;
10865 vl_api_ipfix_classify_table_add_del_t *mp;
10867 u32 classify_table_index = ~0;
10869 u8 transport_protocol = 255;
10872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10874 if (unformat (i, "add"))
10876 else if (unformat (i, "del"))
10878 else if (unformat (i, "table %d", &classify_table_index))
10880 else if (unformat (i, "ip4"))
10882 else if (unformat (i, "ip6"))
10884 else if (unformat (i, "tcp"))
10885 transport_protocol = 6;
10886 else if (unformat (i, "udp"))
10887 transport_protocol = 17;
10890 errmsg ("unknown input `%U'", format_unformat_error, i);
10897 errmsg ("expecting: add|del");
10900 if (classify_table_index == ~0)
10902 errmsg ("classifier table not specified");
10905 if (ip_version == 0)
10907 errmsg ("IP version not specified");
10911 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10913 mp->is_add = is_add;
10914 mp->table_id = htonl (classify_table_index);
10915 mp->ip_version = ip_version;
10916 mp->transport_protocol = transport_protocol;
10924 api_get_node_index (vat_main_t * vam)
10926 unformat_input_t *i = vam->input;
10927 vl_api_get_node_index_t *mp;
10931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10933 if (unformat (i, "node %s", &name))
10940 errmsg ("node name required");
10943 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10945 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10949 M (GET_NODE_INDEX, mp);
10950 clib_memcpy (mp->node_name, name, vec_len (name));
10959 api_get_next_index (vat_main_t * vam)
10961 unformat_input_t *i = vam->input;
10962 vl_api_get_next_index_t *mp;
10963 u8 *node_name = 0, *next_node_name = 0;
10966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10968 if (unformat (i, "node-name %s", &node_name))
10970 else if (unformat (i, "next-node-name %s", &next_node_name))
10974 if (node_name == 0)
10976 errmsg ("node name required");
10979 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10981 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10985 if (next_node_name == 0)
10987 errmsg ("next node name required");
10990 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10992 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10996 M (GET_NEXT_INDEX, mp);
10997 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10998 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10999 vec_free (node_name);
11000 vec_free (next_node_name);
11008 api_add_node_next (vat_main_t * vam)
11010 unformat_input_t *i = vam->input;
11011 vl_api_add_node_next_t *mp;
11016 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11018 if (unformat (i, "node %s", &name))
11020 else if (unformat (i, "next %s", &next))
11027 errmsg ("node name required");
11030 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11032 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11037 errmsg ("next node required");
11040 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11042 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11046 M (ADD_NODE_NEXT, mp);
11047 clib_memcpy (mp->node_name, name, vec_len (name));
11048 clib_memcpy (mp->next_name, next, vec_len (next));
11058 api_l2tpv3_create_tunnel (vat_main_t * vam)
11060 unformat_input_t *i = vam->input;
11061 ip6_address_t client_address, our_address;
11062 int client_address_set = 0;
11063 int our_address_set = 0;
11064 u32 local_session_id = 0;
11065 u32 remote_session_id = 0;
11066 u64 local_cookie = 0;
11067 u64 remote_cookie = 0;
11068 u8 l2_sublayer_present = 0;
11069 vl_api_l2tpv3_create_tunnel_t *mp;
11072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11074 if (unformat (i, "client_address %U", unformat_ip6_address,
11076 client_address_set = 1;
11077 else if (unformat (i, "our_address %U", unformat_ip6_address,
11079 our_address_set = 1;
11080 else if (unformat (i, "local_session_id %d", &local_session_id))
11082 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11084 else if (unformat (i, "local_cookie %lld", &local_cookie))
11086 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11088 else if (unformat (i, "l2-sublayer-present"))
11089 l2_sublayer_present = 1;
11094 if (client_address_set == 0)
11096 errmsg ("client_address required");
11100 if (our_address_set == 0)
11102 errmsg ("our_address required");
11106 M (L2TPV3_CREATE_TUNNEL, mp);
11108 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11109 sizeof (ip6_address_t));
11111 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11112 sizeof (ip6_address_t));
11114 mp->local_session_id = ntohl (local_session_id);
11115 mp->remote_session_id = ntohl (remote_session_id);
11116 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11117 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11118 mp->l2_sublayer_present = l2_sublayer_present;
11126 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11128 unformat_input_t *i = vam->input;
11130 u8 sw_if_index_set = 0;
11131 u64 new_local_cookie = 0;
11132 u64 new_remote_cookie = 0;
11133 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11138 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11139 sw_if_index_set = 1;
11140 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11141 sw_if_index_set = 1;
11142 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11144 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11150 if (sw_if_index_set == 0)
11152 errmsg ("missing interface name or sw_if_index");
11156 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11158 mp->sw_if_index = ntohl (sw_if_index);
11159 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11160 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11168 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11170 unformat_input_t *i = vam->input;
11171 vl_api_l2tpv3_interface_enable_disable_t *mp;
11173 u8 sw_if_index_set = 0;
11174 u8 enable_disable = 1;
11177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11179 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11180 sw_if_index_set = 1;
11181 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11182 sw_if_index_set = 1;
11183 else if (unformat (i, "enable"))
11184 enable_disable = 1;
11185 else if (unformat (i, "disable"))
11186 enable_disable = 0;
11191 if (sw_if_index_set == 0)
11193 errmsg ("missing interface name or sw_if_index");
11197 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11199 mp->sw_if_index = ntohl (sw_if_index);
11200 mp->enable_disable = enable_disable;
11208 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11210 unformat_input_t *i = vam->input;
11211 vl_api_l2tpv3_set_lookup_key_t *mp;
11215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11217 if (unformat (i, "lookup_v6_src"))
11218 key = L2T_LOOKUP_SRC_ADDRESS;
11219 else if (unformat (i, "lookup_v6_dst"))
11220 key = L2T_LOOKUP_DST_ADDRESS;
11221 else if (unformat (i, "lookup_session_id"))
11222 key = L2T_LOOKUP_SESSION_ID;
11227 if (key == (u8) ~ 0)
11229 errmsg ("l2tp session lookup key unset");
11233 M (L2TPV3_SET_LOOKUP_KEY, mp);
11242 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11243 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11245 vat_main_t *vam = &vat_main;
11247 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11248 format_ip6_address, mp->our_address,
11249 format_ip6_address, mp->client_address,
11250 clib_net_to_host_u32 (mp->sw_if_index));
11253 " local cookies %016llx %016llx remote cookie %016llx",
11254 clib_net_to_host_u64 (mp->local_cookie[0]),
11255 clib_net_to_host_u64 (mp->local_cookie[1]),
11256 clib_net_to_host_u64 (mp->remote_cookie));
11258 print (vam->ofp, " local session-id %d remote session-id %d",
11259 clib_net_to_host_u32 (mp->local_session_id),
11260 clib_net_to_host_u32 (mp->remote_session_id));
11262 print (vam->ofp, " l2 specific sublayer %s\n",
11263 mp->l2_sublayer_present ? "preset" : "absent");
11267 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11268 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11270 vat_main_t *vam = &vat_main;
11271 vat_json_node_t *node = NULL;
11272 struct in6_addr addr;
11274 if (VAT_JSON_ARRAY != vam->json_tree.type)
11276 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11277 vat_json_init_array (&vam->json_tree);
11279 node = vat_json_array_add (&vam->json_tree);
11281 vat_json_init_object (node);
11283 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11284 vat_json_object_add_ip6 (node, "our_address", addr);
11285 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11286 vat_json_object_add_ip6 (node, "client_address", addr);
11288 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11289 vat_json_init_array (lc);
11290 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11291 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11292 vat_json_object_add_uint (node, "remote_cookie",
11293 clib_net_to_host_u64 (mp->remote_cookie));
11295 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11296 vat_json_object_add_uint (node, "local_session_id",
11297 clib_net_to_host_u32 (mp->local_session_id));
11298 vat_json_object_add_uint (node, "remote_session_id",
11299 clib_net_to_host_u32 (mp->remote_session_id));
11300 vat_json_object_add_string_copy (node, "l2_sublayer",
11301 mp->l2_sublayer_present ? (u8 *) "present"
11302 : (u8 *) "absent");
11306 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11308 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11309 vl_api_control_ping_t *mp_ping;
11312 /* Get list of l2tpv3-tunnel interfaces */
11313 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11316 /* Use a control ping for synchronization */
11317 MPING (CONTROL_PING, mp_ping);
11325 static void vl_api_sw_interface_tap_v2_details_t_handler
11326 (vl_api_sw_interface_tap_v2_details_t * mp)
11328 vat_main_t *vam = &vat_main;
11331 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11332 mp->host_ip4_prefix.len);
11334 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11335 mp->host_ip6_prefix.len);
11338 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11339 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11340 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11341 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11342 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11348 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11349 (vl_api_sw_interface_tap_v2_details_t * mp)
11351 vat_main_t *vam = &vat_main;
11352 vat_json_node_t *node = NULL;
11354 if (VAT_JSON_ARRAY != vam->json_tree.type)
11356 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11357 vat_json_init_array (&vam->json_tree);
11359 node = vat_json_array_add (&vam->json_tree);
11361 vat_json_init_object (node);
11362 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11363 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11364 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11365 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11366 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11367 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11368 vat_json_object_add_string_copy (node, "host_mac_addr",
11369 format (0, "%U", format_ethernet_address,
11370 &mp->host_mac_addr));
11371 vat_json_object_add_string_copy (node, "host_namespace",
11372 mp->host_namespace);
11373 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11374 vat_json_object_add_string_copy (node, "host_ip4_addr",
11375 format (0, "%U/%d", format_ip4_address,
11376 mp->host_ip4_prefix.address,
11377 mp->host_ip4_prefix.len));
11378 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11379 format (0, "%U/%d", format_ip6_address,
11380 mp->host_ip6_prefix.address,
11381 mp->host_ip6_prefix.len));
11386 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11388 vl_api_sw_interface_tap_v2_dump_t *mp;
11389 vl_api_control_ping_t *mp_ping;
11393 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11394 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11395 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11398 /* Get list of tap interfaces */
11399 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11402 /* Use a control ping for synchronization */
11403 MPING (CONTROL_PING, mp_ping);
11410 static void vl_api_sw_interface_virtio_pci_details_t_handler
11411 (vl_api_sw_interface_virtio_pci_details_t * mp)
11413 vat_main_t *vam = &vat_main;
11428 addr.domain = ntohs (mp->pci_addr.domain);
11429 addr.bus = mp->pci_addr.bus;
11430 addr.slot = mp->pci_addr.slot;
11431 addr.function = mp->pci_addr.function;
11433 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11434 addr.slot, addr.function);
11437 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11438 pci_addr, ntohl (mp->sw_if_index),
11439 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11440 format_ethernet_address, mp->mac_addr,
11441 clib_net_to_host_u64 (mp->features));
11442 vec_free (pci_addr);
11445 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11446 (vl_api_sw_interface_virtio_pci_details_t * mp)
11448 vat_main_t *vam = &vat_main;
11449 vat_json_node_t *node = NULL;
11450 vlib_pci_addr_t pci_addr;
11452 if (VAT_JSON_ARRAY != vam->json_tree.type)
11454 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11455 vat_json_init_array (&vam->json_tree);
11457 node = vat_json_array_add (&vam->json_tree);
11459 pci_addr.domain = ntohs (mp->pci_addr.domain);
11460 pci_addr.bus = mp->pci_addr.bus;
11461 pci_addr.slot = mp->pci_addr.slot;
11462 pci_addr.function = mp->pci_addr.function;
11464 vat_json_init_object (node);
11465 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11466 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11467 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11468 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11469 vat_json_object_add_uint (node, "features",
11470 clib_net_to_host_u64 (mp->features));
11471 vat_json_object_add_string_copy (node, "mac_addr",
11472 format (0, "%U", format_ethernet_address,
11477 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11479 vl_api_sw_interface_virtio_pci_dump_t *mp;
11480 vl_api_control_ping_t *mp_ping;
11484 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11485 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11486 "mac_addr", "features");
11488 /* Get list of tap interfaces */
11489 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11492 /* Use a control ping for synchronization */
11493 MPING (CONTROL_PING, mp_ping);
11501 api_vxlan_offload_rx (vat_main_t * vam)
11503 unformat_input_t *line_input = vam->input;
11504 vl_api_vxlan_offload_rx_t *mp;
11505 u32 hw_if_index = ~0, rx_if_index = ~0;
11509 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11511 if (unformat (line_input, "del"))
11513 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11516 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11518 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11521 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11525 errmsg ("parse error '%U'", format_unformat_error, line_input);
11530 if (hw_if_index == ~0)
11532 errmsg ("no hw interface");
11536 if (rx_if_index == ~0)
11538 errmsg ("no rx tunnel");
11542 M (VXLAN_OFFLOAD_RX, mp);
11544 mp->hw_if_index = ntohl (hw_if_index);
11545 mp->sw_if_index = ntohl (rx_if_index);
11546 mp->enable = is_add;
11553 static uword unformat_vxlan_decap_next
11554 (unformat_input_t * input, va_list * args)
11556 u32 *result = va_arg (*args, u32 *);
11559 if (unformat (input, "l2"))
11560 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11561 else if (unformat (input, "%d", &tmp))
11569 api_vxlan_add_del_tunnel (vat_main_t * vam)
11571 unformat_input_t *line_input = vam->input;
11572 vl_api_vxlan_add_del_tunnel_t *mp;
11573 ip46_address_t src, dst;
11575 u8 ipv4_set = 0, ipv6_set = 0;
11580 u32 mcast_sw_if_index = ~0;
11581 u32 encap_vrf_id = 0;
11582 u32 decap_next_index = ~0;
11586 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11587 clib_memset (&src, 0, sizeof src);
11588 clib_memset (&dst, 0, sizeof dst);
11590 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11592 if (unformat (line_input, "del"))
11594 else if (unformat (line_input, "instance %d", &instance))
11597 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11603 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11609 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11615 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11620 else if (unformat (line_input, "group %U %U",
11621 unformat_ip4_address, &dst.ip4,
11622 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11624 grp_set = dst_set = 1;
11627 else if (unformat (line_input, "group %U",
11628 unformat_ip4_address, &dst.ip4))
11630 grp_set = dst_set = 1;
11633 else if (unformat (line_input, "group %U %U",
11634 unformat_ip6_address, &dst.ip6,
11635 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11637 grp_set = dst_set = 1;
11640 else if (unformat (line_input, "group %U",
11641 unformat_ip6_address, &dst.ip6))
11643 grp_set = dst_set = 1;
11647 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11649 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11651 else if (unformat (line_input, "decap-next %U",
11652 unformat_vxlan_decap_next, &decap_next_index))
11654 else if (unformat (line_input, "vni %d", &vni))
11658 errmsg ("parse error '%U'", format_unformat_error, line_input);
11665 errmsg ("tunnel src address not specified");
11670 errmsg ("tunnel dst address not specified");
11674 if (grp_set && !ip46_address_is_multicast (&dst))
11676 errmsg ("tunnel group address not multicast");
11679 if (grp_set && mcast_sw_if_index == ~0)
11681 errmsg ("tunnel nonexistent multicast device");
11684 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11686 errmsg ("tunnel dst address must be unicast");
11691 if (ipv4_set && ipv6_set)
11693 errmsg ("both IPv4 and IPv6 addresses specified");
11697 if ((vni == 0) || (vni >> 24))
11699 errmsg ("vni not specified or out of range");
11703 M (VXLAN_ADD_DEL_TUNNEL, mp);
11707 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11708 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11712 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11713 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11716 mp->instance = htonl (instance);
11717 mp->encap_vrf_id = ntohl (encap_vrf_id);
11718 mp->decap_next_index = ntohl (decap_next_index);
11719 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11720 mp->vni = ntohl (vni);
11721 mp->is_add = is_add;
11722 mp->is_ipv6 = ipv6_set;
11729 static void vl_api_vxlan_tunnel_details_t_handler
11730 (vl_api_vxlan_tunnel_details_t * mp)
11732 vat_main_t *vam = &vat_main;
11733 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11734 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11736 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11737 ntohl (mp->sw_if_index),
11738 ntohl (mp->instance),
11739 format_ip46_address, &src, IP46_TYPE_ANY,
11740 format_ip46_address, &dst, IP46_TYPE_ANY,
11741 ntohl (mp->encap_vrf_id),
11742 ntohl (mp->decap_next_index), ntohl (mp->vni),
11743 ntohl (mp->mcast_sw_if_index));
11746 static void vl_api_vxlan_tunnel_details_t_handler_json
11747 (vl_api_vxlan_tunnel_details_t * mp)
11749 vat_main_t *vam = &vat_main;
11750 vat_json_node_t *node = NULL;
11752 if (VAT_JSON_ARRAY != vam->json_tree.type)
11754 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11755 vat_json_init_array (&vam->json_tree);
11757 node = vat_json_array_add (&vam->json_tree);
11759 vat_json_init_object (node);
11760 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11762 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11766 struct in6_addr ip6;
11768 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11769 vat_json_object_add_ip6 (node, "src_address", ip6);
11770 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11771 vat_json_object_add_ip6 (node, "dst_address", ip6);
11775 struct in_addr ip4;
11777 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11778 vat_json_object_add_ip4 (node, "src_address", ip4);
11779 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11780 vat_json_object_add_ip4 (node, "dst_address", ip4);
11782 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11783 vat_json_object_add_uint (node, "decap_next_index",
11784 ntohl (mp->decap_next_index));
11785 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11786 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11787 vat_json_object_add_uint (node, "mcast_sw_if_index",
11788 ntohl (mp->mcast_sw_if_index));
11792 api_vxlan_tunnel_dump (vat_main_t * vam)
11794 unformat_input_t *i = vam->input;
11795 vl_api_vxlan_tunnel_dump_t *mp;
11796 vl_api_control_ping_t *mp_ping;
11798 u8 sw_if_index_set = 0;
11801 /* Parse args required to build the message */
11802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11804 if (unformat (i, "sw_if_index %d", &sw_if_index))
11805 sw_if_index_set = 1;
11810 if (sw_if_index_set == 0)
11815 if (!vam->json_output)
11817 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11818 "sw_if_index", "instance", "src_address", "dst_address",
11819 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11822 /* Get list of vxlan-tunnel interfaces */
11823 M (VXLAN_TUNNEL_DUMP, mp);
11825 mp->sw_if_index = htonl (sw_if_index);
11829 /* Use a control ping for synchronization */
11830 MPING (CONTROL_PING, mp_ping);
11837 static uword unformat_geneve_decap_next
11838 (unformat_input_t * input, va_list * args)
11840 u32 *result = va_arg (*args, u32 *);
11843 if (unformat (input, "l2"))
11844 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11845 else if (unformat (input, "%d", &tmp))
11853 api_geneve_add_del_tunnel (vat_main_t * vam)
11855 unformat_input_t *line_input = vam->input;
11856 vl_api_geneve_add_del_tunnel_t *mp;
11857 ip46_address_t src, dst;
11859 u8 ipv4_set = 0, ipv6_set = 0;
11863 u32 mcast_sw_if_index = ~0;
11864 u32 encap_vrf_id = 0;
11865 u32 decap_next_index = ~0;
11869 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11870 clib_memset (&src, 0, sizeof src);
11871 clib_memset (&dst, 0, sizeof dst);
11873 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11875 if (unformat (line_input, "del"))
11878 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11884 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11890 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11896 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11901 else if (unformat (line_input, "group %U %U",
11902 unformat_ip4_address, &dst.ip4,
11903 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11905 grp_set = dst_set = 1;
11908 else if (unformat (line_input, "group %U",
11909 unformat_ip4_address, &dst.ip4))
11911 grp_set = dst_set = 1;
11914 else if (unformat (line_input, "group %U %U",
11915 unformat_ip6_address, &dst.ip6,
11916 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11918 grp_set = dst_set = 1;
11921 else if (unformat (line_input, "group %U",
11922 unformat_ip6_address, &dst.ip6))
11924 grp_set = dst_set = 1;
11928 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11930 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11932 else if (unformat (line_input, "decap-next %U",
11933 unformat_geneve_decap_next, &decap_next_index))
11935 else if (unformat (line_input, "vni %d", &vni))
11939 errmsg ("parse error '%U'", format_unformat_error, line_input);
11946 errmsg ("tunnel src address not specified");
11951 errmsg ("tunnel dst address not specified");
11955 if (grp_set && !ip46_address_is_multicast (&dst))
11957 errmsg ("tunnel group address not multicast");
11960 if (grp_set && mcast_sw_if_index == ~0)
11962 errmsg ("tunnel nonexistent multicast device");
11965 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11967 errmsg ("tunnel dst address must be unicast");
11972 if (ipv4_set && ipv6_set)
11974 errmsg ("both IPv4 and IPv6 addresses specified");
11978 if ((vni == 0) || (vni >> 24))
11980 errmsg ("vni not specified or out of range");
11984 M (GENEVE_ADD_DEL_TUNNEL, mp);
11988 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
11989 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11993 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
11994 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11996 mp->encap_vrf_id = ntohl (encap_vrf_id);
11997 mp->decap_next_index = ntohl (decap_next_index);
11998 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11999 mp->vni = ntohl (vni);
12000 mp->is_add = is_add;
12007 static void vl_api_geneve_tunnel_details_t_handler
12008 (vl_api_geneve_tunnel_details_t * mp)
12010 vat_main_t *vam = &vat_main;
12011 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12012 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12014 if (mp->src_address.af == ADDRESS_IP6)
12016 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12017 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12021 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12022 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12025 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12026 ntohl (mp->sw_if_index),
12027 format_ip46_address, &src, IP46_TYPE_ANY,
12028 format_ip46_address, &dst, IP46_TYPE_ANY,
12029 ntohl (mp->encap_vrf_id),
12030 ntohl (mp->decap_next_index), ntohl (mp->vni),
12031 ntohl (mp->mcast_sw_if_index));
12034 static void vl_api_geneve_tunnel_details_t_handler_json
12035 (vl_api_geneve_tunnel_details_t * mp)
12037 vat_main_t *vam = &vat_main;
12038 vat_json_node_t *node = NULL;
12041 if (VAT_JSON_ARRAY != vam->json_tree.type)
12043 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12044 vat_json_init_array (&vam->json_tree);
12046 node = vat_json_array_add (&vam->json_tree);
12048 vat_json_init_object (node);
12049 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12050 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12053 struct in6_addr ip6;
12055 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12056 vat_json_object_add_ip6 (node, "src_address", ip6);
12057 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12058 vat_json_object_add_ip6 (node, "dst_address", ip6);
12062 struct in_addr ip4;
12064 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12065 vat_json_object_add_ip4 (node, "src_address", ip4);
12066 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12067 vat_json_object_add_ip4 (node, "dst_address", ip4);
12069 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12070 vat_json_object_add_uint (node, "decap_next_index",
12071 ntohl (mp->decap_next_index));
12072 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12073 vat_json_object_add_uint (node, "mcast_sw_if_index",
12074 ntohl (mp->mcast_sw_if_index));
12078 api_geneve_tunnel_dump (vat_main_t * vam)
12080 unformat_input_t *i = vam->input;
12081 vl_api_geneve_tunnel_dump_t *mp;
12082 vl_api_control_ping_t *mp_ping;
12084 u8 sw_if_index_set = 0;
12087 /* Parse args required to build the message */
12088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12090 if (unformat (i, "sw_if_index %d", &sw_if_index))
12091 sw_if_index_set = 1;
12096 if (sw_if_index_set == 0)
12101 if (!vam->json_output)
12103 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12104 "sw_if_index", "local_address", "remote_address",
12105 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12108 /* Get list of geneve-tunnel interfaces */
12109 M (GENEVE_TUNNEL_DUMP, mp);
12111 mp->sw_if_index = htonl (sw_if_index);
12115 /* Use a control ping for synchronization */
12116 M (CONTROL_PING, mp_ping);
12124 api_gre_tunnel_add_del (vat_main_t * vam)
12126 unformat_input_t *line_input = vam->input;
12127 vl_api_address_t src = { }, dst =
12130 vl_api_gre_tunnel_add_del_t *mp;
12131 vl_api_gre_tunnel_type_t t_type;
12135 u32 outer_table_id = 0;
12136 u32 session_id = 0;
12140 t_type = GRE_API_TUNNEL_TYPE_L3;
12142 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12144 if (unformat (line_input, "del"))
12146 else if (unformat (line_input, "instance %d", &instance))
12148 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12152 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12156 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12158 else if (unformat (line_input, "teb"))
12159 t_type = GRE_API_TUNNEL_TYPE_TEB;
12160 else if (unformat (line_input, "erspan %d", &session_id))
12161 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12164 errmsg ("parse error '%U'", format_unformat_error, line_input);
12171 errmsg ("tunnel src address not specified");
12176 errmsg ("tunnel dst address not specified");
12180 M (GRE_TUNNEL_ADD_DEL, mp);
12182 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12183 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12185 mp->tunnel.instance = htonl (instance);
12186 mp->tunnel.outer_table_id = htonl (outer_table_id);
12187 mp->is_add = is_add;
12188 mp->tunnel.session_id = htons ((u16) session_id);
12189 mp->tunnel.type = htonl (t_type);
12196 static void vl_api_gre_tunnel_details_t_handler
12197 (vl_api_gre_tunnel_details_t * mp)
12199 vat_main_t *vam = &vat_main;
12201 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12202 ntohl (mp->tunnel.sw_if_index),
12203 ntohl (mp->tunnel.instance),
12204 format_vl_api_address, &mp->tunnel.src,
12205 format_vl_api_address, &mp->tunnel.dst,
12206 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12207 ntohl (mp->tunnel.session_id));
12210 static void vl_api_gre_tunnel_details_t_handler_json
12211 (vl_api_gre_tunnel_details_t * mp)
12213 vat_main_t *vam = &vat_main;
12214 vat_json_node_t *node = NULL;
12216 if (VAT_JSON_ARRAY != vam->json_tree.type)
12218 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12219 vat_json_init_array (&vam->json_tree);
12221 node = vat_json_array_add (&vam->json_tree);
12223 vat_json_init_object (node);
12224 vat_json_object_add_uint (node, "sw_if_index",
12225 ntohl (mp->tunnel.sw_if_index));
12226 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12228 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12229 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12230 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12231 vat_json_object_add_uint (node, "outer_table_id",
12232 ntohl (mp->tunnel.outer_table_id));
12233 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12237 api_gre_tunnel_dump (vat_main_t * vam)
12239 unformat_input_t *i = vam->input;
12240 vl_api_gre_tunnel_dump_t *mp;
12241 vl_api_control_ping_t *mp_ping;
12243 u8 sw_if_index_set = 0;
12246 /* Parse args required to build the message */
12247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12249 if (unformat (i, "sw_if_index %d", &sw_if_index))
12250 sw_if_index_set = 1;
12255 if (sw_if_index_set == 0)
12260 if (!vam->json_output)
12262 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12263 "sw_if_index", "instance", "src_address", "dst_address",
12264 "tunnel_type", "outer_fib_id", "session_id");
12267 /* Get list of gre-tunnel interfaces */
12268 M (GRE_TUNNEL_DUMP, mp);
12270 mp->sw_if_index = htonl (sw_if_index);
12274 /* Use a control ping for synchronization */
12275 MPING (CONTROL_PING, mp_ping);
12283 api_l2_fib_clear_table (vat_main_t * vam)
12285 // unformat_input_t * i = vam->input;
12286 vl_api_l2_fib_clear_table_t *mp;
12289 M (L2_FIB_CLEAR_TABLE, mp);
12297 api_l2_interface_efp_filter (vat_main_t * vam)
12299 unformat_input_t *i = vam->input;
12300 vl_api_l2_interface_efp_filter_t *mp;
12303 u8 sw_if_index_set = 0;
12306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12308 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12309 sw_if_index_set = 1;
12310 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12311 sw_if_index_set = 1;
12312 else if (unformat (i, "enable"))
12314 else if (unformat (i, "disable"))
12318 clib_warning ("parse error '%U'", format_unformat_error, i);
12323 if (sw_if_index_set == 0)
12325 errmsg ("missing sw_if_index");
12329 M (L2_INTERFACE_EFP_FILTER, mp);
12331 mp->sw_if_index = ntohl (sw_if_index);
12332 mp->enable_disable = enable;
12339 #define foreach_vtr_op \
12340 _("disable", L2_VTR_DISABLED) \
12341 _("push-1", L2_VTR_PUSH_1) \
12342 _("push-2", L2_VTR_PUSH_2) \
12343 _("pop-1", L2_VTR_POP_1) \
12344 _("pop-2", L2_VTR_POP_2) \
12345 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12346 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12347 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12348 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12351 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12353 unformat_input_t *i = vam->input;
12354 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12356 u8 sw_if_index_set = 0;
12359 u32 push_dot1q = 1;
12364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12366 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12367 sw_if_index_set = 1;
12368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12369 sw_if_index_set = 1;
12370 else if (unformat (i, "vtr_op %d", &vtr_op))
12372 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12375 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12377 else if (unformat (i, "tag1 %d", &tag1))
12379 else if (unformat (i, "tag2 %d", &tag2))
12383 clib_warning ("parse error '%U'", format_unformat_error, i);
12388 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12390 errmsg ("missing vtr operation or sw_if_index");
12394 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12395 mp->sw_if_index = ntohl (sw_if_index);
12396 mp->vtr_op = ntohl (vtr_op);
12397 mp->push_dot1q = ntohl (push_dot1q);
12398 mp->tag1 = ntohl (tag1);
12399 mp->tag2 = ntohl (tag2);
12407 api_create_vhost_user_if (vat_main_t * vam)
12409 unformat_input_t *i = vam->input;
12410 vl_api_create_vhost_user_if_t *mp;
12413 u8 file_name_set = 0;
12414 u32 custom_dev_instance = ~0;
12416 u8 use_custom_mac = 0;
12417 u8 disable_mrg_rxbuf = 0;
12418 u8 disable_indirect_desc = 0;
12423 /* Shut up coverity */
12424 clib_memset (hwaddr, 0, sizeof (hwaddr));
12426 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12428 if (unformat (i, "socket %s", &file_name))
12432 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12434 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12435 use_custom_mac = 1;
12436 else if (unformat (i, "server"))
12438 else if (unformat (i, "disable_mrg_rxbuf"))
12439 disable_mrg_rxbuf = 1;
12440 else if (unformat (i, "disable_indirect_desc"))
12441 disable_indirect_desc = 1;
12442 else if (unformat (i, "gso"))
12444 else if (unformat (i, "tag %s", &tag))
12450 if (file_name_set == 0)
12452 errmsg ("missing socket file name");
12456 if (vec_len (file_name) > 255)
12458 errmsg ("socket file name too long");
12461 vec_add1 (file_name, 0);
12463 M (CREATE_VHOST_USER_IF, mp);
12465 mp->is_server = is_server;
12466 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12467 mp->disable_indirect_desc = disable_indirect_desc;
12468 mp->enable_gso = enable_gso;
12469 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12470 vec_free (file_name);
12471 if (custom_dev_instance != ~0)
12474 mp->custom_dev_instance = ntohl (custom_dev_instance);
12477 mp->use_custom_mac = use_custom_mac;
12478 clib_memcpy (mp->mac_address, hwaddr, 6);
12480 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12489 api_modify_vhost_user_if (vat_main_t * vam)
12491 unformat_input_t *i = vam->input;
12492 vl_api_modify_vhost_user_if_t *mp;
12495 u8 file_name_set = 0;
12496 u32 custom_dev_instance = ~0;
12497 u8 sw_if_index_set = 0;
12498 u32 sw_if_index = (u32) ~ 0;
12502 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12504 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12505 sw_if_index_set = 1;
12506 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12507 sw_if_index_set = 1;
12508 else if (unformat (i, "socket %s", &file_name))
12512 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12514 else if (unformat (i, "server"))
12516 else if (unformat (i, "gso"))
12522 if (sw_if_index_set == 0)
12524 errmsg ("missing sw_if_index or interface name");
12528 if (file_name_set == 0)
12530 errmsg ("missing socket file name");
12534 if (vec_len (file_name) > 255)
12536 errmsg ("socket file name too long");
12539 vec_add1 (file_name, 0);
12541 M (MODIFY_VHOST_USER_IF, mp);
12543 mp->sw_if_index = ntohl (sw_if_index);
12544 mp->is_server = is_server;
12545 mp->enable_gso = enable_gso;
12546 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12547 vec_free (file_name);
12548 if (custom_dev_instance != ~0)
12551 mp->custom_dev_instance = ntohl (custom_dev_instance);
12560 api_delete_vhost_user_if (vat_main_t * vam)
12562 unformat_input_t *i = vam->input;
12563 vl_api_delete_vhost_user_if_t *mp;
12564 u32 sw_if_index = ~0;
12565 u8 sw_if_index_set = 0;
12568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12570 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12571 sw_if_index_set = 1;
12572 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12573 sw_if_index_set = 1;
12578 if (sw_if_index_set == 0)
12580 errmsg ("missing sw_if_index or interface name");
12585 M (DELETE_VHOST_USER_IF, mp);
12587 mp->sw_if_index = ntohl (sw_if_index);
12594 static void vl_api_sw_interface_vhost_user_details_t_handler
12595 (vl_api_sw_interface_vhost_user_details_t * mp)
12597 vat_main_t *vam = &vat_main;
12601 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12602 clib_net_to_host_u32
12603 (mp->features_last_32) <<
12606 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12607 (char *) mp->interface_name,
12608 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12609 features, mp->is_server,
12610 ntohl (mp->num_regions), (char *) mp->sock_filename);
12611 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12614 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12615 (vl_api_sw_interface_vhost_user_details_t * mp)
12617 vat_main_t *vam = &vat_main;
12618 vat_json_node_t *node = NULL;
12620 if (VAT_JSON_ARRAY != vam->json_tree.type)
12622 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12623 vat_json_init_array (&vam->json_tree);
12625 node = vat_json_array_add (&vam->json_tree);
12627 vat_json_init_object (node);
12628 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12629 vat_json_object_add_string_copy (node, "interface_name",
12630 mp->interface_name);
12631 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12632 ntohl (mp->virtio_net_hdr_sz));
12633 vat_json_object_add_uint (node, "features_first_32",
12634 clib_net_to_host_u32 (mp->features_first_32));
12635 vat_json_object_add_uint (node, "features_last_32",
12636 clib_net_to_host_u32 (mp->features_last_32));
12637 vat_json_object_add_uint (node, "is_server", mp->is_server);
12638 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12639 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12640 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12644 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12646 vl_api_sw_interface_vhost_user_dump_t *mp;
12647 vl_api_control_ping_t *mp_ping;
12650 "Interface name idx hdr_sz features server regions filename");
12652 /* Get list of vhost-user interfaces */
12653 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12654 mp->sw_if_index = ntohl (~0);
12657 /* Use a control ping for synchronization */
12658 MPING (CONTROL_PING, mp_ping);
12666 api_show_version (vat_main_t * vam)
12668 vl_api_show_version_t *mp;
12671 M (SHOW_VERSION, mp);
12680 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12682 unformat_input_t *line_input = vam->input;
12683 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12684 ip4_address_t local4, remote4;
12685 ip6_address_t local6, remote6;
12687 u8 ipv4_set = 0, ipv6_set = 0;
12691 u32 mcast_sw_if_index = ~0;
12692 u32 encap_vrf_id = 0;
12693 u32 decap_vrf_id = 0;
12699 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12700 clib_memset (&local4, 0, sizeof local4);
12701 clib_memset (&remote4, 0, sizeof remote4);
12702 clib_memset (&local6, 0, sizeof local6);
12703 clib_memset (&remote6, 0, sizeof remote6);
12705 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12707 if (unformat (line_input, "del"))
12709 else if (unformat (line_input, "local %U",
12710 unformat_ip4_address, &local4))
12715 else if (unformat (line_input, "remote %U",
12716 unformat_ip4_address, &remote4))
12721 else if (unformat (line_input, "local %U",
12722 unformat_ip6_address, &local6))
12727 else if (unformat (line_input, "remote %U",
12728 unformat_ip6_address, &remote6))
12733 else if (unformat (line_input, "group %U %U",
12734 unformat_ip4_address, &remote4,
12735 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12737 grp_set = remote_set = 1;
12740 else if (unformat (line_input, "group %U",
12741 unformat_ip4_address, &remote4))
12743 grp_set = remote_set = 1;
12746 else if (unformat (line_input, "group %U %U",
12747 unformat_ip6_address, &remote6,
12748 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12750 grp_set = remote_set = 1;
12753 else if (unformat (line_input, "group %U",
12754 unformat_ip6_address, &remote6))
12756 grp_set = remote_set = 1;
12760 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12762 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12764 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12766 else if (unformat (line_input, "vni %d", &vni))
12768 else if (unformat (line_input, "next-ip4"))
12770 else if (unformat (line_input, "next-ip6"))
12772 else if (unformat (line_input, "next-ethernet"))
12774 else if (unformat (line_input, "next-nsh"))
12778 errmsg ("parse error '%U'", format_unformat_error, line_input);
12783 if (local_set == 0)
12785 errmsg ("tunnel local address not specified");
12788 if (remote_set == 0)
12790 errmsg ("tunnel remote address not specified");
12793 if (grp_set && mcast_sw_if_index == ~0)
12795 errmsg ("tunnel nonexistent multicast device");
12798 if (ipv4_set && ipv6_set)
12800 errmsg ("both IPv4 and IPv6 addresses specified");
12806 errmsg ("vni not specified");
12810 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12815 clib_memcpy (&mp->local, &local6, sizeof (local6));
12816 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12820 clib_memcpy (&mp->local, &local4, sizeof (local4));
12821 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12824 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12825 mp->encap_vrf_id = ntohl (encap_vrf_id);
12826 mp->decap_vrf_id = ntohl (decap_vrf_id);
12827 mp->protocol = protocol;
12828 mp->vni = ntohl (vni);
12829 mp->is_add = is_add;
12830 mp->is_ipv6 = ipv6_set;
12837 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12838 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12840 vat_main_t *vam = &vat_main;
12841 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12842 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12844 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12845 ntohl (mp->sw_if_index),
12846 format_ip46_address, &local, IP46_TYPE_ANY,
12847 format_ip46_address, &remote, IP46_TYPE_ANY,
12848 ntohl (mp->vni), mp->protocol,
12849 ntohl (mp->mcast_sw_if_index),
12850 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12854 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12855 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12857 vat_main_t *vam = &vat_main;
12858 vat_json_node_t *node = NULL;
12859 struct in_addr ip4;
12860 struct in6_addr ip6;
12862 if (VAT_JSON_ARRAY != vam->json_tree.type)
12864 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12865 vat_json_init_array (&vam->json_tree);
12867 node = vat_json_array_add (&vam->json_tree);
12869 vat_json_init_object (node);
12870 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12873 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12874 vat_json_object_add_ip6 (node, "local", ip6);
12875 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12876 vat_json_object_add_ip6 (node, "remote", ip6);
12880 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12881 vat_json_object_add_ip4 (node, "local", ip4);
12882 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12883 vat_json_object_add_ip4 (node, "remote", ip4);
12885 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12886 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12887 vat_json_object_add_uint (node, "mcast_sw_if_index",
12888 ntohl (mp->mcast_sw_if_index));
12889 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12890 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12891 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12895 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12897 unformat_input_t *i = vam->input;
12898 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12899 vl_api_control_ping_t *mp_ping;
12901 u8 sw_if_index_set = 0;
12904 /* Parse args required to build the message */
12905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12907 if (unformat (i, "sw_if_index %d", &sw_if_index))
12908 sw_if_index_set = 1;
12913 if (sw_if_index_set == 0)
12918 if (!vam->json_output)
12920 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12921 "sw_if_index", "local", "remote", "vni",
12922 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12925 /* Get list of vxlan-tunnel interfaces */
12926 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12928 mp->sw_if_index = htonl (sw_if_index);
12932 /* Use a control ping for synchronization */
12933 MPING (CONTROL_PING, mp_ping);
12940 static void vl_api_l2_fib_table_details_t_handler
12941 (vl_api_l2_fib_table_details_t * mp)
12943 vat_main_t *vam = &vat_main;
12945 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12947 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12948 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12952 static void vl_api_l2_fib_table_details_t_handler_json
12953 (vl_api_l2_fib_table_details_t * mp)
12955 vat_main_t *vam = &vat_main;
12956 vat_json_node_t *node = NULL;
12958 if (VAT_JSON_ARRAY != vam->json_tree.type)
12960 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12961 vat_json_init_array (&vam->json_tree);
12963 node = vat_json_array_add (&vam->json_tree);
12965 vat_json_init_object (node);
12966 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12967 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12968 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12969 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12970 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12971 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12975 api_l2_fib_table_dump (vat_main_t * vam)
12977 unformat_input_t *i = vam->input;
12978 vl_api_l2_fib_table_dump_t *mp;
12979 vl_api_control_ping_t *mp_ping;
12984 /* Parse args required to build the message */
12985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12987 if (unformat (i, "bd_id %d", &bd_id))
12993 if (bd_id_set == 0)
12995 errmsg ("missing bridge domain");
12999 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13001 /* Get list of l2 fib entries */
13002 M (L2_FIB_TABLE_DUMP, mp);
13004 mp->bd_id = ntohl (bd_id);
13007 /* Use a control ping for synchronization */
13008 MPING (CONTROL_PING, mp_ping);
13017 api_interface_name_renumber (vat_main_t * vam)
13019 unformat_input_t *line_input = vam->input;
13020 vl_api_interface_name_renumber_t *mp;
13021 u32 sw_if_index = ~0;
13022 u32 new_show_dev_instance = ~0;
13025 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13027 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13030 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13032 else if (unformat (line_input, "new_show_dev_instance %d",
13033 &new_show_dev_instance))
13039 if (sw_if_index == ~0)
13041 errmsg ("missing interface name or sw_if_index");
13045 if (new_show_dev_instance == ~0)
13047 errmsg ("missing new_show_dev_instance");
13051 M (INTERFACE_NAME_RENUMBER, mp);
13053 mp->sw_if_index = ntohl (sw_if_index);
13054 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13062 api_want_l2_macs_events (vat_main_t * vam)
13064 unformat_input_t *line_input = vam->input;
13065 vl_api_want_l2_macs_events_t *mp;
13066 u8 enable_disable = 1;
13067 u32 scan_delay = 0;
13068 u32 max_macs_in_event = 0;
13069 u32 learn_limit = 0;
13072 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13074 if (unformat (line_input, "learn-limit %d", &learn_limit))
13076 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13078 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13080 else if (unformat (line_input, "disable"))
13081 enable_disable = 0;
13086 M (WANT_L2_MACS_EVENTS, mp);
13087 mp->enable_disable = enable_disable;
13088 mp->pid = htonl (getpid ());
13089 mp->learn_limit = htonl (learn_limit);
13090 mp->scan_delay = (u8) scan_delay;
13091 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13098 api_input_acl_set_interface (vat_main_t * vam)
13100 unformat_input_t *i = vam->input;
13101 vl_api_input_acl_set_interface_t *mp;
13103 int sw_if_index_set;
13104 u32 ip4_table_index = ~0;
13105 u32 ip6_table_index = ~0;
13106 u32 l2_table_index = ~0;
13110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13112 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13113 sw_if_index_set = 1;
13114 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13115 sw_if_index_set = 1;
13116 else if (unformat (i, "del"))
13118 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13120 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13122 else if (unformat (i, "l2-table %d", &l2_table_index))
13126 clib_warning ("parse error '%U'", format_unformat_error, i);
13131 if (sw_if_index_set == 0)
13133 errmsg ("missing interface name or sw_if_index");
13137 M (INPUT_ACL_SET_INTERFACE, mp);
13139 mp->sw_if_index = ntohl (sw_if_index);
13140 mp->ip4_table_index = ntohl (ip4_table_index);
13141 mp->ip6_table_index = ntohl (ip6_table_index);
13142 mp->l2_table_index = ntohl (l2_table_index);
13143 mp->is_add = is_add;
13151 api_output_acl_set_interface (vat_main_t * vam)
13153 unformat_input_t *i = vam->input;
13154 vl_api_output_acl_set_interface_t *mp;
13156 int sw_if_index_set;
13157 u32 ip4_table_index = ~0;
13158 u32 ip6_table_index = ~0;
13159 u32 l2_table_index = ~0;
13163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13165 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13166 sw_if_index_set = 1;
13167 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13168 sw_if_index_set = 1;
13169 else if (unformat (i, "del"))
13171 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13173 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13175 else if (unformat (i, "l2-table %d", &l2_table_index))
13179 clib_warning ("parse error '%U'", format_unformat_error, i);
13184 if (sw_if_index_set == 0)
13186 errmsg ("missing interface name or sw_if_index");
13190 M (OUTPUT_ACL_SET_INTERFACE, mp);
13192 mp->sw_if_index = ntohl (sw_if_index);
13193 mp->ip4_table_index = ntohl (ip4_table_index);
13194 mp->ip6_table_index = ntohl (ip6_table_index);
13195 mp->l2_table_index = ntohl (l2_table_index);
13196 mp->is_add = is_add;
13204 api_ip_address_dump (vat_main_t * vam)
13206 unformat_input_t *i = vam->input;
13207 vl_api_ip_address_dump_t *mp;
13208 vl_api_control_ping_t *mp_ping;
13209 u32 sw_if_index = ~0;
13210 u8 sw_if_index_set = 0;
13215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13217 if (unformat (i, "sw_if_index %d", &sw_if_index))
13218 sw_if_index_set = 1;
13220 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13221 sw_if_index_set = 1;
13222 else if (unformat (i, "ipv4"))
13224 else if (unformat (i, "ipv6"))
13230 if (ipv4_set && ipv6_set)
13232 errmsg ("ipv4 and ipv6 flags cannot be both set");
13236 if ((!ipv4_set) && (!ipv6_set))
13238 errmsg ("no ipv4 nor ipv6 flag set");
13242 if (sw_if_index_set == 0)
13244 errmsg ("missing interface name or sw_if_index");
13248 vam->current_sw_if_index = sw_if_index;
13249 vam->is_ipv6 = ipv6_set;
13251 M (IP_ADDRESS_DUMP, mp);
13252 mp->sw_if_index = ntohl (sw_if_index);
13253 mp->is_ipv6 = ipv6_set;
13256 /* Use a control ping for synchronization */
13257 MPING (CONTROL_PING, mp_ping);
13265 api_ip_dump (vat_main_t * vam)
13267 vl_api_ip_dump_t *mp;
13268 vl_api_control_ping_t *mp_ping;
13269 unformat_input_t *in = vam->input;
13276 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13278 if (unformat (in, "ipv4"))
13280 else if (unformat (in, "ipv6"))
13286 if (ipv4_set && ipv6_set)
13288 errmsg ("ipv4 and ipv6 flags cannot be both set");
13292 if ((!ipv4_set) && (!ipv6_set))
13294 errmsg ("no ipv4 nor ipv6 flag set");
13298 is_ipv6 = ipv6_set;
13299 vam->is_ipv6 = is_ipv6;
13301 /* free old data */
13302 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13304 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13306 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13309 mp->is_ipv6 = ipv6_set;
13312 /* Use a control ping for synchronization */
13313 MPING (CONTROL_PING, mp_ping);
13321 api_ipsec_spd_add_del (vat_main_t * vam)
13323 unformat_input_t *i = vam->input;
13324 vl_api_ipsec_spd_add_del_t *mp;
13329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13331 if (unformat (i, "spd_id %d", &spd_id))
13333 else if (unformat (i, "del"))
13337 clib_warning ("parse error '%U'", format_unformat_error, i);
13343 errmsg ("spd_id must be set");
13347 M (IPSEC_SPD_ADD_DEL, mp);
13349 mp->spd_id = ntohl (spd_id);
13350 mp->is_add = is_add;
13358 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13360 unformat_input_t *i = vam->input;
13361 vl_api_ipsec_interface_add_del_spd_t *mp;
13363 u8 sw_if_index_set = 0;
13364 u32 spd_id = (u32) ~ 0;
13368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13370 if (unformat (i, "del"))
13372 else if (unformat (i, "spd_id %d", &spd_id))
13375 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13376 sw_if_index_set = 1;
13377 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13378 sw_if_index_set = 1;
13381 clib_warning ("parse error '%U'", format_unformat_error, i);
13387 if (spd_id == (u32) ~ 0)
13389 errmsg ("spd_id must be set");
13393 if (sw_if_index_set == 0)
13395 errmsg ("missing interface name or sw_if_index");
13399 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13401 mp->spd_id = ntohl (spd_id);
13402 mp->sw_if_index = ntohl (sw_if_index);
13403 mp->is_add = is_add;
13411 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13413 unformat_input_t *i = vam->input;
13414 vl_api_ipsec_spd_entry_add_del_t *mp;
13415 u8 is_add = 1, is_outbound = 0;
13416 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13418 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13419 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13420 vl_api_address_t laddr_start = { }, laddr_stop =
13429 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13431 if (unformat (i, "del"))
13433 if (unformat (i, "outbound"))
13435 if (unformat (i, "inbound"))
13437 else if (unformat (i, "spd_id %d", &spd_id))
13439 else if (unformat (i, "sa_id %d", &sa_id))
13441 else if (unformat (i, "priority %d", &priority))
13443 else if (unformat (i, "protocol %d", &protocol))
13445 else if (unformat (i, "lport_start %d", &lport_start))
13447 else if (unformat (i, "lport_stop %d", &lport_stop))
13449 else if (unformat (i, "rport_start %d", &rport_start))
13451 else if (unformat (i, "rport_stop %d", &rport_stop))
13453 else if (unformat (i, "laddr_start %U",
13454 unformat_vl_api_address, &laddr_start))
13456 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13459 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13462 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13466 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13468 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13470 clib_warning ("unsupported action: 'resolve'");
13476 clib_warning ("parse error '%U'", format_unformat_error, i);
13482 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13484 mp->is_add = is_add;
13486 mp->entry.spd_id = ntohl (spd_id);
13487 mp->entry.priority = ntohl (priority);
13488 mp->entry.is_outbound = is_outbound;
13490 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13491 sizeof (vl_api_address_t));
13492 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13493 sizeof (vl_api_address_t));
13494 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13495 sizeof (vl_api_address_t));
13496 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13497 sizeof (vl_api_address_t));
13499 mp->entry.protocol = (u8) protocol;
13500 mp->entry.local_port_start = ntohs ((u16) lport_start);
13501 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13502 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13503 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13504 mp->entry.policy = (u8) policy;
13505 mp->entry.sa_id = ntohl (sa_id);
13513 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13515 unformat_input_t *i = vam->input;
13516 vl_api_ipsec_sad_entry_add_del_t *mp;
13517 u32 sad_id = 0, spi = 0;
13518 u8 *ck = 0, *ik = 0;
13521 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13522 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13523 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13524 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13525 vl_api_address_t tun_src, tun_dst;
13528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13530 if (unformat (i, "del"))
13532 else if (unformat (i, "sad_id %d", &sad_id))
13534 else if (unformat (i, "spi %d", &spi))
13536 else if (unformat (i, "esp"))
13537 protocol = IPSEC_API_PROTO_ESP;
13539 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13541 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13542 if (ADDRESS_IP6 == tun_src.af)
13543 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13546 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13548 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13549 if (ADDRESS_IP6 == tun_src.af)
13550 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13553 if (unformat (i, "crypto_alg %U",
13554 unformat_ipsec_api_crypto_alg, &crypto_alg))
13556 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13558 else if (unformat (i, "integ_alg %U",
13559 unformat_ipsec_api_integ_alg, &integ_alg))
13561 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13565 clib_warning ("parse error '%U'", format_unformat_error, i);
13571 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13573 mp->is_add = is_add;
13574 mp->entry.sad_id = ntohl (sad_id);
13575 mp->entry.protocol = protocol;
13576 mp->entry.spi = ntohl (spi);
13577 mp->entry.flags = flags;
13579 mp->entry.crypto_algorithm = crypto_alg;
13580 mp->entry.integrity_algorithm = integ_alg;
13581 mp->entry.crypto_key.length = vec_len (ck);
13582 mp->entry.integrity_key.length = vec_len (ik);
13584 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13585 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13587 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13588 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13591 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13593 clib_memcpy (mp->entry.integrity_key.data, ik,
13594 mp->entry.integrity_key.length);
13596 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13598 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13599 sizeof (mp->entry.tunnel_src));
13600 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13601 sizeof (mp->entry.tunnel_dst));
13610 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13612 unformat_input_t *i = vam->input;
13613 vl_api_ipsec_tunnel_if_add_del_t *mp;
13614 u32 local_spi = 0, remote_spi = 0;
13615 u32 crypto_alg = 0, integ_alg = 0;
13616 u8 *lck = NULL, *rck = NULL;
13617 u8 *lik = NULL, *rik = NULL;
13618 vl_api_address_t local_ip = { 0 };
13619 vl_api_address_t remote_ip = { 0 };
13623 u8 anti_replay = 0;
13629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13631 if (unformat (i, "del"))
13633 else if (unformat (i, "esn"))
13635 else if (unformat (i, "anti-replay"))
13637 else if (unformat (i, "count %d", &count))
13639 else if (unformat (i, "local_spi %d", &local_spi))
13641 else if (unformat (i, "remote_spi %d", &remote_spi))
13644 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13647 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13649 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13652 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13654 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13656 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13660 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13662 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13664 errmsg ("unsupported crypto-alg: '%U'\n",
13665 format_ipsec_crypto_alg, crypto_alg);
13671 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13673 if (integ_alg >= IPSEC_INTEG_N_ALG)
13675 errmsg ("unsupported integ-alg: '%U'\n",
13676 format_ipsec_integ_alg, integ_alg);
13680 else if (unformat (i, "instance %u", &instance))
13684 errmsg ("parse error '%U'\n", format_unformat_error, i);
13691 /* Turn on async mode */
13692 vam->async_mode = 1;
13693 vam->async_errors = 0;
13694 before = vat_time_now (vam);
13697 for (jj = 0; jj < count; jj++)
13699 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13701 mp->is_add = is_add;
13703 mp->anti_replay = anti_replay;
13706 increment_address (&remote_ip);
13708 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13709 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13711 mp->local_spi = htonl (local_spi + jj);
13712 mp->remote_spi = htonl (remote_spi + jj);
13713 mp->crypto_alg = (u8) crypto_alg;
13715 mp->local_crypto_key_len = 0;
13718 mp->local_crypto_key_len = vec_len (lck);
13719 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13720 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13721 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13724 mp->remote_crypto_key_len = 0;
13727 mp->remote_crypto_key_len = vec_len (rck);
13728 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13729 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13730 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13733 mp->integ_alg = (u8) integ_alg;
13735 mp->local_integ_key_len = 0;
13738 mp->local_integ_key_len = vec_len (lik);
13739 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13740 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13741 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13744 mp->remote_integ_key_len = 0;
13747 mp->remote_integ_key_len = vec_len (rik);
13748 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13749 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13750 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13755 mp->renumber = renumber;
13756 mp->show_instance = ntohl (instance);
13761 /* When testing multiple add/del ops, use a control-ping to sync */
13764 vl_api_control_ping_t *mp_ping;
13768 /* Shut off async mode */
13769 vam->async_mode = 0;
13771 MPING (CONTROL_PING, mp_ping);
13774 timeout = vat_time_now (vam) + 1.0;
13775 while (vat_time_now (vam) < timeout)
13776 if (vam->result_ready == 1)
13781 if (vam->retval == -99)
13782 errmsg ("timeout");
13784 if (vam->async_errors > 0)
13786 errmsg ("%d asynchronous errors", vam->async_errors);
13789 vam->async_errors = 0;
13790 after = vat_time_now (vam);
13792 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13796 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13797 count, after - before, count / (after - before));
13801 /* Wait for a reply... */
13810 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13812 vat_main_t *vam = &vat_main;
13814 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13815 "crypto_key %U integ_alg %u integ_key %U flags %x "
13816 "tunnel_src_addr %U tunnel_dst_addr %U "
13817 "salt %u seq_outbound %lu last_seq_inbound %lu "
13818 "replay_window %lu\n",
13819 ntohl (mp->entry.sad_id),
13820 ntohl (mp->sw_if_index),
13821 ntohl (mp->entry.spi),
13822 ntohl (mp->entry.protocol),
13823 ntohl (mp->entry.crypto_algorithm),
13824 format_hex_bytes, mp->entry.crypto_key.data,
13825 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13826 format_hex_bytes, mp->entry.integrity_key.data,
13827 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13828 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13829 &mp->entry.tunnel_dst, ntohl (mp->salt),
13830 clib_net_to_host_u64 (mp->seq_outbound),
13831 clib_net_to_host_u64 (mp->last_seq_inbound),
13832 clib_net_to_host_u64 (mp->replay_window));
13835 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13836 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13838 static void vl_api_ipsec_sa_details_t_handler_json
13839 (vl_api_ipsec_sa_details_t * mp)
13841 vat_main_t *vam = &vat_main;
13842 vat_json_node_t *node = NULL;
13843 vl_api_ipsec_sad_flags_t flags;
13845 if (VAT_JSON_ARRAY != vam->json_tree.type)
13847 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13848 vat_json_init_array (&vam->json_tree);
13850 node = vat_json_array_add (&vam->json_tree);
13852 vat_json_init_object (node);
13853 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13854 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13855 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13856 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13857 vat_json_object_add_uint (node, "crypto_alg",
13858 ntohl (mp->entry.crypto_algorithm));
13859 vat_json_object_add_uint (node, "integ_alg",
13860 ntohl (mp->entry.integrity_algorithm));
13861 flags = ntohl (mp->entry.flags);
13862 vat_json_object_add_uint (node, "use_esn",
13863 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13864 vat_json_object_add_uint (node, "use_anti_replay",
13865 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13866 vat_json_object_add_uint (node, "is_tunnel",
13867 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13868 vat_json_object_add_uint (node, "is_tunnel_ip6",
13869 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13870 vat_json_object_add_uint (node, "udp_encap",
13871 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13872 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13873 mp->entry.crypto_key.length);
13874 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13875 mp->entry.integrity_key.length);
13876 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13877 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13878 vat_json_object_add_uint (node, "replay_window",
13879 clib_net_to_host_u64 (mp->replay_window));
13883 api_ipsec_sa_dump (vat_main_t * vam)
13885 unformat_input_t *i = vam->input;
13886 vl_api_ipsec_sa_dump_t *mp;
13887 vl_api_control_ping_t *mp_ping;
13891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13893 if (unformat (i, "sa_id %d", &sa_id))
13897 clib_warning ("parse error '%U'", format_unformat_error, i);
13902 M (IPSEC_SA_DUMP, mp);
13904 mp->sa_id = ntohl (sa_id);
13908 /* Use a control ping for synchronization */
13909 M (CONTROL_PING, mp_ping);
13917 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13919 unformat_input_t *i = vam->input;
13920 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13921 u32 sw_if_index = ~0;
13923 u8 is_outbound = (u8) ~ 0;
13926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13928 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13930 else if (unformat (i, "sa_id %d", &sa_id))
13932 else if (unformat (i, "outbound"))
13934 else if (unformat (i, "inbound"))
13938 clib_warning ("parse error '%U'", format_unformat_error, i);
13943 if (sw_if_index == ~0)
13945 errmsg ("interface must be specified");
13951 errmsg ("SA ID must be specified");
13955 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13957 mp->sw_if_index = htonl (sw_if_index);
13958 mp->sa_id = htonl (sa_id);
13959 mp->is_outbound = is_outbound;
13968 api_get_first_msg_id (vat_main_t * vam)
13970 vl_api_get_first_msg_id_t *mp;
13971 unformat_input_t *i = vam->input;
13976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13978 if (unformat (i, "client %s", &name))
13986 errmsg ("missing client name");
13989 vec_add1 (name, 0);
13991 if (vec_len (name) > 63)
13993 errmsg ("client name too long");
13997 M (GET_FIRST_MSG_ID, mp);
13998 clib_memcpy (mp->name, name, vec_len (name));
14005 api_cop_interface_enable_disable (vat_main_t * vam)
14007 unformat_input_t *line_input = vam->input;
14008 vl_api_cop_interface_enable_disable_t *mp;
14009 u32 sw_if_index = ~0;
14010 u8 enable_disable = 1;
14013 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14015 if (unformat (line_input, "disable"))
14016 enable_disable = 0;
14017 if (unformat (line_input, "enable"))
14018 enable_disable = 1;
14019 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14020 vam, &sw_if_index))
14022 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14028 if (sw_if_index == ~0)
14030 errmsg ("missing interface name or sw_if_index");
14034 /* Construct the API message */
14035 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14036 mp->sw_if_index = ntohl (sw_if_index);
14037 mp->enable_disable = enable_disable;
14041 /* Wait for the reply */
14047 api_cop_whitelist_enable_disable (vat_main_t * vam)
14049 unformat_input_t *line_input = vam->input;
14050 vl_api_cop_whitelist_enable_disable_t *mp;
14051 u32 sw_if_index = ~0;
14052 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14056 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14058 if (unformat (line_input, "ip4"))
14060 else if (unformat (line_input, "ip6"))
14062 else if (unformat (line_input, "default"))
14064 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14065 vam, &sw_if_index))
14067 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14069 else if (unformat (line_input, "fib-id %d", &fib_id))
14075 if (sw_if_index == ~0)
14077 errmsg ("missing interface name or sw_if_index");
14081 /* Construct the API message */
14082 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14083 mp->sw_if_index = ntohl (sw_if_index);
14084 mp->fib_id = ntohl (fib_id);
14087 mp->default_cop = default_cop;
14091 /* Wait for the reply */
14097 api_get_node_graph (vat_main_t * vam)
14099 vl_api_get_node_graph_t *mp;
14102 M (GET_NODE_GRAPH, mp);
14106 /* Wait for the reply */
14112 /** Used for parsing LISP eids */
14113 typedef CLIB_PACKED(struct{
14114 u8 addr[16]; /**< eid address */
14115 u32 len; /**< prefix length if IP */
14116 u8 type; /**< type of eid */
14121 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14123 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14125 clib_memset (a, 0, sizeof (a[0]));
14127 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14129 a->type = 0; /* ipv4 type */
14131 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14133 a->type = 1; /* ipv6 type */
14135 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14137 a->type = 2; /* mac type */
14139 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14141 a->type = 3; /* NSH type */
14142 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14143 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14150 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14159 lisp_eid_size_vat (u8 type)
14176 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14178 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14182 api_one_add_del_locator_set (vat_main_t * vam)
14184 unformat_input_t *input = vam->input;
14185 vl_api_one_add_del_locator_set_t *mp;
14187 u8 *locator_set_name = NULL;
14188 u8 locator_set_name_set = 0;
14189 vl_api_local_locator_t locator, *locators = 0;
14190 u32 sw_if_index, priority, weight;
14194 /* Parse args required to build the message */
14195 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14197 if (unformat (input, "del"))
14201 else if (unformat (input, "locator-set %s", &locator_set_name))
14203 locator_set_name_set = 1;
14205 else if (unformat (input, "sw_if_index %u p %u w %u",
14206 &sw_if_index, &priority, &weight))
14208 locator.sw_if_index = htonl (sw_if_index);
14209 locator.priority = priority;
14210 locator.weight = weight;
14211 vec_add1 (locators, locator);
14215 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14216 &sw_if_index, &priority, &weight))
14218 locator.sw_if_index = htonl (sw_if_index);
14219 locator.priority = priority;
14220 locator.weight = weight;
14221 vec_add1 (locators, locator);
14227 if (locator_set_name_set == 0)
14229 errmsg ("missing locator-set name");
14230 vec_free (locators);
14234 if (vec_len (locator_set_name) > 64)
14236 errmsg ("locator-set name too long");
14237 vec_free (locator_set_name);
14238 vec_free (locators);
14241 vec_add1 (locator_set_name, 0);
14243 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14245 /* Construct the API message */
14246 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14248 mp->is_add = is_add;
14249 clib_memcpy (mp->locator_set_name, locator_set_name,
14250 vec_len (locator_set_name));
14251 vec_free (locator_set_name);
14253 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14255 clib_memcpy (mp->locators, locators, data_len);
14256 vec_free (locators);
14261 /* Wait for a reply... */
14266 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14269 api_one_add_del_locator (vat_main_t * vam)
14271 unformat_input_t *input = vam->input;
14272 vl_api_one_add_del_locator_t *mp;
14273 u32 tmp_if_index = ~0;
14274 u32 sw_if_index = ~0;
14275 u8 sw_if_index_set = 0;
14276 u8 sw_if_index_if_name_set = 0;
14278 u8 priority_set = 0;
14282 u8 *locator_set_name = NULL;
14283 u8 locator_set_name_set = 0;
14286 /* Parse args required to build the message */
14287 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14289 if (unformat (input, "del"))
14293 else if (unformat (input, "locator-set %s", &locator_set_name))
14295 locator_set_name_set = 1;
14297 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14300 sw_if_index_if_name_set = 1;
14301 sw_if_index = tmp_if_index;
14303 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14305 sw_if_index_set = 1;
14306 sw_if_index = tmp_if_index;
14308 else if (unformat (input, "p %d", &priority))
14312 else if (unformat (input, "w %d", &weight))
14320 if (locator_set_name_set == 0)
14322 errmsg ("missing locator-set name");
14326 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14328 errmsg ("missing sw_if_index");
14329 vec_free (locator_set_name);
14333 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14335 errmsg ("cannot use both params interface name and sw_if_index");
14336 vec_free (locator_set_name);
14340 if (priority_set == 0)
14342 errmsg ("missing locator-set priority");
14343 vec_free (locator_set_name);
14347 if (weight_set == 0)
14349 errmsg ("missing locator-set weight");
14350 vec_free (locator_set_name);
14354 if (vec_len (locator_set_name) > 64)
14356 errmsg ("locator-set name too long");
14357 vec_free (locator_set_name);
14360 vec_add1 (locator_set_name, 0);
14362 /* Construct the API message */
14363 M (ONE_ADD_DEL_LOCATOR, mp);
14365 mp->is_add = is_add;
14366 mp->sw_if_index = ntohl (sw_if_index);
14367 mp->priority = priority;
14368 mp->weight = weight;
14369 clib_memcpy (mp->locator_set_name, locator_set_name,
14370 vec_len (locator_set_name));
14371 vec_free (locator_set_name);
14376 /* Wait for a reply... */
14381 #define api_lisp_add_del_locator api_one_add_del_locator
14384 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14386 u32 *key_id = va_arg (*args, u32 *);
14389 if (unformat (input, "%s", &s))
14391 if (!strcmp ((char *) s, "sha1"))
14392 key_id[0] = HMAC_SHA_1_96;
14393 else if (!strcmp ((char *) s, "sha256"))
14394 key_id[0] = HMAC_SHA_256_128;
14397 clib_warning ("invalid key_id: '%s'", s);
14398 key_id[0] = HMAC_NO_KEY;
14409 api_one_add_del_local_eid (vat_main_t * vam)
14411 unformat_input_t *input = vam->input;
14412 vl_api_one_add_del_local_eid_t *mp;
14415 lisp_eid_vat_t _eid, *eid = &_eid;
14416 u8 *locator_set_name = 0;
14417 u8 locator_set_name_set = 0;
14423 /* Parse args required to build the message */
14424 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14426 if (unformat (input, "del"))
14430 else if (unformat (input, "vni %d", &vni))
14434 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14438 else if (unformat (input, "locator-set %s", &locator_set_name))
14440 locator_set_name_set = 1;
14442 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14444 else if (unformat (input, "secret-key %_%v%_", &key))
14450 if (locator_set_name_set == 0)
14452 errmsg ("missing locator-set name");
14458 errmsg ("EID address not set!");
14459 vec_free (locator_set_name);
14463 if (key && (0 == key_id))
14465 errmsg ("invalid key_id!");
14469 if (vec_len (key) > 64)
14471 errmsg ("key too long");
14476 if (vec_len (locator_set_name) > 64)
14478 errmsg ("locator-set name too long");
14479 vec_free (locator_set_name);
14482 vec_add1 (locator_set_name, 0);
14484 /* Construct the API message */
14485 M (ONE_ADD_DEL_LOCAL_EID, mp);
14487 mp->is_add = is_add;
14488 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14489 mp->eid_type = eid->type;
14490 mp->prefix_len = eid->len;
14491 mp->vni = clib_host_to_net_u32 (vni);
14492 mp->key_id = clib_host_to_net_u16 (key_id);
14493 clib_memcpy (mp->locator_set_name, locator_set_name,
14494 vec_len (locator_set_name));
14495 clib_memcpy (mp->key, key, vec_len (key));
14497 vec_free (locator_set_name);
14503 /* Wait for a reply... */
14508 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14511 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14513 u32 dp_table = 0, vni = 0;;
14514 unformat_input_t *input = vam->input;
14515 vl_api_gpe_add_del_fwd_entry_t *mp;
14517 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14518 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14519 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14520 u32 action = ~0, w;
14521 ip4_address_t rmt_rloc4, lcl_rloc4;
14522 ip6_address_t rmt_rloc6, lcl_rloc6;
14523 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14526 clib_memset (&rloc, 0, sizeof (rloc));
14528 /* Parse args required to build the message */
14529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14531 if (unformat (input, "del"))
14533 else if (unformat (input, "add"))
14535 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14539 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14543 else if (unformat (input, "vrf %d", &dp_table))
14545 else if (unformat (input, "bd %d", &dp_table))
14547 else if (unformat (input, "vni %d", &vni))
14549 else if (unformat (input, "w %d", &w))
14553 errmsg ("No RLOC configured for setting priority/weight!");
14556 curr_rloc->weight = w;
14558 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14559 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14563 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14565 vec_add1 (lcl_locs, rloc);
14567 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14568 vec_add1 (rmt_locs, rloc);
14569 /* weight saved in rmt loc */
14570 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14572 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14573 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14576 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14578 vec_add1 (lcl_locs, rloc);
14580 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14581 vec_add1 (rmt_locs, rloc);
14582 /* weight saved in rmt loc */
14583 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14585 else if (unformat (input, "action %d", &action))
14591 clib_warning ("parse error '%U'", format_unformat_error, input);
14598 errmsg ("remote eid addresses not set");
14602 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14604 errmsg ("eid types don't match");
14608 if (0 == rmt_locs && (u32) ~ 0 == action)
14610 errmsg ("action not set for negative mapping");
14614 /* Construct the API message */
14615 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14616 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14618 mp->is_add = is_add;
14619 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14620 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14621 mp->eid_type = rmt_eid->type;
14622 mp->dp_table = clib_host_to_net_u32 (dp_table);
14623 mp->vni = clib_host_to_net_u32 (vni);
14624 mp->rmt_len = rmt_eid->len;
14625 mp->lcl_len = lcl_eid->len;
14626 mp->action = action;
14628 if (0 != rmt_locs && 0 != lcl_locs)
14630 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14631 clib_memcpy (mp->locs, lcl_locs,
14632 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14634 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14635 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14636 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14638 vec_free (lcl_locs);
14639 vec_free (rmt_locs);
14644 /* Wait for a reply... */
14650 api_one_add_del_map_server (vat_main_t * vam)
14652 unformat_input_t *input = vam->input;
14653 vl_api_one_add_del_map_server_t *mp;
14657 ip4_address_t ipv4;
14658 ip6_address_t ipv6;
14661 /* Parse args required to build the message */
14662 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14664 if (unformat (input, "del"))
14668 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14672 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14680 if (ipv4_set && ipv6_set)
14682 errmsg ("both eid v4 and v6 addresses set");
14686 if (!ipv4_set && !ipv6_set)
14688 errmsg ("eid addresses not set");
14692 /* Construct the API message */
14693 M (ONE_ADD_DEL_MAP_SERVER, mp);
14695 mp->is_add = is_add;
14699 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14704 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14710 /* Wait for a reply... */
14715 #define api_lisp_add_del_map_server api_one_add_del_map_server
14718 api_one_add_del_map_resolver (vat_main_t * vam)
14720 unformat_input_t *input = vam->input;
14721 vl_api_one_add_del_map_resolver_t *mp;
14725 ip4_address_t ipv4;
14726 ip6_address_t ipv6;
14729 /* Parse args required to build the message */
14730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14732 if (unformat (input, "del"))
14736 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14740 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14748 if (ipv4_set && ipv6_set)
14750 errmsg ("both eid v4 and v6 addresses set");
14754 if (!ipv4_set && !ipv6_set)
14756 errmsg ("eid addresses not set");
14760 /* Construct the API message */
14761 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14763 mp->is_add = is_add;
14767 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14772 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14778 /* Wait for a reply... */
14783 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14786 api_lisp_gpe_enable_disable (vat_main_t * vam)
14788 unformat_input_t *input = vam->input;
14789 vl_api_gpe_enable_disable_t *mp;
14794 /* Parse args required to build the message */
14795 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14797 if (unformat (input, "enable"))
14802 else if (unformat (input, "disable"))
14813 errmsg ("Value not set");
14817 /* Construct the API message */
14818 M (GPE_ENABLE_DISABLE, mp);
14825 /* Wait for a reply... */
14831 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14833 unformat_input_t *input = vam->input;
14834 vl_api_one_rloc_probe_enable_disable_t *mp;
14839 /* Parse args required to build the message */
14840 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14842 if (unformat (input, "enable"))
14847 else if (unformat (input, "disable"))
14855 errmsg ("Value not set");
14859 /* Construct the API message */
14860 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14862 mp->is_enabled = is_en;
14867 /* Wait for a reply... */
14872 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14875 api_one_map_register_enable_disable (vat_main_t * vam)
14877 unformat_input_t *input = vam->input;
14878 vl_api_one_map_register_enable_disable_t *mp;
14883 /* Parse args required to build the message */
14884 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14886 if (unformat (input, "enable"))
14891 else if (unformat (input, "disable"))
14899 errmsg ("Value not set");
14903 /* Construct the API message */
14904 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14906 mp->is_enabled = is_en;
14911 /* Wait for a reply... */
14916 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14919 api_one_enable_disable (vat_main_t * vam)
14921 unformat_input_t *input = vam->input;
14922 vl_api_one_enable_disable_t *mp;
14927 /* Parse args required to build the message */
14928 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14930 if (unformat (input, "enable"))
14935 else if (unformat (input, "disable"))
14945 errmsg ("Value not set");
14949 /* Construct the API message */
14950 M (ONE_ENABLE_DISABLE, mp);
14957 /* Wait for a reply... */
14962 #define api_lisp_enable_disable api_one_enable_disable
14965 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14967 unformat_input_t *input = vam->input;
14968 vl_api_one_enable_disable_xtr_mode_t *mp;
14973 /* Parse args required to build the message */
14974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14976 if (unformat (input, "enable"))
14981 else if (unformat (input, "disable"))
14991 errmsg ("Value not set");
14995 /* Construct the API message */
14996 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15003 /* Wait for a reply... */
15009 api_one_show_xtr_mode (vat_main_t * vam)
15011 vl_api_one_show_xtr_mode_t *mp;
15014 /* Construct the API message */
15015 M (ONE_SHOW_XTR_MODE, mp);
15020 /* Wait for a reply... */
15026 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15028 unformat_input_t *input = vam->input;
15029 vl_api_one_enable_disable_pitr_mode_t *mp;
15034 /* Parse args required to build the message */
15035 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15037 if (unformat (input, "enable"))
15042 else if (unformat (input, "disable"))
15052 errmsg ("Value not set");
15056 /* Construct the API message */
15057 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15064 /* Wait for a reply... */
15070 api_one_show_pitr_mode (vat_main_t * vam)
15072 vl_api_one_show_pitr_mode_t *mp;
15075 /* Construct the API message */
15076 M (ONE_SHOW_PITR_MODE, mp);
15081 /* Wait for a reply... */
15087 api_one_enable_disable_petr_mode (vat_main_t * vam)
15089 unformat_input_t *input = vam->input;
15090 vl_api_one_enable_disable_petr_mode_t *mp;
15095 /* Parse args required to build the message */
15096 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15098 if (unformat (input, "enable"))
15103 else if (unformat (input, "disable"))
15113 errmsg ("Value not set");
15117 /* Construct the API message */
15118 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15125 /* Wait for a reply... */
15131 api_one_show_petr_mode (vat_main_t * vam)
15133 vl_api_one_show_petr_mode_t *mp;
15136 /* Construct the API message */
15137 M (ONE_SHOW_PETR_MODE, mp);
15142 /* Wait for a reply... */
15148 api_show_one_map_register_state (vat_main_t * vam)
15150 vl_api_show_one_map_register_state_t *mp;
15153 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15158 /* wait for reply */
15163 #define api_show_lisp_map_register_state api_show_one_map_register_state
15166 api_show_one_rloc_probe_state (vat_main_t * vam)
15168 vl_api_show_one_rloc_probe_state_t *mp;
15171 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15176 /* wait for reply */
15181 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15184 api_one_add_del_ndp_entry (vat_main_t * vam)
15186 vl_api_one_add_del_ndp_entry_t *mp;
15187 unformat_input_t *input = vam->input;
15192 u8 mac[6] = { 0, };
15193 u8 ip6[16] = { 0, };
15197 /* Parse args required to build the message */
15198 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15200 if (unformat (input, "del"))
15202 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15204 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15206 else if (unformat (input, "bd %d", &bd))
15210 errmsg ("parse error '%U'", format_unformat_error, input);
15215 if (!bd_set || !ip_set || (!mac_set && is_add))
15217 errmsg ("Missing BD, IP or MAC!");
15221 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15222 mp->is_add = is_add;
15223 clib_memcpy (mp->mac, mac, 6);
15224 mp->bd = clib_host_to_net_u32 (bd);
15225 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15230 /* wait for reply */
15236 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15238 vl_api_one_add_del_l2_arp_entry_t *mp;
15239 unformat_input_t *input = vam->input;
15244 u8 mac[6] = { 0, };
15245 u32 ip4 = 0, bd = ~0;
15248 /* Parse args required to build the message */
15249 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15251 if (unformat (input, "del"))
15253 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15255 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15257 else if (unformat (input, "bd %d", &bd))
15261 errmsg ("parse error '%U'", format_unformat_error, input);
15266 if (!bd_set || !ip_set || (!mac_set && is_add))
15268 errmsg ("Missing BD, IP or MAC!");
15272 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15273 mp->is_add = is_add;
15274 clib_memcpy (mp->mac, mac, 6);
15275 mp->bd = clib_host_to_net_u32 (bd);
15281 /* wait for reply */
15287 api_one_ndp_bd_get (vat_main_t * vam)
15289 vl_api_one_ndp_bd_get_t *mp;
15292 M (ONE_NDP_BD_GET, mp);
15297 /* wait for reply */
15303 api_one_ndp_entries_get (vat_main_t * vam)
15305 vl_api_one_ndp_entries_get_t *mp;
15306 unformat_input_t *input = vam->input;
15311 /* Parse args required to build the message */
15312 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15314 if (unformat (input, "bd %d", &bd))
15318 errmsg ("parse error '%U'", format_unformat_error, input);
15325 errmsg ("Expected bridge domain!");
15329 M (ONE_NDP_ENTRIES_GET, mp);
15330 mp->bd = clib_host_to_net_u32 (bd);
15335 /* wait for reply */
15341 api_one_l2_arp_bd_get (vat_main_t * vam)
15343 vl_api_one_l2_arp_bd_get_t *mp;
15346 M (ONE_L2_ARP_BD_GET, mp);
15351 /* wait for reply */
15357 api_one_l2_arp_entries_get (vat_main_t * vam)
15359 vl_api_one_l2_arp_entries_get_t *mp;
15360 unformat_input_t *input = vam->input;
15365 /* Parse args required to build the message */
15366 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15368 if (unformat (input, "bd %d", &bd))
15372 errmsg ("parse error '%U'", format_unformat_error, input);
15379 errmsg ("Expected bridge domain!");
15383 M (ONE_L2_ARP_ENTRIES_GET, mp);
15384 mp->bd = clib_host_to_net_u32 (bd);
15389 /* wait for reply */
15395 api_one_stats_enable_disable (vat_main_t * vam)
15397 vl_api_one_stats_enable_disable_t *mp;
15398 unformat_input_t *input = vam->input;
15403 /* Parse args required to build the message */
15404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15406 if (unformat (input, "enable"))
15411 else if (unformat (input, "disable"))
15421 errmsg ("Value not set");
15425 M (ONE_STATS_ENABLE_DISABLE, mp);
15431 /* wait for reply */
15437 api_show_one_stats_enable_disable (vat_main_t * vam)
15439 vl_api_show_one_stats_enable_disable_t *mp;
15442 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15447 /* wait for reply */
15453 api_show_one_map_request_mode (vat_main_t * vam)
15455 vl_api_show_one_map_request_mode_t *mp;
15458 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15463 /* wait for reply */
15468 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15471 api_one_map_request_mode (vat_main_t * vam)
15473 unformat_input_t *input = vam->input;
15474 vl_api_one_map_request_mode_t *mp;
15478 /* Parse args required to build the message */
15479 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15481 if (unformat (input, "dst-only"))
15483 else if (unformat (input, "src-dst"))
15487 errmsg ("parse error '%U'", format_unformat_error, input);
15492 M (ONE_MAP_REQUEST_MODE, mp);
15499 /* wait for reply */
15504 #define api_lisp_map_request_mode api_one_map_request_mode
15507 * Enable/disable ONE proxy ITR.
15509 * @param vam vpp API test context
15510 * @return return code
15513 api_one_pitr_set_locator_set (vat_main_t * vam)
15515 u8 ls_name_set = 0;
15516 unformat_input_t *input = vam->input;
15517 vl_api_one_pitr_set_locator_set_t *mp;
15522 /* Parse args required to build the message */
15523 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15525 if (unformat (input, "del"))
15527 else if (unformat (input, "locator-set %s", &ls_name))
15531 errmsg ("parse error '%U'", format_unformat_error, input);
15538 errmsg ("locator-set name not set!");
15542 M (ONE_PITR_SET_LOCATOR_SET, mp);
15544 mp->is_add = is_add;
15545 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15546 vec_free (ls_name);
15551 /* wait for reply */
15556 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15559 api_one_nsh_set_locator_set (vat_main_t * vam)
15561 u8 ls_name_set = 0;
15562 unformat_input_t *input = vam->input;
15563 vl_api_one_nsh_set_locator_set_t *mp;
15568 /* Parse args required to build the message */
15569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15571 if (unformat (input, "del"))
15573 else if (unformat (input, "ls %s", &ls_name))
15577 errmsg ("parse error '%U'", format_unformat_error, input);
15582 if (!ls_name_set && is_add)
15584 errmsg ("locator-set name not set!");
15588 M (ONE_NSH_SET_LOCATOR_SET, mp);
15590 mp->is_add = is_add;
15591 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15592 vec_free (ls_name);
15597 /* wait for reply */
15603 api_show_one_pitr (vat_main_t * vam)
15605 vl_api_show_one_pitr_t *mp;
15608 if (!vam->json_output)
15610 print (vam->ofp, "%=20s", "lisp status:");
15613 M (SHOW_ONE_PITR, mp);
15617 /* Wait for a reply... */
15622 #define api_show_lisp_pitr api_show_one_pitr
15625 api_one_use_petr (vat_main_t * vam)
15627 unformat_input_t *input = vam->input;
15628 vl_api_one_use_petr_t *mp;
15633 clib_memset (&ip, 0, sizeof (ip));
15635 /* Parse args required to build the message */
15636 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15638 if (unformat (input, "disable"))
15641 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15644 ip_addr_version (&ip) = AF_IP4;
15647 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15650 ip_addr_version (&ip) = AF_IP6;
15654 errmsg ("parse error '%U'", format_unformat_error, input);
15659 M (ONE_USE_PETR, mp);
15661 mp->is_add = is_add;
15664 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15666 clib_memcpy (mp->address, &ip, 4);
15668 clib_memcpy (mp->address, &ip, 16);
15674 /* wait for reply */
15679 #define api_lisp_use_petr api_one_use_petr
15682 api_show_one_nsh_mapping (vat_main_t * vam)
15684 vl_api_show_one_use_petr_t *mp;
15687 if (!vam->json_output)
15689 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15692 M (SHOW_ONE_NSH_MAPPING, mp);
15696 /* Wait for a reply... */
15702 api_show_one_use_petr (vat_main_t * vam)
15704 vl_api_show_one_use_petr_t *mp;
15707 if (!vam->json_output)
15709 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15712 M (SHOW_ONE_USE_PETR, mp);
15716 /* Wait for a reply... */
15721 #define api_show_lisp_use_petr api_show_one_use_petr
15724 * Add/delete mapping between vni and vrf
15727 api_one_eid_table_add_del_map (vat_main_t * vam)
15729 unformat_input_t *input = vam->input;
15730 vl_api_one_eid_table_add_del_map_t *mp;
15731 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15732 u32 vni, vrf, bd_index;
15735 /* Parse args required to build the message */
15736 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15738 if (unformat (input, "del"))
15740 else if (unformat (input, "vrf %d", &vrf))
15742 else if (unformat (input, "bd_index %d", &bd_index))
15744 else if (unformat (input, "vni %d", &vni))
15750 if (!vni_set || (!vrf_set && !bd_index_set))
15752 errmsg ("missing arguments!");
15756 if (vrf_set && bd_index_set)
15758 errmsg ("error: both vrf and bd entered!");
15762 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15764 mp->is_add = is_add;
15765 mp->vni = htonl (vni);
15766 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15767 mp->is_l2 = bd_index_set;
15772 /* wait for reply */
15777 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15780 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15782 u32 *action = va_arg (*args, u32 *);
15785 if (unformat (input, "%s", &s))
15787 if (!strcmp ((char *) s, "no-action"))
15789 else if (!strcmp ((char *) s, "natively-forward"))
15791 else if (!strcmp ((char *) s, "send-map-request"))
15793 else if (!strcmp ((char *) s, "drop"))
15797 clib_warning ("invalid action: '%s'", s);
15809 * Add/del remote mapping to/from ONE control plane
15811 * @param vam vpp API test context
15812 * @return return code
15815 api_one_add_del_remote_mapping (vat_main_t * vam)
15817 unformat_input_t *input = vam->input;
15818 vl_api_one_add_del_remote_mapping_t *mp;
15820 lisp_eid_vat_t _eid, *eid = &_eid;
15821 lisp_eid_vat_t _seid, *seid = &_seid;
15822 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15823 u32 action = ~0, p, w, data_len;
15824 ip4_address_t rloc4;
15825 ip6_address_t rloc6;
15826 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15829 clib_memset (&rloc, 0, sizeof (rloc));
15831 /* Parse args required to build the message */
15832 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15834 if (unformat (input, "del-all"))
15838 else if (unformat (input, "del"))
15842 else if (unformat (input, "add"))
15846 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15850 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15854 else if (unformat (input, "vni %d", &vni))
15858 else if (unformat (input, "p %d w %d", &p, &w))
15862 errmsg ("No RLOC configured for setting priority/weight!");
15865 curr_rloc->priority = p;
15866 curr_rloc->weight = w;
15868 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15871 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15872 vec_add1 (rlocs, rloc);
15873 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15875 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15878 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15879 vec_add1 (rlocs, rloc);
15880 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15882 else if (unformat (input, "action %U",
15883 unformat_negative_mapping_action, &action))
15889 clib_warning ("parse error '%U'", format_unformat_error, input);
15896 errmsg ("missing params!");
15900 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15902 errmsg ("no action set for negative map-reply!");
15906 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15908 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15909 mp->is_add = is_add;
15910 mp->vni = htonl (vni);
15911 mp->action = (u8) action;
15912 mp->is_src_dst = seid_set;
15913 mp->eid_len = eid->len;
15914 mp->seid_len = seid->len;
15915 mp->del_all = del_all;
15916 mp->eid_type = eid->type;
15917 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15918 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15920 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15921 clib_memcpy (mp->rlocs, rlocs, data_len);
15927 /* Wait for a reply... */
15932 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15935 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15936 * forwarding entries in data-plane accordingly.
15938 * @param vam vpp API test context
15939 * @return return code
15942 api_one_add_del_adjacency (vat_main_t * vam)
15944 unformat_input_t *input = vam->input;
15945 vl_api_one_add_del_adjacency_t *mp;
15947 ip4_address_t leid4, reid4;
15948 ip6_address_t leid6, reid6;
15949 u8 reid_mac[6] = { 0 };
15950 u8 leid_mac[6] = { 0 };
15951 u8 reid_type, leid_type;
15952 u32 leid_len = 0, reid_len = 0, len;
15956 leid_type = reid_type = (u8) ~ 0;
15958 /* Parse args required to build the message */
15959 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15961 if (unformat (input, "del"))
15965 else if (unformat (input, "add"))
15969 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15972 reid_type = 0; /* ipv4 */
15975 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15978 reid_type = 1; /* ipv6 */
15981 else if (unformat (input, "reid %U", unformat_ethernet_address,
15984 reid_type = 2; /* mac */
15986 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15989 leid_type = 0; /* ipv4 */
15992 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15995 leid_type = 1; /* ipv6 */
15998 else if (unformat (input, "leid %U", unformat_ethernet_address,
16001 leid_type = 2; /* mac */
16003 else if (unformat (input, "vni %d", &vni))
16009 errmsg ("parse error '%U'", format_unformat_error, input);
16014 if ((u8) ~ 0 == reid_type)
16016 errmsg ("missing params!");
16020 if (leid_type != reid_type)
16022 errmsg ("remote and local EIDs are of different types!");
16026 M (ONE_ADD_DEL_ADJACENCY, mp);
16027 mp->is_add = is_add;
16028 mp->vni = htonl (vni);
16029 mp->leid_len = leid_len;
16030 mp->reid_len = reid_len;
16031 mp->eid_type = reid_type;
16033 switch (mp->eid_type)
16036 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16037 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16040 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16041 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16044 clib_memcpy (mp->leid, leid_mac, 6);
16045 clib_memcpy (mp->reid, reid_mac, 6);
16048 errmsg ("unknown EID type %d!", mp->eid_type);
16055 /* Wait for a reply... */
16060 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16063 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16065 u32 *mode = va_arg (*args, u32 *);
16067 if (unformat (input, "lisp"))
16069 else if (unformat (input, "vxlan"))
16078 api_gpe_get_encap_mode (vat_main_t * vam)
16080 vl_api_gpe_get_encap_mode_t *mp;
16083 /* Construct the API message */
16084 M (GPE_GET_ENCAP_MODE, mp);
16089 /* Wait for a reply... */
16095 api_gpe_set_encap_mode (vat_main_t * vam)
16097 unformat_input_t *input = vam->input;
16098 vl_api_gpe_set_encap_mode_t *mp;
16102 /* Parse args required to build the message */
16103 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16105 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16111 /* Construct the API message */
16112 M (GPE_SET_ENCAP_MODE, mp);
16119 /* Wait for a reply... */
16125 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16127 unformat_input_t *input = vam->input;
16128 vl_api_gpe_add_del_iface_t *mp;
16129 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16130 u32 dp_table = 0, vni = 0;
16133 /* Parse args required to build the message */
16134 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16136 if (unformat (input, "up"))
16141 else if (unformat (input, "down"))
16146 else if (unformat (input, "table_id %d", &dp_table))
16150 else if (unformat (input, "bd_id %d", &dp_table))
16155 else if (unformat (input, "vni %d", &vni))
16163 if (action_set == 0)
16165 errmsg ("Action not set");
16168 if (dp_table_set == 0 || vni_set == 0)
16170 errmsg ("vni and dp_table must be set");
16174 /* Construct the API message */
16175 M (GPE_ADD_DEL_IFACE, mp);
16177 mp->is_add = is_add;
16178 mp->dp_table = clib_host_to_net_u32 (dp_table);
16180 mp->vni = clib_host_to_net_u32 (vni);
16185 /* Wait for a reply... */
16191 api_one_map_register_fallback_threshold (vat_main_t * vam)
16193 unformat_input_t *input = vam->input;
16194 vl_api_one_map_register_fallback_threshold_t *mp;
16199 /* Parse args required to build the message */
16200 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16202 if (unformat (input, "%u", &value))
16206 clib_warning ("parse error '%U'", format_unformat_error, input);
16213 errmsg ("fallback threshold value is missing!");
16217 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16218 mp->value = clib_host_to_net_u32 (value);
16223 /* Wait for a reply... */
16229 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16231 vl_api_show_one_map_register_fallback_threshold_t *mp;
16234 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16239 /* Wait for a reply... */
16245 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16247 u32 *proto = va_arg (*args, u32 *);
16249 if (unformat (input, "udp"))
16251 else if (unformat (input, "api"))
16260 api_one_set_transport_protocol (vat_main_t * vam)
16262 unformat_input_t *input = vam->input;
16263 vl_api_one_set_transport_protocol_t *mp;
16268 /* Parse args required to build the message */
16269 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16271 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16275 clib_warning ("parse error '%U'", format_unformat_error, input);
16282 errmsg ("Transport protocol missing!");
16286 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16287 mp->protocol = (u8) protocol;
16292 /* Wait for a reply... */
16298 api_one_get_transport_protocol (vat_main_t * vam)
16300 vl_api_one_get_transport_protocol_t *mp;
16303 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16308 /* Wait for a reply... */
16314 api_one_map_register_set_ttl (vat_main_t * vam)
16316 unformat_input_t *input = vam->input;
16317 vl_api_one_map_register_set_ttl_t *mp;
16322 /* Parse args required to build the message */
16323 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16325 if (unformat (input, "%u", &ttl))
16329 clib_warning ("parse error '%U'", format_unformat_error, input);
16336 errmsg ("TTL value missing!");
16340 M (ONE_MAP_REGISTER_SET_TTL, mp);
16341 mp->ttl = clib_host_to_net_u32 (ttl);
16346 /* Wait for a reply... */
16352 api_show_one_map_register_ttl (vat_main_t * vam)
16354 vl_api_show_one_map_register_ttl_t *mp;
16357 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16362 /* Wait for a reply... */
16368 * Add/del map request itr rlocs from ONE control plane and updates
16370 * @param vam vpp API test context
16371 * @return return code
16374 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16376 unformat_input_t *input = vam->input;
16377 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16378 u8 *locator_set_name = 0;
16379 u8 locator_set_name_set = 0;
16383 /* Parse args required to build the message */
16384 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16386 if (unformat (input, "del"))
16390 else if (unformat (input, "%_%v%_", &locator_set_name))
16392 locator_set_name_set = 1;
16396 clib_warning ("parse error '%U'", format_unformat_error, input);
16401 if (is_add && !locator_set_name_set)
16403 errmsg ("itr-rloc is not set!");
16407 if (is_add && vec_len (locator_set_name) > 64)
16409 errmsg ("itr-rloc locator-set name too long");
16410 vec_free (locator_set_name);
16414 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16415 mp->is_add = is_add;
16418 clib_memcpy (mp->locator_set_name, locator_set_name,
16419 vec_len (locator_set_name));
16423 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16425 vec_free (locator_set_name);
16430 /* Wait for a reply... */
16435 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16438 api_one_locator_dump (vat_main_t * vam)
16440 unformat_input_t *input = vam->input;
16441 vl_api_one_locator_dump_t *mp;
16442 vl_api_control_ping_t *mp_ping;
16443 u8 is_index_set = 0, is_name_set = 0;
16448 /* Parse args required to build the message */
16449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16451 if (unformat (input, "ls_name %_%v%_", &ls_name))
16455 else if (unformat (input, "ls_index %d", &ls_index))
16461 errmsg ("parse error '%U'", format_unformat_error, input);
16466 if (!is_index_set && !is_name_set)
16468 errmsg ("error: expected one of index or name!");
16472 if (is_index_set && is_name_set)
16474 errmsg ("error: only one param expected!");
16478 if (vec_len (ls_name) > 62)
16480 errmsg ("error: locator set name too long!");
16484 if (!vam->json_output)
16486 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16489 M (ONE_LOCATOR_DUMP, mp);
16490 mp->is_index_set = is_index_set;
16493 mp->ls_index = clib_host_to_net_u32 (ls_index);
16496 vec_add1 (ls_name, 0);
16497 strncpy ((char *) mp->ls_name, (char *) ls_name,
16498 sizeof (mp->ls_name) - 1);
16504 /* Use a control ping for synchronization */
16505 MPING (CONTROL_PING, mp_ping);
16508 /* Wait for a reply... */
16513 #define api_lisp_locator_dump api_one_locator_dump
16516 api_one_locator_set_dump (vat_main_t * vam)
16518 vl_api_one_locator_set_dump_t *mp;
16519 vl_api_control_ping_t *mp_ping;
16520 unformat_input_t *input = vam->input;
16524 /* Parse args required to build the message */
16525 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16527 if (unformat (input, "local"))
16531 else if (unformat (input, "remote"))
16537 errmsg ("parse error '%U'", format_unformat_error, input);
16542 if (!vam->json_output)
16544 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16547 M (ONE_LOCATOR_SET_DUMP, mp);
16549 mp->filter = filter;
16554 /* Use a control ping for synchronization */
16555 MPING (CONTROL_PING, mp_ping);
16558 /* Wait for a reply... */
16563 #define api_lisp_locator_set_dump api_one_locator_set_dump
16566 api_one_eid_table_map_dump (vat_main_t * vam)
16570 unformat_input_t *input = vam->input;
16571 vl_api_one_eid_table_map_dump_t *mp;
16572 vl_api_control_ping_t *mp_ping;
16575 /* Parse args required to build the message */
16576 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16578 if (unformat (input, "l2"))
16583 else if (unformat (input, "l3"))
16590 errmsg ("parse error '%U'", format_unformat_error, input);
16597 errmsg ("expected one of 'l2' or 'l3' parameter!");
16601 if (!vam->json_output)
16603 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16606 M (ONE_EID_TABLE_MAP_DUMP, mp);
16612 /* Use a control ping for synchronization */
16613 MPING (CONTROL_PING, mp_ping);
16616 /* Wait for a reply... */
16621 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16624 api_one_eid_table_vni_dump (vat_main_t * vam)
16626 vl_api_one_eid_table_vni_dump_t *mp;
16627 vl_api_control_ping_t *mp_ping;
16630 if (!vam->json_output)
16632 print (vam->ofp, "VNI");
16635 M (ONE_EID_TABLE_VNI_DUMP, mp);
16640 /* Use a control ping for synchronization */
16641 MPING (CONTROL_PING, mp_ping);
16644 /* Wait for a reply... */
16649 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16652 api_one_eid_table_dump (vat_main_t * vam)
16654 unformat_input_t *i = vam->input;
16655 vl_api_one_eid_table_dump_t *mp;
16656 vl_api_control_ping_t *mp_ping;
16657 struct in_addr ip4;
16658 struct in6_addr ip6;
16660 u8 eid_type = ~0, eid_set = 0;
16661 u32 prefix_length = ~0, t, vni = 0;
16664 lisp_nsh_api_t nsh;
16666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16668 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16674 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16680 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16685 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16690 else if (unformat (i, "vni %d", &t))
16694 else if (unformat (i, "local"))
16698 else if (unformat (i, "remote"))
16704 errmsg ("parse error '%U'", format_unformat_error, i);
16709 if (!vam->json_output)
16711 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16712 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16715 M (ONE_EID_TABLE_DUMP, mp);
16717 mp->filter = filter;
16721 mp->vni = htonl (vni);
16722 mp->eid_type = eid_type;
16726 mp->prefix_length = prefix_length;
16727 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16730 mp->prefix_length = prefix_length;
16731 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16734 clib_memcpy (mp->eid, mac, sizeof (mac));
16737 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16740 errmsg ("unknown EID type %d!", eid_type);
16748 /* Use a control ping for synchronization */
16749 MPING (CONTROL_PING, mp_ping);
16752 /* Wait for a reply... */
16757 #define api_lisp_eid_table_dump api_one_eid_table_dump
16760 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16762 unformat_input_t *i = vam->input;
16763 vl_api_gpe_fwd_entries_get_t *mp;
16768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16770 if (unformat (i, "vni %d", &vni))
16776 errmsg ("parse error '%U'", format_unformat_error, i);
16783 errmsg ("vni not set!");
16787 if (!vam->json_output)
16789 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16793 M (GPE_FWD_ENTRIES_GET, mp);
16794 mp->vni = clib_host_to_net_u32 (vni);
16799 /* Wait for a reply... */
16804 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16805 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16806 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16807 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16808 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16809 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16810 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16811 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16814 api_one_adjacencies_get (vat_main_t * vam)
16816 unformat_input_t *i = vam->input;
16817 vl_api_one_adjacencies_get_t *mp;
16822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16824 if (unformat (i, "vni %d", &vni))
16830 errmsg ("parse error '%U'", format_unformat_error, i);
16837 errmsg ("vni not set!");
16841 if (!vam->json_output)
16843 print (vam->ofp, "%s %40s", "leid", "reid");
16846 M (ONE_ADJACENCIES_GET, mp);
16847 mp->vni = clib_host_to_net_u32 (vni);
16852 /* Wait for a reply... */
16857 #define api_lisp_adjacencies_get api_one_adjacencies_get
16860 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16862 unformat_input_t *i = vam->input;
16863 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16865 u8 ip_family_set = 0, is_ip4 = 1;
16867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16869 if (unformat (i, "ip4"))
16874 else if (unformat (i, "ip6"))
16881 errmsg ("parse error '%U'", format_unformat_error, i);
16886 if (!ip_family_set)
16888 errmsg ("ip family not set!");
16892 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16893 mp->is_ip4 = is_ip4;
16898 /* Wait for a reply... */
16904 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16906 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16909 if (!vam->json_output)
16911 print (vam->ofp, "VNIs");
16914 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16919 /* Wait for a reply... */
16925 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16927 unformat_input_t *i = vam->input;
16928 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16930 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16931 struct in_addr ip4;
16932 struct in6_addr ip6;
16933 u32 table_id = 0, nh_sw_if_index = ~0;
16935 clib_memset (&ip4, 0, sizeof (ip4));
16936 clib_memset (&ip6, 0, sizeof (ip6));
16938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16940 if (unformat (i, "del"))
16942 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16943 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16948 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16949 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16954 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16958 nh_sw_if_index = ~0;
16960 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16964 nh_sw_if_index = ~0;
16966 else if (unformat (i, "table %d", &table_id))
16970 errmsg ("parse error '%U'", format_unformat_error, i);
16977 errmsg ("nh addr not set!");
16981 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16982 mp->is_add = is_add;
16983 mp->table_id = clib_host_to_net_u32 (table_id);
16984 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16985 mp->is_ip4 = is_ip4;
16987 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16989 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16994 /* Wait for a reply... */
17000 api_one_map_server_dump (vat_main_t * vam)
17002 vl_api_one_map_server_dump_t *mp;
17003 vl_api_control_ping_t *mp_ping;
17006 if (!vam->json_output)
17008 print (vam->ofp, "%=20s", "Map server");
17011 M (ONE_MAP_SERVER_DUMP, mp);
17015 /* Use a control ping for synchronization */
17016 MPING (CONTROL_PING, mp_ping);
17019 /* Wait for a reply... */
17024 #define api_lisp_map_server_dump api_one_map_server_dump
17027 api_one_map_resolver_dump (vat_main_t * vam)
17029 vl_api_one_map_resolver_dump_t *mp;
17030 vl_api_control_ping_t *mp_ping;
17033 if (!vam->json_output)
17035 print (vam->ofp, "%=20s", "Map resolver");
17038 M (ONE_MAP_RESOLVER_DUMP, mp);
17042 /* Use a control ping for synchronization */
17043 MPING (CONTROL_PING, mp_ping);
17046 /* Wait for a reply... */
17051 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17054 api_one_stats_flush (vat_main_t * vam)
17056 vl_api_one_stats_flush_t *mp;
17059 M (ONE_STATS_FLUSH, mp);
17066 api_one_stats_dump (vat_main_t * vam)
17068 vl_api_one_stats_dump_t *mp;
17069 vl_api_control_ping_t *mp_ping;
17072 M (ONE_STATS_DUMP, mp);
17076 /* Use a control ping for synchronization */
17077 MPING (CONTROL_PING, mp_ping);
17080 /* Wait for a reply... */
17086 api_show_one_status (vat_main_t * vam)
17088 vl_api_show_one_status_t *mp;
17091 if (!vam->json_output)
17093 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17096 M (SHOW_ONE_STATUS, mp);
17099 /* Wait for a reply... */
17104 #define api_show_lisp_status api_show_one_status
17107 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17109 vl_api_gpe_fwd_entry_path_dump_t *mp;
17110 vl_api_control_ping_t *mp_ping;
17111 unformat_input_t *i = vam->input;
17112 u32 fwd_entry_index = ~0;
17115 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17117 if (unformat (i, "index %d", &fwd_entry_index))
17123 if (~0 == fwd_entry_index)
17125 errmsg ("no index specified!");
17129 if (!vam->json_output)
17131 print (vam->ofp, "first line");
17134 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17138 /* Use a control ping for synchronization */
17139 MPING (CONTROL_PING, mp_ping);
17142 /* Wait for a reply... */
17148 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17150 vl_api_one_get_map_request_itr_rlocs_t *mp;
17153 if (!vam->json_output)
17155 print (vam->ofp, "%=20s", "itr-rlocs:");
17158 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17161 /* Wait for a reply... */
17166 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17169 api_af_packet_create (vat_main_t * vam)
17171 unformat_input_t *i = vam->input;
17172 vl_api_af_packet_create_t *mp;
17173 u8 *host_if_name = 0;
17175 u8 random_hw_addr = 1;
17178 clib_memset (hw_addr, 0, sizeof (hw_addr));
17180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17182 if (unformat (i, "name %s", &host_if_name))
17183 vec_add1 (host_if_name, 0);
17184 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17185 random_hw_addr = 0;
17190 if (!vec_len (host_if_name))
17192 errmsg ("host-interface name must be specified");
17196 if (vec_len (host_if_name) > 64)
17198 errmsg ("host-interface name too long");
17202 M (AF_PACKET_CREATE, mp);
17204 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17205 clib_memcpy (mp->hw_addr, hw_addr, 6);
17206 mp->use_random_hw_addr = random_hw_addr;
17207 vec_free (host_if_name);
17215 fprintf (vam->ofp ? vam->ofp : stderr,
17216 " new sw_if_index = %d\n", vam->sw_if_index);
17223 api_af_packet_delete (vat_main_t * vam)
17225 unformat_input_t *i = vam->input;
17226 vl_api_af_packet_delete_t *mp;
17227 u8 *host_if_name = 0;
17230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17232 if (unformat (i, "name %s", &host_if_name))
17233 vec_add1 (host_if_name, 0);
17238 if (!vec_len (host_if_name))
17240 errmsg ("host-interface name must be specified");
17244 if (vec_len (host_if_name) > 64)
17246 errmsg ("host-interface name too long");
17250 M (AF_PACKET_DELETE, mp);
17252 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17253 vec_free (host_if_name);
17260 static void vl_api_af_packet_details_t_handler
17261 (vl_api_af_packet_details_t * mp)
17263 vat_main_t *vam = &vat_main;
17265 print (vam->ofp, "%-16s %d",
17266 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17269 static void vl_api_af_packet_details_t_handler_json
17270 (vl_api_af_packet_details_t * mp)
17272 vat_main_t *vam = &vat_main;
17273 vat_json_node_t *node = NULL;
17275 if (VAT_JSON_ARRAY != vam->json_tree.type)
17277 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17278 vat_json_init_array (&vam->json_tree);
17280 node = vat_json_array_add (&vam->json_tree);
17282 vat_json_init_object (node);
17283 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17284 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17288 api_af_packet_dump (vat_main_t * vam)
17290 vl_api_af_packet_dump_t *mp;
17291 vl_api_control_ping_t *mp_ping;
17294 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17295 /* Get list of tap interfaces */
17296 M (AF_PACKET_DUMP, mp);
17299 /* Use a control ping for synchronization */
17300 MPING (CONTROL_PING, mp_ping);
17308 api_policer_add_del (vat_main_t * vam)
17310 unformat_input_t *i = vam->input;
17311 vl_api_policer_add_del_t *mp;
17321 u8 color_aware = 0;
17322 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17325 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17326 conform_action.dscp = 0;
17327 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17328 exceed_action.dscp = 0;
17329 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17330 violate_action.dscp = 0;
17332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17334 if (unformat (i, "del"))
17336 else if (unformat (i, "name %s", &name))
17337 vec_add1 (name, 0);
17338 else if (unformat (i, "cir %u", &cir))
17340 else if (unformat (i, "eir %u", &eir))
17342 else if (unformat (i, "cb %u", &cb))
17344 else if (unformat (i, "eb %u", &eb))
17346 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17349 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17352 else if (unformat (i, "type %U", unformat_policer_type, &type))
17354 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17357 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17360 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17363 else if (unformat (i, "color-aware"))
17369 if (!vec_len (name))
17371 errmsg ("policer name must be specified");
17375 if (vec_len (name) > 64)
17377 errmsg ("policer name too long");
17381 M (POLICER_ADD_DEL, mp);
17383 clib_memcpy (mp->name, name, vec_len (name));
17385 mp->is_add = is_add;
17386 mp->cir = ntohl (cir);
17387 mp->eir = ntohl (eir);
17388 mp->cb = clib_net_to_host_u64 (cb);
17389 mp->eb = clib_net_to_host_u64 (eb);
17390 mp->rate_type = rate_type;
17391 mp->round_type = round_type;
17393 mp->conform_action_type = conform_action.action_type;
17394 mp->conform_dscp = conform_action.dscp;
17395 mp->exceed_action_type = exceed_action.action_type;
17396 mp->exceed_dscp = exceed_action.dscp;
17397 mp->violate_action_type = violate_action.action_type;
17398 mp->violate_dscp = violate_action.dscp;
17399 mp->color_aware = color_aware;
17407 api_policer_dump (vat_main_t * vam)
17409 unformat_input_t *i = vam->input;
17410 vl_api_policer_dump_t *mp;
17411 vl_api_control_ping_t *mp_ping;
17412 u8 *match_name = 0;
17413 u8 match_name_valid = 0;
17416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17418 if (unformat (i, "name %s", &match_name))
17420 vec_add1 (match_name, 0);
17421 match_name_valid = 1;
17427 M (POLICER_DUMP, mp);
17428 mp->match_name_valid = match_name_valid;
17429 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17430 vec_free (match_name);
17434 /* Use a control ping for synchronization */
17435 MPING (CONTROL_PING, mp_ping);
17438 /* Wait for a reply... */
17444 api_policer_classify_set_interface (vat_main_t * vam)
17446 unformat_input_t *i = vam->input;
17447 vl_api_policer_classify_set_interface_t *mp;
17449 int sw_if_index_set;
17450 u32 ip4_table_index = ~0;
17451 u32 ip6_table_index = ~0;
17452 u32 l2_table_index = ~0;
17456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17458 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17459 sw_if_index_set = 1;
17460 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17461 sw_if_index_set = 1;
17462 else if (unformat (i, "del"))
17464 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17466 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17468 else if (unformat (i, "l2-table %d", &l2_table_index))
17472 clib_warning ("parse error '%U'", format_unformat_error, i);
17477 if (sw_if_index_set == 0)
17479 errmsg ("missing interface name or sw_if_index");
17483 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17485 mp->sw_if_index = ntohl (sw_if_index);
17486 mp->ip4_table_index = ntohl (ip4_table_index);
17487 mp->ip6_table_index = ntohl (ip6_table_index);
17488 mp->l2_table_index = ntohl (l2_table_index);
17489 mp->is_add = is_add;
17497 api_policer_classify_dump (vat_main_t * vam)
17499 unformat_input_t *i = vam->input;
17500 vl_api_policer_classify_dump_t *mp;
17501 vl_api_control_ping_t *mp_ping;
17502 u8 type = POLICER_CLASSIFY_N_TABLES;
17505 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17509 errmsg ("classify table type must be specified");
17513 if (!vam->json_output)
17515 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17518 M (POLICER_CLASSIFY_DUMP, mp);
17523 /* Use a control ping for synchronization */
17524 MPING (CONTROL_PING, mp_ping);
17527 /* Wait for a reply... */
17533 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17535 vl_api_fib_path_nh_proto_t proto =
17536 va_arg (*args, vl_api_fib_path_nh_proto_t);
17540 case FIB_API_PATH_NH_PROTO_IP4:
17541 s = format (s, "ip4");
17543 case FIB_API_PATH_NH_PROTO_IP6:
17544 s = format (s, "ip6");
17546 case FIB_API_PATH_NH_PROTO_MPLS:
17547 s = format (s, "mpls");
17549 case FIB_API_PATH_NH_PROTO_BIER:
17550 s = format (s, "bier");
17552 case FIB_API_PATH_NH_PROTO_ETHERNET:
17553 s = format (s, "ethernet");
17561 format_vl_api_ip_address_union (u8 * s, va_list * args)
17563 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
17564 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17569 s = format (s, "%U", format_ip4_address, u->ip4);
17572 s = format (s, "%U", format_ip6_address, u->ip6);
17579 format_vl_api_fib_path_type (u8 * s, va_list * args)
17581 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17585 case FIB_API_PATH_TYPE_NORMAL:
17586 s = format (s, "normal");
17588 case FIB_API_PATH_TYPE_LOCAL:
17589 s = format (s, "local");
17591 case FIB_API_PATH_TYPE_DROP:
17592 s = format (s, "drop");
17594 case FIB_API_PATH_TYPE_UDP_ENCAP:
17595 s = format (s, "udp-encap");
17597 case FIB_API_PATH_TYPE_BIER_IMP:
17598 s = format (s, "bier-imp");
17600 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17601 s = format (s, "unreach");
17603 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17604 s = format (s, "prohibit");
17606 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17607 s = format (s, "src-lookup");
17609 case FIB_API_PATH_TYPE_DVR:
17610 s = format (s, "dvr");
17612 case FIB_API_PATH_TYPE_INTERFACE_RX:
17613 s = format (s, "interface-rx");
17615 case FIB_API_PATH_TYPE_CLASSIFY:
17616 s = format (s, "classify");
17624 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17627 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17628 ntohl (fp->weight), ntohl (fp->sw_if_index),
17629 format_vl_api_fib_path_type, fp->type,
17630 format_fib_api_path_nh_proto, fp->proto,
17631 format_vl_api_ip_address_union, &fp->nh.address);
17635 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17636 vl_api_fib_path_t * fp)
17638 struct in_addr ip4;
17639 struct in6_addr ip6;
17641 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17642 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17643 vat_json_object_add_uint (node, "type", fp->type);
17644 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17645 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17647 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17648 vat_json_object_add_ip4 (node, "next_hop", ip4);
17650 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17652 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17653 vat_json_object_add_ip6 (node, "next_hop", ip6);
17658 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17660 vat_main_t *vam = &vat_main;
17661 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17662 vl_api_fib_path_t *fp;
17665 print (vam->ofp, "sw_if_index %d via:",
17666 ntohl (mp->mt_tunnel.mt_sw_if_index));
17667 fp = mp->mt_tunnel.mt_paths;
17668 for (i = 0; i < count; i++)
17670 vl_api_fib_path_print (vam, fp);
17674 print (vam->ofp, "");
17677 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17678 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17681 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17683 vat_main_t *vam = &vat_main;
17684 vat_json_node_t *node = NULL;
17685 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17686 vl_api_fib_path_t *fp;
17689 if (VAT_JSON_ARRAY != vam->json_tree.type)
17691 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17692 vat_json_init_array (&vam->json_tree);
17694 node = vat_json_array_add (&vam->json_tree);
17696 vat_json_init_object (node);
17697 vat_json_object_add_uint (node, "sw_if_index",
17698 ntohl (mp->mt_tunnel.mt_sw_if_index));
17700 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17702 fp = mp->mt_tunnel.mt_paths;
17703 for (i = 0; i < count; i++)
17705 vl_api_mpls_fib_path_json_print (node, fp);
17711 api_mpls_tunnel_dump (vat_main_t * vam)
17713 vl_api_mpls_tunnel_dump_t *mp;
17714 vl_api_control_ping_t *mp_ping;
17717 M (MPLS_TUNNEL_DUMP, mp);
17721 /* Use a control ping for synchronization */
17722 MPING (CONTROL_PING, mp_ping);
17729 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17730 #define vl_api_mpls_table_details_t_print vl_noop_handler
17734 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17736 vat_main_t *vam = &vat_main;
17738 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17741 static void vl_api_mpls_table_details_t_handler_json
17742 (vl_api_mpls_table_details_t * mp)
17744 vat_main_t *vam = &vat_main;
17745 vat_json_node_t *node = NULL;
17747 if (VAT_JSON_ARRAY != vam->json_tree.type)
17749 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17750 vat_json_init_array (&vam->json_tree);
17752 node = vat_json_array_add (&vam->json_tree);
17754 vat_json_init_object (node);
17755 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17759 api_mpls_table_dump (vat_main_t * vam)
17761 vl_api_mpls_table_dump_t *mp;
17762 vl_api_control_ping_t *mp_ping;
17765 M (MPLS_TABLE_DUMP, mp);
17768 /* Use a control ping for synchronization */
17769 MPING (CONTROL_PING, mp_ping);
17776 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17777 #define vl_api_mpls_route_details_t_print vl_noop_handler
17780 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17782 vat_main_t *vam = &vat_main;
17783 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17784 vl_api_fib_path_t *fp;
17788 "table-id %d, label %u, ess_bit %u",
17789 ntohl (mp->mr_route.mr_table_id),
17790 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17791 fp = mp->mr_route.mr_paths;
17792 for (i = 0; i < count; i++)
17794 vl_api_fib_path_print (vam, fp);
17799 static void vl_api_mpls_route_details_t_handler_json
17800 (vl_api_mpls_route_details_t * mp)
17802 vat_main_t *vam = &vat_main;
17803 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17804 vat_json_node_t *node = NULL;
17805 vl_api_fib_path_t *fp;
17808 if (VAT_JSON_ARRAY != vam->json_tree.type)
17810 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17811 vat_json_init_array (&vam->json_tree);
17813 node = vat_json_array_add (&vam->json_tree);
17815 vat_json_init_object (node);
17816 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17817 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17818 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17819 vat_json_object_add_uint (node, "path_count", count);
17820 fp = mp->mr_route.mr_paths;
17821 for (i = 0; i < count; i++)
17823 vl_api_mpls_fib_path_json_print (node, fp);
17829 api_mpls_route_dump (vat_main_t * vam)
17831 unformat_input_t *input = vam->input;
17832 vl_api_mpls_route_dump_t *mp;
17833 vl_api_control_ping_t *mp_ping;
17837 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17839 if (unformat (input, "table_id %d", &table_id))
17844 if (table_id == ~0)
17846 errmsg ("missing table id");
17850 M (MPLS_ROUTE_DUMP, mp);
17852 mp->table.mt_table_id = ntohl (table_id);
17855 /* Use a control ping for synchronization */
17856 MPING (CONTROL_PING, mp_ping);
17863 #define vl_api_ip_table_details_t_endian vl_noop_handler
17864 #define vl_api_ip_table_details_t_print vl_noop_handler
17867 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17869 vat_main_t *vam = &vat_main;
17872 "%s; table-id %d, prefix %U/%d",
17873 mp->table.name, ntohl (mp->table.table_id));
17877 static void vl_api_ip_table_details_t_handler_json
17878 (vl_api_ip_table_details_t * mp)
17880 vat_main_t *vam = &vat_main;
17881 vat_json_node_t *node = NULL;
17883 if (VAT_JSON_ARRAY != vam->json_tree.type)
17885 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17886 vat_json_init_array (&vam->json_tree);
17888 node = vat_json_array_add (&vam->json_tree);
17890 vat_json_init_object (node);
17891 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17895 api_ip_table_dump (vat_main_t * vam)
17897 vl_api_ip_table_dump_t *mp;
17898 vl_api_control_ping_t *mp_ping;
17901 M (IP_TABLE_DUMP, mp);
17904 /* Use a control ping for synchronization */
17905 MPING (CONTROL_PING, mp_ping);
17913 api_ip_mtable_dump (vat_main_t * vam)
17915 vl_api_ip_mtable_dump_t *mp;
17916 vl_api_control_ping_t *mp_ping;
17919 M (IP_MTABLE_DUMP, mp);
17922 /* Use a control ping for synchronization */
17923 MPING (CONTROL_PING, mp_ping);
17931 api_ip_mroute_dump (vat_main_t * vam)
17933 unformat_input_t *input = vam->input;
17934 vl_api_control_ping_t *mp_ping;
17935 vl_api_ip_mroute_dump_t *mp;
17940 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17942 if (unformat (input, "table_id %d", &table_id))
17944 else if (unformat (input, "ip6"))
17946 else if (unformat (input, "ip4"))
17951 if (table_id == ~0)
17953 errmsg ("missing table id");
17957 M (IP_MROUTE_DUMP, mp);
17958 mp->table.table_id = table_id;
17959 mp->table.is_ip6 = is_ip6;
17962 /* Use a control ping for synchronization */
17963 MPING (CONTROL_PING, mp_ping);
17970 #define vl_api_ip_route_details_t_endian vl_noop_handler
17971 #define vl_api_ip_route_details_t_print vl_noop_handler
17974 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17976 vat_main_t *vam = &vat_main;
17977 u8 count = mp->route.n_paths;
17978 vl_api_fib_path_t *fp;
17982 "table-id %d, prefix %U/%d",
17983 ntohl (mp->route.table_id),
17984 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17985 for (i = 0; i < count; i++)
17987 fp = &mp->route.paths[i];
17989 vl_api_fib_path_print (vam, fp);
17994 static void vl_api_ip_route_details_t_handler_json
17995 (vl_api_ip_route_details_t * mp)
17997 vat_main_t *vam = &vat_main;
17998 u8 count = mp->route.n_paths;
17999 vat_json_node_t *node = NULL;
18000 struct in_addr ip4;
18001 struct in6_addr ip6;
18002 vl_api_fib_path_t *fp;
18005 if (VAT_JSON_ARRAY != vam->json_tree.type)
18007 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18008 vat_json_init_array (&vam->json_tree);
18010 node = vat_json_array_add (&vam->json_tree);
18012 vat_json_init_object (node);
18013 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18014 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18016 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18017 vat_json_object_add_ip6 (node, "prefix", ip6);
18021 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18022 vat_json_object_add_ip4 (node, "prefix", ip4);
18024 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18025 vat_json_object_add_uint (node, "path_count", count);
18026 for (i = 0; i < count; i++)
18028 fp = &mp->route.paths[i];
18029 vl_api_mpls_fib_path_json_print (node, fp);
18034 api_ip_route_dump (vat_main_t * vam)
18036 unformat_input_t *input = vam->input;
18037 vl_api_ip_route_dump_t *mp;
18038 vl_api_control_ping_t *mp_ping;
18044 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18046 if (unformat (input, "table_id %d", &table_id))
18048 else if (unformat (input, "ip6"))
18050 else if (unformat (input, "ip4"))
18055 if (table_id == ~0)
18057 errmsg ("missing table id");
18061 M (IP_ROUTE_DUMP, mp);
18063 mp->table.table_id = table_id;
18064 mp->table.is_ip6 = is_ip6;
18068 /* Use a control ping for synchronization */
18069 MPING (CONTROL_PING, mp_ping);
18077 api_classify_table_ids (vat_main_t * vam)
18079 vl_api_classify_table_ids_t *mp;
18082 /* Construct the API message */
18083 M (CLASSIFY_TABLE_IDS, mp);
18092 api_classify_table_by_interface (vat_main_t * vam)
18094 unformat_input_t *input = vam->input;
18095 vl_api_classify_table_by_interface_t *mp;
18097 u32 sw_if_index = ~0;
18099 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18101 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18103 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18108 if (sw_if_index == ~0)
18110 errmsg ("missing interface name or sw_if_index");
18114 /* Construct the API message */
18115 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18117 mp->sw_if_index = ntohl (sw_if_index);
18125 api_classify_table_info (vat_main_t * vam)
18127 unformat_input_t *input = vam->input;
18128 vl_api_classify_table_info_t *mp;
18132 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18134 if (unformat (input, "table_id %d", &table_id))
18139 if (table_id == ~0)
18141 errmsg ("missing table id");
18145 /* Construct the API message */
18146 M (CLASSIFY_TABLE_INFO, mp);
18148 mp->table_id = ntohl (table_id);
18156 api_classify_session_dump (vat_main_t * vam)
18158 unformat_input_t *input = vam->input;
18159 vl_api_classify_session_dump_t *mp;
18160 vl_api_control_ping_t *mp_ping;
18164 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18166 if (unformat (input, "table_id %d", &table_id))
18171 if (table_id == ~0)
18173 errmsg ("missing table id");
18177 /* Construct the API message */
18178 M (CLASSIFY_SESSION_DUMP, mp);
18180 mp->table_id = ntohl (table_id);
18183 /* Use a control ping for synchronization */
18184 MPING (CONTROL_PING, mp_ping);
18192 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18194 vat_main_t *vam = &vat_main;
18196 print (vam->ofp, "collector_address %U, collector_port %d, "
18197 "src_address %U, vrf_id %d, path_mtu %u, "
18198 "template_interval %u, udp_checksum %d",
18199 format_ip4_address, mp->collector_address,
18200 ntohs (mp->collector_port),
18201 format_ip4_address, mp->src_address,
18202 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18203 ntohl (mp->template_interval), mp->udp_checksum);
18206 vam->result_ready = 1;
18210 vl_api_ipfix_exporter_details_t_handler_json
18211 (vl_api_ipfix_exporter_details_t * mp)
18213 vat_main_t *vam = &vat_main;
18214 vat_json_node_t node;
18215 struct in_addr collector_address;
18216 struct in_addr src_address;
18218 vat_json_init_object (&node);
18219 clib_memcpy (&collector_address, &mp->collector_address,
18220 sizeof (collector_address));
18221 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18222 vat_json_object_add_uint (&node, "collector_port",
18223 ntohs (mp->collector_port));
18224 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18225 vat_json_object_add_ip4 (&node, "src_address", src_address);
18226 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18227 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18228 vat_json_object_add_uint (&node, "template_interval",
18229 ntohl (mp->template_interval));
18230 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18232 vat_json_print (vam->ofp, &node);
18233 vat_json_free (&node);
18235 vam->result_ready = 1;
18239 api_ipfix_exporter_dump (vat_main_t * vam)
18241 vl_api_ipfix_exporter_dump_t *mp;
18244 /* Construct the API message */
18245 M (IPFIX_EXPORTER_DUMP, mp);
18254 api_ipfix_classify_stream_dump (vat_main_t * vam)
18256 vl_api_ipfix_classify_stream_dump_t *mp;
18259 /* Construct the API message */
18260 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18271 vl_api_ipfix_classify_stream_details_t_handler
18272 (vl_api_ipfix_classify_stream_details_t * mp)
18274 vat_main_t *vam = &vat_main;
18275 print (vam->ofp, "domain_id %d, src_port %d",
18276 ntohl (mp->domain_id), ntohs (mp->src_port));
18278 vam->result_ready = 1;
18282 vl_api_ipfix_classify_stream_details_t_handler_json
18283 (vl_api_ipfix_classify_stream_details_t * mp)
18285 vat_main_t *vam = &vat_main;
18286 vat_json_node_t node;
18288 vat_json_init_object (&node);
18289 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18290 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18292 vat_json_print (vam->ofp, &node);
18293 vat_json_free (&node);
18295 vam->result_ready = 1;
18299 api_ipfix_classify_table_dump (vat_main_t * vam)
18301 vl_api_ipfix_classify_table_dump_t *mp;
18302 vl_api_control_ping_t *mp_ping;
18305 if (!vam->json_output)
18307 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18308 "transport_protocol");
18311 /* Construct the API message */
18312 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18317 /* Use a control ping for synchronization */
18318 MPING (CONTROL_PING, mp_ping);
18326 vl_api_ipfix_classify_table_details_t_handler
18327 (vl_api_ipfix_classify_table_details_t * mp)
18329 vat_main_t *vam = &vat_main;
18330 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18331 mp->transport_protocol);
18335 vl_api_ipfix_classify_table_details_t_handler_json
18336 (vl_api_ipfix_classify_table_details_t * mp)
18338 vat_json_node_t *node = NULL;
18339 vat_main_t *vam = &vat_main;
18341 if (VAT_JSON_ARRAY != vam->json_tree.type)
18343 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18344 vat_json_init_array (&vam->json_tree);
18347 node = vat_json_array_add (&vam->json_tree);
18348 vat_json_init_object (node);
18350 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18351 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18352 vat_json_object_add_uint (node, "transport_protocol",
18353 mp->transport_protocol);
18357 api_sw_interface_span_enable_disable (vat_main_t * vam)
18359 unformat_input_t *i = vam->input;
18360 vl_api_sw_interface_span_enable_disable_t *mp;
18361 u32 src_sw_if_index = ~0;
18362 u32 dst_sw_if_index = ~0;
18367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18370 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18372 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18376 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18378 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18380 else if (unformat (i, "disable"))
18382 else if (unformat (i, "rx"))
18384 else if (unformat (i, "tx"))
18386 else if (unformat (i, "both"))
18388 else if (unformat (i, "l2"))
18394 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18396 mp->sw_if_index_from = htonl (src_sw_if_index);
18397 mp->sw_if_index_to = htonl (dst_sw_if_index);
18407 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18410 vat_main_t *vam = &vat_main;
18411 u8 *sw_if_from_name = 0;
18412 u8 *sw_if_to_name = 0;
18413 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18414 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18415 char *states[] = { "none", "rx", "tx", "both" };
18419 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18421 if ((u32) p->value[0] == sw_if_index_from)
18423 sw_if_from_name = (u8 *)(p->key);
18427 if ((u32) p->value[0] == sw_if_index_to)
18429 sw_if_to_name = (u8 *)(p->key);
18430 if (sw_if_from_name)
18435 print (vam->ofp, "%20s => %20s (%s) %s",
18436 sw_if_from_name, sw_if_to_name, states[mp->state],
18437 mp->is_l2 ? "l2" : "device");
18441 vl_api_sw_interface_span_details_t_handler_json
18442 (vl_api_sw_interface_span_details_t * mp)
18444 vat_main_t *vam = &vat_main;
18445 vat_json_node_t *node = NULL;
18446 u8 *sw_if_from_name = 0;
18447 u8 *sw_if_to_name = 0;
18448 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18449 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18453 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18455 if ((u32) p->value[0] == sw_if_index_from)
18457 sw_if_from_name = (u8 *)(p->key);
18461 if ((u32) p->value[0] == sw_if_index_to)
18463 sw_if_to_name = (u8 *)(p->key);
18464 if (sw_if_from_name)
18470 if (VAT_JSON_ARRAY != vam->json_tree.type)
18472 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18473 vat_json_init_array (&vam->json_tree);
18475 node = vat_json_array_add (&vam->json_tree);
18477 vat_json_init_object (node);
18478 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18479 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18480 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18481 if (0 != sw_if_to_name)
18483 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18485 vat_json_object_add_uint (node, "state", mp->state);
18486 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18490 api_sw_interface_span_dump (vat_main_t * vam)
18492 unformat_input_t *input = vam->input;
18493 vl_api_sw_interface_span_dump_t *mp;
18494 vl_api_control_ping_t *mp_ping;
18498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18500 if (unformat (input, "l2"))
18506 M (SW_INTERFACE_SPAN_DUMP, mp);
18510 /* Use a control ping for synchronization */
18511 MPING (CONTROL_PING, mp_ping);
18519 api_pg_create_interface (vat_main_t * vam)
18521 unformat_input_t *input = vam->input;
18522 vl_api_pg_create_interface_t *mp;
18524 u32 if_id = ~0, gso_size = 0;
18525 u8 gso_enabled = 0;
18527 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18529 if (unformat (input, "if_id %d", &if_id))
18531 else if (unformat (input, "gso-enabled"))
18534 if (unformat (input, "gso-size %u", &gso_size))
18538 errmsg ("missing gso-size");
18547 errmsg ("missing pg interface index");
18551 /* Construct the API message */
18552 M (PG_CREATE_INTERFACE, mp);
18554 mp->interface_id = ntohl (if_id);
18555 mp->gso_enabled = gso_enabled;
18563 api_pg_capture (vat_main_t * vam)
18565 unformat_input_t *input = vam->input;
18566 vl_api_pg_capture_t *mp;
18571 u8 pcap_file_set = 0;
18574 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18576 if (unformat (input, "if_id %d", &if_id))
18578 else if (unformat (input, "pcap %s", &pcap_file))
18580 else if (unformat (input, "count %d", &count))
18582 else if (unformat (input, "disable"))
18589 errmsg ("missing pg interface index");
18592 if (pcap_file_set > 0)
18594 if (vec_len (pcap_file) > 255)
18596 errmsg ("pcap file name is too long");
18601 u32 name_len = vec_len (pcap_file);
18602 /* Construct the API message */
18603 M (PG_CAPTURE, mp);
18605 mp->interface_id = ntohl (if_id);
18606 mp->is_enabled = enable;
18607 mp->count = ntohl (count);
18608 mp->pcap_name_length = ntohl (name_len);
18609 if (pcap_file_set != 0)
18611 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18613 vec_free (pcap_file);
18621 api_pg_enable_disable (vat_main_t * vam)
18623 unformat_input_t *input = vam->input;
18624 vl_api_pg_enable_disable_t *mp;
18627 u8 stream_name_set = 0;
18628 u8 *stream_name = 0;
18630 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18632 if (unformat (input, "stream %s", &stream_name))
18633 stream_name_set = 1;
18634 else if (unformat (input, "disable"))
18640 if (stream_name_set > 0)
18642 if (vec_len (stream_name) > 255)
18644 errmsg ("stream name too long");
18649 u32 name_len = vec_len (stream_name);
18650 /* Construct the API message */
18651 M (PG_ENABLE_DISABLE, mp);
18653 mp->is_enabled = enable;
18654 if (stream_name_set != 0)
18656 mp->stream_name_length = ntohl (name_len);
18657 clib_memcpy (mp->stream_name, stream_name, name_len);
18659 vec_free (stream_name);
18667 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18669 unformat_input_t *input = vam->input;
18670 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18672 u16 *low_ports = 0;
18673 u16 *high_ports = 0;
18676 vl_api_prefix_t prefix;
18683 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18685 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18687 else if (unformat (input, "vrf %d", &vrf_id))
18689 else if (unformat (input, "del"))
18691 else if (unformat (input, "port %d", &tmp))
18693 if (tmp == 0 || tmp > 65535)
18695 errmsg ("port %d out of range", tmp);
18699 this_hi = this_low + 1;
18700 vec_add1 (low_ports, this_low);
18701 vec_add1 (high_ports, this_hi);
18703 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18705 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18707 errmsg ("incorrect range parameters");
18711 /* Note: in debug CLI +1 is added to high before
18712 passing to real fn that does "the work"
18713 (ip_source_and_port_range_check_add_del).
18714 This fn is a wrapper around the binary API fn a
18715 control plane will call, which expects this increment
18716 to have occurred. Hence letting the binary API control
18717 plane fn do the increment for consistency between VAT
18718 and other control planes.
18721 vec_add1 (low_ports, this_low);
18722 vec_add1 (high_ports, this_hi);
18728 if (prefix_set == 0)
18730 errmsg ("<address>/<mask> not specified");
18736 errmsg ("VRF ID required, not specified");
18743 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18747 if (vec_len (low_ports) == 0)
18749 errmsg ("At least one port or port range required");
18753 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18755 mp->is_add = is_add;
18757 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18759 mp->number_of_ranges = vec_len (low_ports);
18761 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18762 vec_free (low_ports);
18764 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18765 vec_free (high_ports);
18767 mp->vrf_id = ntohl (vrf_id);
18775 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18777 unformat_input_t *input = vam->input;
18778 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18779 u32 sw_if_index = ~0;
18781 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18782 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18786 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18788 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18790 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18792 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18794 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18796 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18798 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18800 else if (unformat (input, "del"))
18806 if (sw_if_index == ~0)
18808 errmsg ("Interface required but not specified");
18814 errmsg ("VRF ID required but not specified");
18818 if (tcp_out_vrf_id == 0
18819 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18822 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18826 /* Construct the API message */
18827 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18829 mp->sw_if_index = ntohl (sw_if_index);
18830 mp->is_add = is_add;
18831 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18832 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18833 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18834 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18839 /* Wait for a reply... */
18845 api_set_punt (vat_main_t * vam)
18847 unformat_input_t *i = vam->input;
18848 vl_api_address_family_t af;
18849 vl_api_set_punt_t *mp;
18855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18857 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18859 else if (unformat (i, "protocol %d", &protocol))
18861 else if (unformat (i, "port %d", &port))
18863 else if (unformat (i, "del"))
18867 clib_warning ("parse error '%U'", format_unformat_error, i);
18874 mp->is_add = (u8) is_add;
18875 mp->punt.type = PUNT_API_TYPE_L4;
18876 mp->punt.punt.l4.af = af;
18877 mp->punt.punt.l4.protocol = (u8) protocol;
18878 mp->punt.punt.l4.port = htons ((u16) port);
18886 api_delete_subif (vat_main_t * vam)
18888 unformat_input_t *i = vam->input;
18889 vl_api_delete_subif_t *mp;
18890 u32 sw_if_index = ~0;
18893 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18895 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18897 if (unformat (i, "sw_if_index %d", &sw_if_index))
18903 if (sw_if_index == ~0)
18905 errmsg ("missing sw_if_index");
18909 /* Construct the API message */
18910 M (DELETE_SUBIF, mp);
18911 mp->sw_if_index = ntohl (sw_if_index);
18918 #define foreach_pbb_vtr_op \
18919 _("disable", L2_VTR_DISABLED) \
18920 _("pop", L2_VTR_POP_2) \
18921 _("push", L2_VTR_PUSH_2)
18924 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18926 unformat_input_t *i = vam->input;
18927 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18928 u32 sw_if_index = ~0, vtr_op = ~0;
18929 u16 outer_tag = ~0;
18930 u8 dmac[6], smac[6];
18931 u8 dmac_set = 0, smac_set = 0;
18937 /* Shut up coverity */
18938 clib_memset (dmac, 0, sizeof (dmac));
18939 clib_memset (smac, 0, sizeof (smac));
18941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18945 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18947 else if (unformat (i, "vtr_op %d", &vtr_op))
18949 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18952 else if (unformat (i, "translate_pbb_stag"))
18954 if (unformat (i, "%d", &tmp))
18956 vtr_op = L2_VTR_TRANSLATE_2_1;
18962 ("translate_pbb_stag operation requires outer tag definition");
18966 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18968 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18970 else if (unformat (i, "sid %d", &sid))
18972 else if (unformat (i, "vlanid %d", &tmp))
18976 clib_warning ("parse error '%U'", format_unformat_error, i);
18981 if ((sw_if_index == ~0) || (vtr_op == ~0))
18983 errmsg ("missing sw_if_index or vtr operation");
18986 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18987 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18990 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18994 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18995 mp->sw_if_index = ntohl (sw_if_index);
18996 mp->vtr_op = ntohl (vtr_op);
18997 mp->outer_tag = ntohs (outer_tag);
18998 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
18999 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19000 mp->b_vlanid = ntohs (vlanid);
19001 mp->i_sid = ntohl (sid);
19009 api_flow_classify_set_interface (vat_main_t * vam)
19011 unformat_input_t *i = vam->input;
19012 vl_api_flow_classify_set_interface_t *mp;
19014 int sw_if_index_set;
19015 u32 ip4_table_index = ~0;
19016 u32 ip6_table_index = ~0;
19020 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19022 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19023 sw_if_index_set = 1;
19024 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19025 sw_if_index_set = 1;
19026 else if (unformat (i, "del"))
19028 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19030 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19034 clib_warning ("parse error '%U'", format_unformat_error, i);
19039 if (sw_if_index_set == 0)
19041 errmsg ("missing interface name or sw_if_index");
19045 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19047 mp->sw_if_index = ntohl (sw_if_index);
19048 mp->ip4_table_index = ntohl (ip4_table_index);
19049 mp->ip6_table_index = ntohl (ip6_table_index);
19050 mp->is_add = is_add;
19058 api_flow_classify_dump (vat_main_t * vam)
19060 unformat_input_t *i = vam->input;
19061 vl_api_flow_classify_dump_t *mp;
19062 vl_api_control_ping_t *mp_ping;
19063 u8 type = FLOW_CLASSIFY_N_TABLES;
19066 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19070 errmsg ("classify table type must be specified");
19074 if (!vam->json_output)
19076 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19079 M (FLOW_CLASSIFY_DUMP, mp);
19084 /* Use a control ping for synchronization */
19085 MPING (CONTROL_PING, mp_ping);
19088 /* Wait for a reply... */
19094 api_feature_enable_disable (vat_main_t * vam)
19096 unformat_input_t *i = vam->input;
19097 vl_api_feature_enable_disable_t *mp;
19099 u8 *feature_name = 0;
19100 u32 sw_if_index = ~0;
19104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19106 if (unformat (i, "arc_name %s", &arc_name))
19108 else if (unformat (i, "feature_name %s", &feature_name))
19111 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19113 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19115 else if (unformat (i, "disable"))
19123 errmsg ("missing arc name");
19126 if (vec_len (arc_name) > 63)
19128 errmsg ("arc name too long");
19131 if (feature_name == 0)
19133 errmsg ("missing feature name");
19136 if (vec_len (feature_name) > 63)
19138 errmsg ("feature name too long");
19141 if (sw_if_index == ~0)
19143 errmsg ("missing interface name or sw_if_index");
19147 /* Construct the API message */
19148 M (FEATURE_ENABLE_DISABLE, mp);
19149 mp->sw_if_index = ntohl (sw_if_index);
19150 mp->enable = enable;
19151 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19152 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19153 vec_free (arc_name);
19154 vec_free (feature_name);
19162 api_feature_gso_enable_disable (vat_main_t * vam)
19164 unformat_input_t *i = vam->input;
19165 vl_api_feature_gso_enable_disable_t *mp;
19166 u32 sw_if_index = ~0;
19170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19172 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19174 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19176 else if (unformat (i, "enable"))
19178 else if (unformat (i, "disable"))
19184 if (sw_if_index == ~0)
19186 errmsg ("missing interface name or sw_if_index");
19190 /* Construct the API message */
19191 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19192 mp->sw_if_index = ntohl (sw_if_index);
19193 mp->enable_disable = enable;
19201 api_sw_interface_tag_add_del (vat_main_t * vam)
19203 unformat_input_t *i = vam->input;
19204 vl_api_sw_interface_tag_add_del_t *mp;
19205 u32 sw_if_index = ~0;
19210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19212 if (unformat (i, "tag %s", &tag))
19214 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19216 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19218 else if (unformat (i, "del"))
19224 if (sw_if_index == ~0)
19226 errmsg ("missing interface name or sw_if_index");
19230 if (enable && (tag == 0))
19232 errmsg ("no tag specified");
19236 /* Construct the API message */
19237 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19238 mp->sw_if_index = ntohl (sw_if_index);
19239 mp->is_add = enable;
19241 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19250 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19252 unformat_input_t *i = vam->input;
19253 vl_api_mac_address_t mac = { 0 };
19254 vl_api_sw_interface_add_del_mac_address_t *mp;
19255 u32 sw_if_index = ~0;
19260 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19262 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19264 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19266 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19268 else if (unformat (i, "del"))
19274 if (sw_if_index == ~0)
19276 errmsg ("missing interface name or sw_if_index");
19282 errmsg ("missing MAC address");
19286 /* Construct the API message */
19287 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19288 mp->sw_if_index = ntohl (sw_if_index);
19289 mp->is_add = is_add;
19290 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19297 static void vl_api_l2_xconnect_details_t_handler
19298 (vl_api_l2_xconnect_details_t * mp)
19300 vat_main_t *vam = &vat_main;
19302 print (vam->ofp, "%15d%15d",
19303 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19306 static void vl_api_l2_xconnect_details_t_handler_json
19307 (vl_api_l2_xconnect_details_t * mp)
19309 vat_main_t *vam = &vat_main;
19310 vat_json_node_t *node = NULL;
19312 if (VAT_JSON_ARRAY != vam->json_tree.type)
19314 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19315 vat_json_init_array (&vam->json_tree);
19317 node = vat_json_array_add (&vam->json_tree);
19319 vat_json_init_object (node);
19320 vat_json_object_add_uint (node, "rx_sw_if_index",
19321 ntohl (mp->rx_sw_if_index));
19322 vat_json_object_add_uint (node, "tx_sw_if_index",
19323 ntohl (mp->tx_sw_if_index));
19327 api_l2_xconnect_dump (vat_main_t * vam)
19329 vl_api_l2_xconnect_dump_t *mp;
19330 vl_api_control_ping_t *mp_ping;
19333 if (!vam->json_output)
19335 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19338 M (L2_XCONNECT_DUMP, mp);
19342 /* Use a control ping for synchronization */
19343 MPING (CONTROL_PING, mp_ping);
19351 api_hw_interface_set_mtu (vat_main_t * vam)
19353 unformat_input_t *i = vam->input;
19354 vl_api_hw_interface_set_mtu_t *mp;
19355 u32 sw_if_index = ~0;
19359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19361 if (unformat (i, "mtu %d", &mtu))
19363 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19365 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19371 if (sw_if_index == ~0)
19373 errmsg ("missing interface name or sw_if_index");
19379 errmsg ("no mtu specified");
19383 /* Construct the API message */
19384 M (HW_INTERFACE_SET_MTU, mp);
19385 mp->sw_if_index = ntohl (sw_if_index);
19386 mp->mtu = ntohs ((u16) mtu);
19394 api_p2p_ethernet_add (vat_main_t * vam)
19396 unformat_input_t *i = vam->input;
19397 vl_api_p2p_ethernet_add_t *mp;
19398 u32 parent_if_index = ~0;
19404 clib_memset (remote_mac, 0, sizeof (remote_mac));
19405 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19407 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19409 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19413 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19415 else if (unformat (i, "sub_id %d", &sub_id))
19419 clib_warning ("parse error '%U'", format_unformat_error, i);
19424 if (parent_if_index == ~0)
19426 errmsg ("missing interface name or sw_if_index");
19431 errmsg ("missing remote mac address");
19436 errmsg ("missing sub-interface id");
19440 M (P2P_ETHERNET_ADD, mp);
19441 mp->parent_if_index = ntohl (parent_if_index);
19442 mp->subif_id = ntohl (sub_id);
19443 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19451 api_p2p_ethernet_del (vat_main_t * vam)
19453 unformat_input_t *i = vam->input;
19454 vl_api_p2p_ethernet_del_t *mp;
19455 u32 parent_if_index = ~0;
19460 clib_memset (remote_mac, 0, sizeof (remote_mac));
19461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19463 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19465 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19469 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19473 clib_warning ("parse error '%U'", format_unformat_error, i);
19478 if (parent_if_index == ~0)
19480 errmsg ("missing interface name or sw_if_index");
19485 errmsg ("missing remote mac address");
19489 M (P2P_ETHERNET_DEL, mp);
19490 mp->parent_if_index = ntohl (parent_if_index);
19491 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19499 api_lldp_config (vat_main_t * vam)
19501 unformat_input_t *i = vam->input;
19502 vl_api_lldp_config_t *mp;
19504 int tx_interval = 0;
19505 u8 *sys_name = NULL;
19508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19510 if (unformat (i, "system-name %s", &sys_name))
19512 else if (unformat (i, "tx-hold %d", &tx_hold))
19514 else if (unformat (i, "tx-interval %d", &tx_interval))
19518 clib_warning ("parse error '%U'", format_unformat_error, i);
19523 vec_add1 (sys_name, 0);
19525 M (LLDP_CONFIG, mp);
19526 mp->tx_hold = htonl (tx_hold);
19527 mp->tx_interval = htonl (tx_interval);
19528 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19529 vec_free (sys_name);
19537 api_sw_interface_set_lldp (vat_main_t * vam)
19539 unformat_input_t *i = vam->input;
19540 vl_api_sw_interface_set_lldp_t *mp;
19541 u32 sw_if_index = ~0;
19543 u8 *port_desc = NULL, *mgmt_oid = NULL;
19544 ip4_address_t ip4_addr;
19545 ip6_address_t ip6_addr;
19548 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19549 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19553 if (unformat (i, "disable"))
19556 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19558 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19560 else if (unformat (i, "port-desc %s", &port_desc))
19562 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19564 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19566 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19572 if (sw_if_index == ~0)
19574 errmsg ("missing interface name or sw_if_index");
19578 /* Construct the API message */
19579 vec_add1 (port_desc, 0);
19580 vec_add1 (mgmt_oid, 0);
19581 M (SW_INTERFACE_SET_LLDP, mp);
19582 mp->sw_if_index = ntohl (sw_if_index);
19583 mp->enable = enable;
19584 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19585 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19586 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19587 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19588 vec_free (port_desc);
19589 vec_free (mgmt_oid);
19597 api_tcp_configure_src_addresses (vat_main_t * vam)
19599 vl_api_tcp_configure_src_addresses_t *mp;
19600 unformat_input_t *i = vam->input;
19601 vl_api_address_t first, last;
19606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19608 if (unformat (i, "%U - %U",
19609 unformat_vl_api_address, &first,
19610 unformat_vl_api_address, &last))
19614 errmsg ("one range per message (range already set)");
19619 else if (unformat (i, "vrf %d", &vrf_id))
19625 if (range_set == 0)
19627 errmsg ("address range not set");
19631 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19633 mp->vrf_id = ntohl (vrf_id);
19634 clib_memcpy (&mp->first_address, &first, sizeof (first));
19635 clib_memcpy (&mp->last_address, &last, sizeof (last));
19642 static void vl_api_app_namespace_add_del_reply_t_handler
19643 (vl_api_app_namespace_add_del_reply_t * mp)
19645 vat_main_t *vam = &vat_main;
19646 i32 retval = ntohl (mp->retval);
19647 if (vam->async_mode)
19649 vam->async_errors += (retval < 0);
19653 vam->retval = retval;
19655 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19656 vam->result_ready = 1;
19660 static void vl_api_app_namespace_add_del_reply_t_handler_json
19661 (vl_api_app_namespace_add_del_reply_t * mp)
19663 vat_main_t *vam = &vat_main;
19664 vat_json_node_t node;
19666 vat_json_init_object (&node);
19667 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19668 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19670 vat_json_print (vam->ofp, &node);
19671 vat_json_free (&node);
19673 vam->retval = ntohl (mp->retval);
19674 vam->result_ready = 1;
19678 api_app_namespace_add_del (vat_main_t * vam)
19680 vl_api_app_namespace_add_del_t *mp;
19681 unformat_input_t *i = vam->input;
19682 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19683 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19689 if (unformat (i, "id %_%v%_", &ns_id))
19691 else if (unformat (i, "secret %lu", &secret))
19693 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19694 sw_if_index_set = 1;
19695 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19697 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19702 if (!ns_id || !secret_set || !sw_if_index_set)
19704 errmsg ("namespace id, secret and sw_if_index must be set");
19707 if (vec_len (ns_id) > 64)
19709 errmsg ("namespace id too long");
19712 M (APP_NAMESPACE_ADD_DEL, mp);
19714 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
19715 mp->namespace_id_len = vec_len (ns_id);
19716 mp->secret = clib_host_to_net_u64 (secret);
19717 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19718 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19719 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19727 api_sock_init_shm (vat_main_t * vam)
19729 #if VPP_API_TEST_BUILTIN == 0
19730 unformat_input_t *i = vam->input;
19731 vl_api_shm_elem_config_t *config = 0;
19732 u64 size = 64 << 20;
19735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19737 if (unformat (i, "size %U", unformat_memory_size, &size))
19744 * Canned custom ring allocator config.
19745 * Should probably parse all of this
19747 vec_validate (config, 6);
19748 config[0].type = VL_API_VLIB_RING;
19749 config[0].size = 256;
19750 config[0].count = 32;
19752 config[1].type = VL_API_VLIB_RING;
19753 config[1].size = 1024;
19754 config[1].count = 16;
19756 config[2].type = VL_API_VLIB_RING;
19757 config[2].size = 4096;
19758 config[2].count = 2;
19760 config[3].type = VL_API_CLIENT_RING;
19761 config[3].size = 256;
19762 config[3].count = 32;
19764 config[4].type = VL_API_CLIENT_RING;
19765 config[4].size = 1024;
19766 config[4].count = 16;
19768 config[5].type = VL_API_CLIENT_RING;
19769 config[5].size = 4096;
19770 config[5].count = 2;
19772 config[6].type = VL_API_QUEUE;
19773 config[6].count = 128;
19774 config[6].size = sizeof (uword);
19776 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19778 vam->client_index_invalid = 1;
19786 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19788 vat_main_t *vam = &vat_main;
19793 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19794 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19795 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
19796 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19797 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19798 clib_net_to_host_u32 (mp->action_index), mp->tag);
19803 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19804 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19805 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
19806 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19807 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19808 clib_net_to_host_u32 (mp->action_index), mp->tag);
19813 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19816 vat_main_t *vam = &vat_main;
19817 vat_json_node_t *node = NULL;
19818 struct in6_addr ip6;
19819 struct in_addr ip4;
19821 if (VAT_JSON_ARRAY != vam->json_tree.type)
19823 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19824 vat_json_init_array (&vam->json_tree);
19826 node = vat_json_array_add (&vam->json_tree);
19827 vat_json_init_object (node);
19829 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
19830 vat_json_object_add_uint (node, "appns_index",
19831 clib_net_to_host_u32 (mp->appns_index));
19832 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19833 vat_json_object_add_uint (node, "scope", mp->scope);
19834 vat_json_object_add_uint (node, "action_index",
19835 clib_net_to_host_u32 (mp->action_index));
19836 vat_json_object_add_uint (node, "lcl_port",
19837 clib_net_to_host_u16 (mp->lcl_port));
19838 vat_json_object_add_uint (node, "rmt_port",
19839 clib_net_to_host_u16 (mp->rmt_port));
19840 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
19841 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
19842 vat_json_object_add_string_copy (node, "tag", mp->tag);
19845 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
19846 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19847 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
19848 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19852 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
19853 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19854 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
19855 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19860 api_session_rule_add_del (vat_main_t * vam)
19862 vl_api_session_rule_add_del_t *mp;
19863 unformat_input_t *i = vam->input;
19864 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19865 u32 appns_index = 0, scope = 0;
19866 ip4_address_t lcl_ip4, rmt_ip4;
19867 ip6_address_t lcl_ip6, rmt_ip6;
19868 u8 is_ip4 = 1, conn_set = 0;
19869 u8 is_add = 1, *tag = 0;
19872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19874 if (unformat (i, "del"))
19876 else if (unformat (i, "add"))
19878 else if (unformat (i, "proto tcp"))
19880 else if (unformat (i, "proto udp"))
19882 else if (unformat (i, "appns %d", &appns_index))
19884 else if (unformat (i, "scope %d", &scope))
19886 else if (unformat (i, "tag %_%v%_", &tag))
19890 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19891 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19899 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19900 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19906 else if (unformat (i, "action %d", &action))
19911 if (proto == ~0 || !conn_set || action == ~0)
19913 errmsg ("transport proto, connection and action must be set");
19919 errmsg ("scope should be 0-3");
19923 M (SESSION_RULE_ADD_DEL, mp);
19925 mp->is_ip4 = is_ip4;
19926 mp->transport_proto = proto;
19927 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19928 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19929 mp->lcl_plen = lcl_plen;
19930 mp->rmt_plen = rmt_plen;
19931 mp->action_index = clib_host_to_net_u32 (action);
19932 mp->appns_index = clib_host_to_net_u32 (appns_index);
19934 mp->is_add = is_add;
19937 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
19938 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
19942 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
19943 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
19947 clib_memcpy (mp->tag, tag, vec_len (tag));
19957 api_session_rules_dump (vat_main_t * vam)
19959 vl_api_session_rules_dump_t *mp;
19960 vl_api_control_ping_t *mp_ping;
19963 if (!vam->json_output)
19965 print (vam->ofp, "%=20s", "Session Rules");
19968 M (SESSION_RULES_DUMP, mp);
19972 /* Use a control ping for synchronization */
19973 MPING (CONTROL_PING, mp_ping);
19976 /* Wait for a reply... */
19982 api_ip_container_proxy_add_del (vat_main_t * vam)
19984 vl_api_ip_container_proxy_add_del_t *mp;
19985 unformat_input_t *i = vam->input;
19986 u32 sw_if_index = ~0;
19987 vl_api_prefix_t pfx = { };
19991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19993 if (unformat (i, "del"))
19995 else if (unformat (i, "add"))
19997 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
19999 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20004 if (sw_if_index == ~0 || pfx.len == 0)
20006 errmsg ("address and sw_if_index must be set");
20010 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20012 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20013 mp->is_add = is_add;
20014 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20022 api_qos_record_enable_disable (vat_main_t * vam)
20024 unformat_input_t *i = vam->input;
20025 vl_api_qos_record_enable_disable_t *mp;
20026 u32 sw_if_index, qs = 0xff;
20027 u8 sw_if_index_set = 0;
20031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20033 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20034 sw_if_index_set = 1;
20035 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20036 sw_if_index_set = 1;
20037 else if (unformat (i, "%U", unformat_qos_source, &qs))
20039 else if (unformat (i, "disable"))
20043 clib_warning ("parse error '%U'", format_unformat_error, i);
20048 if (sw_if_index_set == 0)
20050 errmsg ("missing interface name or sw_if_index");
20055 errmsg ("input location must be specified");
20059 M (QOS_RECORD_ENABLE_DISABLE, mp);
20061 mp->record.sw_if_index = ntohl (sw_if_index);
20062 mp->record.input_source = qs;
20063 mp->enable = enable;
20072 q_or_quit (vat_main_t * vam)
20074 #if VPP_API_TEST_BUILTIN == 0
20075 longjmp (vam->jump_buf, 1);
20077 return 0; /* not so much */
20081 q (vat_main_t * vam)
20083 return q_or_quit (vam);
20087 quit (vat_main_t * vam)
20089 return q_or_quit (vam);
20093 comment (vat_main_t * vam)
20099 elog_save (vat_main_t * vam)
20101 #if VPP_API_TEST_BUILTIN == 0
20102 elog_main_t *em = &vam->elog_main;
20103 unformat_input_t *i = vam->input;
20104 char *file, *chroot_file;
20105 clib_error_t *error;
20107 if (!unformat (i, "%s", &file))
20109 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20113 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20114 if (strstr (file, "..") || index (file, '/'))
20116 errmsg ("illegal characters in filename '%s'", file);
20120 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20124 errmsg ("Saving %wd of %wd events to %s",
20125 elog_n_events_in_buffer (em),
20126 elog_buffer_capacity (em), chroot_file);
20128 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20129 vec_free (chroot_file);
20132 clib_error_report (error);
20134 errmsg ("Use the vpp event loger...");
20141 elog_setup (vat_main_t * vam)
20143 #if VPP_API_TEST_BUILTIN == 0
20144 elog_main_t *em = &vam->elog_main;
20145 unformat_input_t *i = vam->input;
20146 u32 nevents = 128 << 10;
20148 (void) unformat (i, "nevents %d", &nevents);
20150 elog_init (em, nevents);
20151 vl_api_set_elog_main (em);
20152 vl_api_set_elog_trace_api_messages (1);
20153 errmsg ("Event logger initialized with %u events", nevents);
20155 errmsg ("Use the vpp event loger...");
20161 elog_enable (vat_main_t * vam)
20163 #if VPP_API_TEST_BUILTIN == 0
20164 elog_main_t *em = &vam->elog_main;
20166 elog_enable_disable (em, 1 /* enable */ );
20167 vl_api_set_elog_trace_api_messages (1);
20168 errmsg ("Event logger enabled...");
20170 errmsg ("Use the vpp event loger...");
20176 elog_disable (vat_main_t * vam)
20178 #if VPP_API_TEST_BUILTIN == 0
20179 elog_main_t *em = &vam->elog_main;
20181 elog_enable_disable (em, 0 /* enable */ );
20182 vl_api_set_elog_trace_api_messages (1);
20183 errmsg ("Event logger disabled...");
20185 errmsg ("Use the vpp event loger...");
20191 statseg (vat_main_t * vam)
20193 ssvm_private_t *ssvmp = &vam->stat_segment;
20194 ssvm_shared_header_t *shared_header = ssvmp->sh;
20195 vlib_counter_t **counters;
20196 u64 thread0_index1_packets;
20197 u64 thread0_index1_bytes;
20198 f64 vector_rate, input_rate;
20201 uword *counter_vector_by_name;
20202 if (vam->stat_segment_lockp == 0)
20204 errmsg ("Stat segment not mapped...");
20208 /* look up "/if/rx for sw_if_index 1 as a test */
20210 clib_spinlock_lock (vam->stat_segment_lockp);
20212 counter_vector_by_name = (uword *) shared_header->opaque[1];
20214 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20217 clib_spinlock_unlock (vam->stat_segment_lockp);
20218 errmsg ("/if/tx not found?");
20222 /* Fish per-thread vector of combined counters from shared memory */
20223 counters = (vlib_counter_t **) p[0];
20225 if (vec_len (counters[0]) < 2)
20227 clib_spinlock_unlock (vam->stat_segment_lockp);
20228 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20232 /* Read thread 0 sw_if_index 1 counter */
20233 thread0_index1_packets = counters[0][1].packets;
20234 thread0_index1_bytes = counters[0][1].bytes;
20236 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20239 clib_spinlock_unlock (vam->stat_segment_lockp);
20240 errmsg ("vector_rate not found?");
20244 vector_rate = *(f64 *) (p[0]);
20245 p = hash_get_mem (counter_vector_by_name, "input_rate");
20248 clib_spinlock_unlock (vam->stat_segment_lockp);
20249 errmsg ("input_rate not found?");
20252 input_rate = *(f64 *) (p[0]);
20254 clib_spinlock_unlock (vam->stat_segment_lockp);
20256 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20257 vector_rate, input_rate);
20258 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20259 thread0_index1_packets, thread0_index1_bytes);
20265 cmd_cmp (void *a1, void *a2)
20270 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20274 help (vat_main_t * vam)
20279 unformat_input_t *i = vam->input;
20282 if (unformat (i, "%s", &name))
20286 vec_add1 (name, 0);
20288 hs = hash_get_mem (vam->help_by_name, name);
20290 print (vam->ofp, "usage: %s %s", name, hs[0]);
20292 print (vam->ofp, "No such msg / command '%s'", name);
20297 print (vam->ofp, "Help is available for the following:");
20300 hash_foreach_pair (p, vam->function_by_name,
20302 vec_add1 (cmds, (u8 *)(p->key));
20306 vec_sort_with_function (cmds, cmd_cmp);
20308 for (j = 0; j < vec_len (cmds); j++)
20309 print (vam->ofp, "%s", cmds[j]);
20316 set (vat_main_t * vam)
20318 u8 *name = 0, *value = 0;
20319 unformat_input_t *i = vam->input;
20321 if (unformat (i, "%s", &name))
20323 /* The input buffer is a vector, not a string. */
20324 value = vec_dup (i->buffer);
20325 vec_delete (value, i->index, 0);
20326 /* Almost certainly has a trailing newline */
20327 if (value[vec_len (value) - 1] == '\n')
20328 value[vec_len (value) - 1] = 0;
20329 /* Make sure it's a proper string, one way or the other */
20330 vec_add1 (value, 0);
20331 (void) clib_macro_set_value (&vam->macro_main,
20332 (char *) name, (char *) value);
20335 errmsg ("usage: set <name> <value>");
20343 unset (vat_main_t * vam)
20347 if (unformat (vam->input, "%s", &name))
20348 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20349 errmsg ("unset: %s wasn't set", name);
20362 macro_sort_cmp (void *a1, void *a2)
20364 macro_sort_t *s1 = a1;
20365 macro_sort_t *s2 = a2;
20367 return strcmp ((char *) (s1->name), (char *) (s2->name));
20371 dump_macro_table (vat_main_t * vam)
20373 macro_sort_t *sort_me = 0, *sm;
20378 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20380 vec_add2 (sort_me, sm, 1);
20381 sm->name = (u8 *)(p->key);
20382 sm->value = (u8 *) (p->value[0]);
20386 vec_sort_with_function (sort_me, macro_sort_cmp);
20388 if (vec_len (sort_me))
20389 print (vam->ofp, "%-15s%s", "Name", "Value");
20391 print (vam->ofp, "The macro table is empty...");
20393 for (i = 0; i < vec_len (sort_me); i++)
20394 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20399 dump_node_table (vat_main_t * vam)
20402 vlib_node_t *node, *next_node;
20404 if (vec_len (vam->graph_nodes) == 0)
20406 print (vam->ofp, "Node table empty, issue get_node_graph...");
20410 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20412 node = vam->graph_nodes[0][i];
20413 print (vam->ofp, "[%d] %s", i, node->name);
20414 for (j = 0; j < vec_len (node->next_nodes); j++)
20416 if (node->next_nodes[j] != ~0)
20418 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20419 print (vam->ofp, " [%d] %s", j, next_node->name);
20427 value_sort_cmp (void *a1, void *a2)
20429 name_sort_t *n1 = a1;
20430 name_sort_t *n2 = a2;
20432 if (n1->value < n2->value)
20434 if (n1->value > n2->value)
20441 dump_msg_api_table (vat_main_t * vam)
20443 api_main_t *am = vlibapi_get_main ();
20444 name_sort_t *nses = 0, *ns;
20449 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20451 vec_add2 (nses, ns, 1);
20452 ns->name = (u8 *)(hp->key);
20453 ns->value = (u32) hp->value[0];
20457 vec_sort_with_function (nses, value_sort_cmp);
20459 for (i = 0; i < vec_len (nses); i++)
20460 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20466 get_msg_id (vat_main_t * vam)
20471 if (unformat (vam->input, "%s", &name_and_crc))
20473 message_index = vl_msg_api_get_msg_index (name_and_crc);
20474 if (message_index == ~0)
20476 print (vam->ofp, " '%s' not found", name_and_crc);
20479 print (vam->ofp, " '%s' has message index %d",
20480 name_and_crc, message_index);
20483 errmsg ("name_and_crc required...");
20488 search_node_table (vat_main_t * vam)
20490 unformat_input_t *line_input = vam->input;
20493 vlib_node_t *node, *next_node;
20496 if (vam->graph_node_index_by_name == 0)
20498 print (vam->ofp, "Node table empty, issue get_node_graph...");
20502 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20504 if (unformat (line_input, "%s", &node_to_find))
20506 vec_add1 (node_to_find, 0);
20507 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20510 print (vam->ofp, "%s not found...", node_to_find);
20513 node = vam->graph_nodes[0][p[0]];
20514 print (vam->ofp, "[%d] %s", p[0], node->name);
20515 for (j = 0; j < vec_len (node->next_nodes); j++)
20517 if (node->next_nodes[j] != ~0)
20519 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20520 print (vam->ofp, " [%d] %s", j, next_node->name);
20527 clib_warning ("parse error '%U'", format_unformat_error,
20533 vec_free (node_to_find);
20542 script (vat_main_t * vam)
20544 #if (VPP_API_TEST_BUILTIN==0)
20546 char *save_current_file;
20547 unformat_input_t save_input;
20548 jmp_buf save_jump_buf;
20549 u32 save_line_number;
20551 FILE *new_fp, *save_ifp;
20553 if (unformat (vam->input, "%s", &s))
20555 new_fp = fopen ((char *) s, "r");
20558 errmsg ("Couldn't open script file %s", s);
20565 errmsg ("Missing script name");
20569 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20570 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20571 save_ifp = vam->ifp;
20572 save_line_number = vam->input_line_number;
20573 save_current_file = (char *) vam->current_file;
20575 vam->input_line_number = 0;
20577 vam->current_file = s;
20580 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20581 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20582 vam->ifp = save_ifp;
20583 vam->input_line_number = save_line_number;
20584 vam->current_file = (u8 *) save_current_file;
20589 clib_warning ("use the exec command...");
20595 echo (vat_main_t * vam)
20597 print (vam->ofp, "%v", vam->input->buffer);
20601 /* List of API message constructors, CLI names map to api_xxx */
20602 #define foreach_vpe_api_msg \
20603 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20604 _(sw_interface_dump,"") \
20605 _(sw_interface_set_flags, \
20606 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20607 _(sw_interface_add_del_address, \
20608 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20609 _(sw_interface_set_rx_mode, \
20610 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20611 _(sw_interface_set_rx_placement, \
20612 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20613 _(sw_interface_rx_placement_dump, \
20614 "[<intfc> | sw_if_index <id>]") \
20615 _(sw_interface_set_table, \
20616 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20617 _(sw_interface_set_mpls_enable, \
20618 "<intfc> | sw_if_index [disable | dis]") \
20619 _(sw_interface_set_vpath, \
20620 "<intfc> | sw_if_index <id> enable | disable") \
20621 _(sw_interface_set_vxlan_bypass, \
20622 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20623 _(sw_interface_set_geneve_bypass, \
20624 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20625 _(sw_interface_set_l2_xconnect, \
20626 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20627 "enable | disable") \
20628 _(sw_interface_set_l2_bridge, \
20629 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20630 "[shg <split-horizon-group>] [bvi]\n" \
20631 "enable | disable") \
20632 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20633 _(bridge_domain_add_del, \
20634 "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") \
20635 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20637 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20638 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20639 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20641 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20643 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20645 "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload]") \
20647 "<vpp-if-name> | sw_if_index <id>") \
20648 _(sw_interface_tap_v2_dump, "") \
20649 _(virtio_pci_create, \
20650 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20651 _(virtio_pci_delete, \
20652 "<vpp-if-name> | sw_if_index <id>") \
20653 _(sw_interface_virtio_pci_dump, "") \
20655 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20656 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20659 "<vpp-if-name> | sw_if_index <id>") \
20661 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20662 _(bond_detach_slave, \
20663 "sw_if_index <n>") \
20664 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20665 _(sw_interface_bond_dump, "") \
20666 _(sw_interface_slave_dump, \
20667 "<vpp-if-name> | sw_if_index <id>") \
20668 _(ip_table_add_del, \
20669 "table <n> [ipv6] [add | del]\n") \
20670 _(ip_route_add_del, \
20671 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20672 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20673 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20674 "[multipath] [count <n>] [del]") \
20675 _(ip_mroute_add_del, \
20676 "<src> <grp>/<mask> [table-id <n>]\n" \
20677 "[<intfc> | sw_if_index <id>] [local] [del]") \
20678 _(mpls_table_add_del, \
20679 "table <n> [add | del]\n") \
20680 _(mpls_route_add_del, \
20681 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20682 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20683 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20684 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20685 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20686 "[count <n>] [del]") \
20687 _(mpls_ip_bind_unbind, \
20688 "<label> <addr/len>") \
20689 _(mpls_tunnel_add_del, \
20690 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20691 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20692 "[l2-only] [out-label <n>]") \
20693 _(sr_mpls_policy_add, \
20694 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20695 _(sr_mpls_policy_del, \
20697 _(bier_table_add_del, \
20698 "<label> <sub-domain> <set> <bsl> [del]") \
20699 _(bier_route_add_del, \
20700 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20701 "[<intfc> | sw_if_index <id>]" \
20702 "[weight <n>] [del] [multipath]") \
20703 _(sw_interface_set_unnumbered, \
20704 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20705 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20706 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20707 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20708 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20709 "[outer_vlan_id_any][inner_vlan_id_any]") \
20710 _(ip_table_replace_begin, "table <n> [ipv6]") \
20711 _(ip_table_flush, "table <n> [ipv6]") \
20712 _(ip_table_replace_end, "table <n> [ipv6]") \
20713 _(set_ip_flow_hash, \
20714 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20715 _(sw_interface_ip6_enable_disable, \
20716 "<intfc> | sw_if_index <id> enable | disable") \
20717 _(l2_patch_add_del, \
20718 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20719 "enable | disable") \
20720 _(sr_localsid_add_del, \
20721 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20722 "fib-table <num> (end.psp) sw_if_index <num>") \
20723 _(classify_add_del_table, \
20724 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20725 " [del] [del-chain] mask <mask-value>\n" \
20726 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20727 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20728 _(classify_add_del_session, \
20729 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20730 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20731 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20732 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20733 _(classify_set_interface_ip_table, \
20734 "<intfc> | sw_if_index <nn> table <nn>") \
20735 _(classify_set_interface_l2_tables, \
20736 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20737 " [other-table <nn>]") \
20738 _(get_node_index, "node <node-name") \
20739 _(add_node_next, "node <node-name> next <next-node-name>") \
20740 _(l2tpv3_create_tunnel, \
20741 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20742 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20743 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20744 _(l2tpv3_set_tunnel_cookies, \
20745 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20746 "[new_remote_cookie <nn>]\n") \
20747 _(l2tpv3_interface_enable_disable, \
20748 "<intfc> | sw_if_index <nn> enable | disable") \
20749 _(l2tpv3_set_lookup_key, \
20750 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20751 _(sw_if_l2tpv3_tunnel_dump, "") \
20752 _(vxlan_offload_rx, \
20753 "hw { <interface name> | hw_if_index <nn>} " \
20754 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20755 _(vxlan_add_del_tunnel, \
20756 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20757 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20758 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20759 _(geneve_add_del_tunnel, \
20760 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20761 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20762 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20763 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20764 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20765 _(gre_tunnel_add_del, \
20766 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20767 "[teb | erspan <session-id>] [del]") \
20768 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20769 _(l2_fib_clear_table, "") \
20770 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20771 _(l2_interface_vlan_tag_rewrite, \
20772 "<intfc> | sw_if_index <nn> \n" \
20773 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20774 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20775 _(create_vhost_user_if, \
20776 "socket <filename> [server] [renumber <dev_instance>] " \
20777 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20778 "[mac <mac_address>]") \
20779 _(modify_vhost_user_if, \
20780 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20781 "[server] [renumber <dev_instance>] [gso]") \
20782 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20783 _(sw_interface_vhost_user_dump, "") \
20784 _(show_version, "") \
20785 _(show_threads, "") \
20786 _(vxlan_gpe_add_del_tunnel, \
20787 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20788 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20789 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20790 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20791 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20792 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20793 _(interface_name_renumber, \
20794 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20795 _(input_acl_set_interface, \
20796 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20797 " [l2-table <nn>] [del]") \
20798 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20799 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20800 _(ip_dump, "ipv4 | ipv6") \
20801 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20802 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20804 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20805 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20806 " integ_alg <alg> integ_key <hex>") \
20807 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20808 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20809 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20810 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20811 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20812 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20813 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20814 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20815 " [instance <n>]") \
20816 _(ipsec_sa_dump, "[sa_id <n>]") \
20817 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20818 _(delete_loopback,"sw_if_index <nn>") \
20819 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20820 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20821 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20822 _(want_interface_events, "enable|disable") \
20823 _(get_first_msg_id, "client <name>") \
20824 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20825 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20826 "fib-id <nn> [ip4][ip6][default]") \
20827 _(get_node_graph, " ") \
20828 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20829 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20830 _(ioam_disable, "") \
20831 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20832 " sw_if_index <sw_if_index> p <priority> " \
20833 "w <weight>] [del]") \
20834 _(one_add_del_locator, "locator-set <locator_name> " \
20835 "iface <intf> | sw_if_index <sw_if_index> " \
20836 "p <priority> w <weight> [del]") \
20837 _(one_add_del_local_eid,"vni <vni> eid " \
20838 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20839 "locator-set <locator_name> [del]" \
20840 "[key-id sha1|sha256 secret-key <secret-key>]")\
20841 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20842 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20843 _(one_enable_disable, "enable|disable") \
20844 _(one_map_register_enable_disable, "enable|disable") \
20845 _(one_map_register_fallback_threshold, "<value>") \
20846 _(one_rloc_probe_enable_disable, "enable|disable") \
20847 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20849 "rloc <locator> p <prio> " \
20850 "w <weight> [rloc <loc> ... ] " \
20851 "action <action> [del-all]") \
20852 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20854 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20855 _(one_use_petr, "ip-address> | disable") \
20856 _(one_map_request_mode, "src-dst|dst-only") \
20857 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20858 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20859 _(one_locator_set_dump, "[local | remote]") \
20860 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20861 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20862 "[local] | [remote]") \
20863 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20864 _(one_ndp_bd_get, "") \
20865 _(one_ndp_entries_get, "bd <bridge-domain>") \
20866 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20867 _(one_l2_arp_bd_get, "") \
20868 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20869 _(one_stats_enable_disable, "enable|disable") \
20870 _(show_one_stats_enable_disable, "") \
20871 _(one_eid_table_vni_dump, "") \
20872 _(one_eid_table_map_dump, "l2|l3") \
20873 _(one_map_resolver_dump, "") \
20874 _(one_map_server_dump, "") \
20875 _(one_adjacencies_get, "vni <vni>") \
20876 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20877 _(show_one_rloc_probe_state, "") \
20878 _(show_one_map_register_state, "") \
20879 _(show_one_status, "") \
20880 _(one_stats_dump, "") \
20881 _(one_stats_flush, "") \
20882 _(one_get_map_request_itr_rlocs, "") \
20883 _(one_map_register_set_ttl, "<ttl>") \
20884 _(one_set_transport_protocol, "udp|api") \
20885 _(one_get_transport_protocol, "") \
20886 _(one_enable_disable_xtr_mode, "enable|disable") \
20887 _(one_show_xtr_mode, "") \
20888 _(one_enable_disable_pitr_mode, "enable|disable") \
20889 _(one_show_pitr_mode, "") \
20890 _(one_enable_disable_petr_mode, "enable|disable") \
20891 _(one_show_petr_mode, "") \
20892 _(show_one_nsh_mapping, "") \
20893 _(show_one_pitr, "") \
20894 _(show_one_use_petr, "") \
20895 _(show_one_map_request_mode, "") \
20896 _(show_one_map_register_ttl, "") \
20897 _(show_one_map_register_fallback_threshold, "") \
20898 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20899 " sw_if_index <sw_if_index> p <priority> " \
20900 "w <weight>] [del]") \
20901 _(lisp_add_del_locator, "locator-set <locator_name> " \
20902 "iface <intf> | sw_if_index <sw_if_index> " \
20903 "p <priority> w <weight> [del]") \
20904 _(lisp_add_del_local_eid,"vni <vni> eid " \
20905 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20906 "locator-set <locator_name> [del]" \
20907 "[key-id sha1|sha256 secret-key <secret-key>]") \
20908 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20909 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20910 _(lisp_enable_disable, "enable|disable") \
20911 _(lisp_map_register_enable_disable, "enable|disable") \
20912 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20913 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20915 "rloc <locator> p <prio> " \
20916 "w <weight> [rloc <loc> ... ] " \
20917 "action <action> [del-all]") \
20918 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20920 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20921 _(lisp_use_petr, "<ip-address> | disable") \
20922 _(lisp_map_request_mode, "src-dst|dst-only") \
20923 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20924 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20925 _(lisp_locator_set_dump, "[local | remote]") \
20926 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20927 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20928 "[local] | [remote]") \
20929 _(lisp_eid_table_vni_dump, "") \
20930 _(lisp_eid_table_map_dump, "l2|l3") \
20931 _(lisp_map_resolver_dump, "") \
20932 _(lisp_map_server_dump, "") \
20933 _(lisp_adjacencies_get, "vni <vni>") \
20934 _(gpe_fwd_entry_vnis_get, "") \
20935 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20936 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20937 "[table <table-id>]") \
20938 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20939 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20940 _(gpe_set_encap_mode, "lisp|vxlan") \
20941 _(gpe_get_encap_mode, "") \
20942 _(lisp_gpe_add_del_iface, "up|down") \
20943 _(lisp_gpe_enable_disable, "enable|disable") \
20944 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20945 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20946 _(show_lisp_rloc_probe_state, "") \
20947 _(show_lisp_map_register_state, "") \
20948 _(show_lisp_status, "") \
20949 _(lisp_get_map_request_itr_rlocs, "") \
20950 _(show_lisp_pitr, "") \
20951 _(show_lisp_use_petr, "") \
20952 _(show_lisp_map_request_mode, "") \
20953 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20954 _(af_packet_delete, "name <host interface name>") \
20955 _(af_packet_dump, "") \
20956 _(policer_add_del, "name <policer name> <params> [del]") \
20957 _(policer_dump, "[name <policer name>]") \
20958 _(policer_classify_set_interface, \
20959 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20960 " [l2-table <nn>] [del]") \
20961 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20962 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20963 _(mpls_table_dump, "") \
20964 _(mpls_route_dump, "table-id <ID>") \
20965 _(classify_table_ids, "") \
20966 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20967 _(classify_table_info, "table_id <nn>") \
20968 _(classify_session_dump, "table_id <nn>") \
20969 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20970 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20971 "[template_interval <nn>] [udp_checksum]") \
20972 _(ipfix_exporter_dump, "") \
20973 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20974 _(ipfix_classify_stream_dump, "") \
20975 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20976 _(ipfix_classify_table_dump, "") \
20977 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20978 _(sw_interface_span_dump, "[l2]") \
20979 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20980 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
20981 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20982 _(pg_enable_disable, "[stream <id>] disable") \
20983 _(ip_source_and_port_range_check_add_del, \
20984 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20985 _(ip_source_and_port_range_check_interface_add_del, \
20986 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20987 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20988 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20989 _(l2_interface_pbb_tag_rewrite, \
20990 "<intfc> | sw_if_index <nn> \n" \
20991 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
20992 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
20993 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
20994 _(flow_classify_set_interface, \
20995 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
20996 _(flow_classify_dump, "type [ip4|ip6]") \
20997 _(ip_table_dump, "") \
20998 _(ip_route_dump, "table-id [ip4|ip6]") \
20999 _(ip_mtable_dump, "") \
21000 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21001 _(feature_enable_disable, "arc_name <arc_name> " \
21002 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21003 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21004 "[enable | disable] ") \
21005 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21007 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21008 "mac <mac-address> [del]") \
21009 _(l2_xconnect_dump, "") \
21010 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21011 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21012 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21013 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21014 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21015 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21016 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21017 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21018 _(sock_init_shm, "size <nnn>") \
21019 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21020 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21021 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21022 _(session_rules_dump, "") \
21023 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21024 _(output_acl_set_interface, \
21025 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21026 " [l2-table <nn>] [del]") \
21027 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21029 /* List of command functions, CLI names map directly to functions */
21030 #define foreach_cli_function \
21031 _(comment, "usage: comment <ignore-rest-of-line>") \
21032 _(dump_interface_table, "usage: dump_interface_table") \
21033 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21034 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21035 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21036 _(dump_macro_table, "usage: dump_macro_table ") \
21037 _(dump_node_table, "usage: dump_node_table") \
21038 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21039 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21040 _(elog_disable, "usage: elog_disable") \
21041 _(elog_enable, "usage: elog_enable") \
21042 _(elog_save, "usage: elog_save <filename>") \
21043 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21044 _(echo, "usage: echo <message>") \
21045 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21046 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21047 _(help, "usage: help") \
21048 _(q, "usage: quit") \
21049 _(quit, "usage: quit") \
21050 _(search_node_table, "usage: search_node_table <name>...") \
21051 _(set, "usage: set <variable-name> <value>") \
21052 _(script, "usage: script <file-name>") \
21053 _(statseg, "usage: statseg") \
21054 _(unset, "usage: unset <variable-name>")
21057 static void vl_api_##n##_t_handler_uni \
21058 (vl_api_##n##_t * mp) \
21060 vat_main_t * vam = &vat_main; \
21061 if (vam->json_output) { \
21062 vl_api_##n##_t_handler_json(mp); \
21064 vl_api_##n##_t_handler(mp); \
21067 foreach_vpe_api_reply_msg;
21068 #if VPP_API_TEST_BUILTIN == 0
21069 foreach_standalone_reply_msg;
21074 vat_api_hookup (vat_main_t * vam)
21077 vl_msg_api_set_handlers(VL_API_##N, #n, \
21078 vl_api_##n##_t_handler_uni, \
21080 vl_api_##n##_t_endian, \
21081 vl_api_##n##_t_print, \
21082 sizeof(vl_api_##n##_t), 1);
21083 foreach_vpe_api_reply_msg;
21084 #if VPP_API_TEST_BUILTIN == 0
21085 foreach_standalone_reply_msg;
21089 #if (VPP_API_TEST_BUILTIN==0)
21090 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21092 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21094 vam->function_by_name = hash_create_string (0, sizeof (uword));
21096 vam->help_by_name = hash_create_string (0, sizeof (uword));
21099 /* API messages we can send */
21100 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21101 foreach_vpe_api_msg;
21105 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21106 foreach_vpe_api_msg;
21109 /* CLI functions */
21110 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21111 foreach_cli_function;
21115 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21116 foreach_cli_function;
21120 #if VPP_API_TEST_BUILTIN
21121 static clib_error_t *
21122 vat_api_hookup_shim (vlib_main_t * vm)
21124 vat_api_hookup (&vat_main);
21128 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21132 * fd.io coding-style-patch-verification: ON
21135 * eval: (c-set-style "gnu")