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 _(netmap_create_reply) \
5113 _(netmap_delete_reply) \
5114 _(set_ipfix_exporter_reply) \
5115 _(set_ipfix_classify_stream_reply) \
5116 _(ipfix_classify_table_add_del_reply) \
5117 _(flow_classify_set_interface_reply) \
5118 _(sw_interface_span_enable_disable_reply) \
5119 _(pg_capture_reply) \
5120 _(pg_enable_disable_reply) \
5121 _(ip_source_and_port_range_check_add_del_reply) \
5122 _(ip_source_and_port_range_check_interface_add_del_reply)\
5123 _(delete_subif_reply) \
5124 _(l2_interface_pbb_tag_rewrite_reply) \
5126 _(feature_enable_disable_reply) \
5127 _(feature_gso_enable_disable_reply) \
5128 _(sw_interface_tag_add_del_reply) \
5129 _(sw_interface_add_del_mac_address_reply) \
5130 _(hw_interface_set_mtu_reply) \
5131 _(p2p_ethernet_add_reply) \
5132 _(p2p_ethernet_del_reply) \
5133 _(lldp_config_reply) \
5134 _(sw_interface_set_lldp_reply) \
5135 _(tcp_configure_src_addresses_reply) \
5136 _(session_rule_add_del_reply) \
5137 _(ip_container_proxy_add_del_reply) \
5138 _(output_acl_set_interface_reply) \
5139 _(qos_record_enable_disable_reply)
5142 static void vl_api_##n##_t_handler \
5143 (vl_api_##n##_t * mp) \
5145 vat_main_t * vam = &vat_main; \
5146 i32 retval = ntohl(mp->retval); \
5147 if (vam->async_mode) { \
5148 vam->async_errors += (retval < 0); \
5150 vam->retval = retval; \
5151 vam->result_ready = 1; \
5154 foreach_standard_reply_retval_handler;
5158 static void vl_api_##n##_t_handler_json \
5159 (vl_api_##n##_t * mp) \
5161 vat_main_t * vam = &vat_main; \
5162 vat_json_node_t node; \
5163 vat_json_init_object(&node); \
5164 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5165 vat_json_print(vam->ofp, &node); \
5166 vam->retval = ntohl(mp->retval); \
5167 vam->result_ready = 1; \
5169 foreach_standard_reply_retval_handler;
5173 * Table of message reply handlers, must include boilerplate handlers
5177 #define foreach_vpe_api_reply_msg \
5178 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5179 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5180 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5181 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5182 _(CONTROL_PING_REPLY, control_ping_reply) \
5183 _(CLI_REPLY, cli_reply) \
5184 _(CLI_INBAND_REPLY, cli_inband_reply) \
5185 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5186 sw_interface_add_del_address_reply) \
5187 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5188 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5189 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5190 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5191 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5192 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5193 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5194 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5195 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5196 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5197 sw_interface_set_l2_xconnect_reply) \
5198 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5199 sw_interface_set_l2_bridge_reply) \
5200 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5201 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5202 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5203 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5204 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5205 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5206 _(L2_FLAGS_REPLY, l2_flags_reply) \
5207 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5208 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5209 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5210 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5211 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5212 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5213 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5214 _(BOND_CREATE_REPLY, bond_create_reply) \
5215 _(BOND_DELETE_REPLY, bond_delete_reply) \
5216 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5217 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5218 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5219 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5220 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5221 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5222 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5223 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5224 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5225 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5226 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5227 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5228 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5229 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5230 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5231 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5232 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5233 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5234 sw_interface_set_unnumbered_reply) \
5235 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5236 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5237 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5238 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5239 sw_interface_ip6_enable_disable_reply) \
5240 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5241 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5242 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5243 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5244 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5245 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5246 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5247 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5248 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5249 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5250 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5251 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5252 classify_set_interface_ip_table_reply) \
5253 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5254 classify_set_interface_l2_tables_reply) \
5255 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5256 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5257 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5258 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5259 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5260 l2tpv3_interface_enable_disable_reply) \
5261 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5262 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5263 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5264 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5265 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5266 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5267 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5268 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5269 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5270 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5271 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5272 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5273 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5274 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5275 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5276 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5277 _(SHOW_VERSION_REPLY, show_version_reply) \
5278 _(SHOW_THREADS_REPLY, show_threads_reply) \
5279 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5280 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5281 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5282 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5283 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5284 _(L2_MACS_EVENT, l2_macs_event) \
5285 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5286 _(IP_ADDRESS_DETAILS, ip_address_details) \
5287 _(IP_DETAILS, ip_details) \
5288 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5289 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5290 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5291 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5292 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5293 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5294 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5295 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5296 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5297 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5298 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5299 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5300 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5301 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5302 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5303 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5304 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5305 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5306 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5307 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5308 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5309 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5310 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5311 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5312 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5313 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5314 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5315 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5316 one_map_register_enable_disable_reply) \
5317 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5318 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5319 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5320 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5321 one_map_register_fallback_threshold_reply) \
5322 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5323 one_rloc_probe_enable_disable_reply) \
5324 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5325 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5326 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5327 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5328 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5329 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5330 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5331 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5332 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5333 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5334 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5335 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5336 _(ONE_STATS_DETAILS, one_stats_details) \
5337 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5338 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5339 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5340 show_one_stats_enable_disable_reply) \
5341 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5342 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5343 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5344 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5345 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5346 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5347 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5348 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5349 one_enable_disable_pitr_mode_reply) \
5350 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5351 one_enable_disable_petr_mode_reply) \
5352 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5353 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5354 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5355 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5356 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5357 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5358 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5359 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5360 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5361 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5362 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5363 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5364 gpe_add_del_native_fwd_rpath_reply) \
5365 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5366 gpe_fwd_entry_path_details) \
5367 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5368 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5369 one_add_del_map_request_itr_rlocs_reply) \
5370 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5371 one_get_map_request_itr_rlocs_reply) \
5372 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5373 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5374 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5375 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5376 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5377 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5378 show_one_map_register_state_reply) \
5379 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5380 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5381 show_one_map_register_fallback_threshold_reply) \
5382 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5383 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5384 _(AF_PACKET_DETAILS, af_packet_details) \
5385 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5386 _(POLICER_DETAILS, policer_details) \
5387 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5388 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5389 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5390 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5391 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5392 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5393 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5394 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5395 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5396 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5397 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5398 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5399 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5400 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5401 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5402 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5403 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5404 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5405 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5406 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5407 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5408 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5409 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5410 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5411 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5412 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5413 ip_source_and_port_range_check_add_del_reply) \
5414 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5415 ip_source_and_port_range_check_interface_add_del_reply) \
5416 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5417 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5418 _(SET_PUNT_REPLY, set_punt_reply) \
5419 _(IP_TABLE_DETAILS, ip_table_details) \
5420 _(IP_ROUTE_DETAILS, ip_route_details) \
5421 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5422 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5423 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5424 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5425 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5426 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5427 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5428 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5429 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5430 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5431 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5432 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5433 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5434 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5435 _(SESSION_RULES_DETAILS, session_rules_details) \
5436 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5437 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5438 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5440 #define foreach_standalone_reply_msg \
5441 _(SW_INTERFACE_EVENT, sw_interface_event)
5449 #define STR_VTR_OP_CASE(op) \
5450 case L2_VTR_ ## op: \
5454 str_vtr_op (u32 vtr_op)
5458 STR_VTR_OP_CASE (DISABLED);
5459 STR_VTR_OP_CASE (PUSH_1);
5460 STR_VTR_OP_CASE (PUSH_2);
5461 STR_VTR_OP_CASE (POP_1);
5462 STR_VTR_OP_CASE (POP_2);
5463 STR_VTR_OP_CASE (TRANSLATE_1_1);
5464 STR_VTR_OP_CASE (TRANSLATE_1_2);
5465 STR_VTR_OP_CASE (TRANSLATE_2_1);
5466 STR_VTR_OP_CASE (TRANSLATE_2_2);
5473 dump_sub_interface_table (vat_main_t * vam)
5475 const sw_interface_subif_t *sub = NULL;
5477 if (vam->json_output)
5480 ("JSON output supported only for VPE API calls and dump_stats_table");
5485 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5486 "Interface", "sw_if_index",
5487 "sub id", "dot1ad", "tags", "outer id",
5488 "inner id", "exact", "default", "outer any", "inner any");
5490 vec_foreach (sub, vam->sw_if_subif_table)
5493 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5494 sub->interface_name,
5496 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5497 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5498 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5499 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5500 if (sub->vtr_op != L2_VTR_DISABLED)
5503 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5504 "tag1: %d tag2: %d ]",
5505 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5506 sub->vtr_tag1, sub->vtr_tag2);
5514 name_sort_cmp (void *a1, void *a2)
5516 name_sort_t *n1 = a1;
5517 name_sort_t *n2 = a2;
5519 return strcmp ((char *) n1->name, (char *) n2->name);
5523 dump_interface_table (vat_main_t * vam)
5526 name_sort_t *nses = 0, *ns;
5528 if (vam->json_output)
5531 ("JSON output supported only for VPE API calls and dump_stats_table");
5536 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5538 vec_add2 (nses, ns, 1);
5539 ns->name = (u8 *)(p->key);
5540 ns->value = (u32) p->value[0];
5544 vec_sort_with_function (nses, name_sort_cmp);
5546 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5547 vec_foreach (ns, nses)
5549 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5556 dump_ip_table (vat_main_t * vam, int is_ipv6)
5558 const ip_details_t *det = NULL;
5559 const ip_address_details_t *address = NULL;
5562 print (vam->ofp, "%-12s", "sw_if_index");
5564 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5571 print (vam->ofp, "%-12d", i);
5572 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5577 vec_foreach (address, det->addr)
5581 is_ipv6 ? format_ip6_address : format_ip4_address,
5582 address->ip, address->prefix_length);
5590 dump_ipv4_table (vat_main_t * vam)
5592 if (vam->json_output)
5595 ("JSON output supported only for VPE API calls and dump_stats_table");
5599 return dump_ip_table (vam, 0);
5603 dump_ipv6_table (vat_main_t * vam)
5605 if (vam->json_output)
5608 ("JSON output supported only for VPE API calls and dump_stats_table");
5612 return dump_ip_table (vam, 1);
5616 * Pass CLI buffers directly in the CLI_INBAND API message,
5617 * instead of an additional shared memory area.
5620 exec_inband (vat_main_t * vam)
5622 vl_api_cli_inband_t *mp;
5623 unformat_input_t *i = vam->input;
5626 if (vec_len (i->buffer) == 0)
5629 if (vam->exec_mode == 0 && unformat (i, "mode"))
5634 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5641 * In order for the CLI command to work, it
5642 * must be a vector ending in \n, not a C-string ending
5645 u32 len = vec_len (vam->input->buffer);
5646 M2 (CLI_INBAND, mp, len);
5647 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5651 /* json responses may or may not include a useful reply... */
5652 if (vec_len (vam->cmd_reply))
5653 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5658 exec (vat_main_t * vam)
5660 return exec_inband (vam);
5664 api_create_loopback (vat_main_t * vam)
5666 unformat_input_t *i = vam->input;
5667 vl_api_create_loopback_t *mp;
5668 vl_api_create_loopback_instance_t *mp_lbi;
5671 u8 is_specified = 0;
5672 u32 user_instance = 0;
5675 clib_memset (mac_address, 0, sizeof (mac_address));
5677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5679 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5681 if (unformat (i, "instance %d", &user_instance))
5689 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5690 mp_lbi->is_specified = is_specified;
5692 mp_lbi->user_instance = htonl (user_instance);
5694 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5699 /* Construct the API message */
5700 M (CREATE_LOOPBACK, mp);
5702 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5711 api_delete_loopback (vat_main_t * vam)
5713 unformat_input_t *i = vam->input;
5714 vl_api_delete_loopback_t *mp;
5715 u32 sw_if_index = ~0;
5718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5720 if (unformat (i, "sw_if_index %d", &sw_if_index))
5726 if (sw_if_index == ~0)
5728 errmsg ("missing sw_if_index");
5732 /* Construct the API message */
5733 M (DELETE_LOOPBACK, mp);
5734 mp->sw_if_index = ntohl (sw_if_index);
5742 api_want_interface_events (vat_main_t * vam)
5744 unformat_input_t *i = vam->input;
5745 vl_api_want_interface_events_t *mp;
5749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5751 if (unformat (i, "enable"))
5753 else if (unformat (i, "disable"))
5761 errmsg ("missing enable|disable");
5765 M (WANT_INTERFACE_EVENTS, mp);
5766 mp->enable_disable = enable;
5768 vam->interface_event_display = enable;
5776 /* Note: non-static, called once to set up the initial intfc table */
5778 api_sw_interface_dump (vat_main_t * vam)
5780 vl_api_sw_interface_dump_t *mp;
5781 vl_api_control_ping_t *mp_ping;
5783 name_sort_t *nses = 0, *ns;
5784 sw_interface_subif_t *sub = NULL;
5787 /* Toss the old name table */
5789 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5791 vec_add2 (nses, ns, 1);
5792 ns->name = (u8 *)(p->key);
5793 ns->value = (u32) p->value[0];
5797 hash_free (vam->sw_if_index_by_interface_name);
5799 vec_foreach (ns, nses) vec_free (ns->name);
5803 vec_foreach (sub, vam->sw_if_subif_table)
5805 vec_free (sub->interface_name);
5807 vec_free (vam->sw_if_subif_table);
5809 /* recreate the interface name hash table */
5810 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5813 * Ask for all interface names. Otherwise, the epic catalog of
5814 * name filters becomes ridiculously long, and vat ends up needing
5815 * to be taught about new interface types.
5817 M (SW_INTERFACE_DUMP, mp);
5820 /* Use a control ping for synchronization */
5821 MPING (CONTROL_PING, mp_ping);
5829 api_sw_interface_set_flags (vat_main_t * vam)
5831 unformat_input_t *i = vam->input;
5832 vl_api_sw_interface_set_flags_t *mp;
5834 u8 sw_if_index_set = 0;
5838 /* Parse args required to build the message */
5839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5841 if (unformat (i, "admin-up"))
5843 else if (unformat (i, "admin-down"))
5846 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5847 sw_if_index_set = 1;
5848 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5849 sw_if_index_set = 1;
5854 if (sw_if_index_set == 0)
5856 errmsg ("missing interface name or sw_if_index");
5860 /* Construct the API message */
5861 M (SW_INTERFACE_SET_FLAGS, mp);
5862 mp->sw_if_index = ntohl (sw_if_index);
5863 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5868 /* Wait for a reply, return the good/bad news... */
5874 api_sw_interface_set_rx_mode (vat_main_t * vam)
5876 unformat_input_t *i = vam->input;
5877 vl_api_sw_interface_set_rx_mode_t *mp;
5879 u8 sw_if_index_set = 0;
5881 u8 queue_id_valid = 0;
5883 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5885 /* Parse args required to build the message */
5886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5888 if (unformat (i, "queue %d", &queue_id))
5890 else if (unformat (i, "polling"))
5891 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5892 else if (unformat (i, "interrupt"))
5893 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5894 else if (unformat (i, "adaptive"))
5895 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5897 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5898 sw_if_index_set = 1;
5899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5900 sw_if_index_set = 1;
5905 if (sw_if_index_set == 0)
5907 errmsg ("missing interface name or sw_if_index");
5910 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5912 errmsg ("missing rx-mode");
5916 /* Construct the API message */
5917 M (SW_INTERFACE_SET_RX_MODE, mp);
5918 mp->sw_if_index = ntohl (sw_if_index);
5919 mp->mode = (vl_api_rx_mode_t) mode;
5920 mp->queue_id_valid = queue_id_valid;
5921 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5926 /* Wait for a reply, return the good/bad news... */
5932 api_sw_interface_set_rx_placement (vat_main_t * vam)
5934 unformat_input_t *i = vam->input;
5935 vl_api_sw_interface_set_rx_placement_t *mp;
5937 u8 sw_if_index_set = 0;
5940 u32 queue_id, thread_index;
5942 /* Parse args required to build the message */
5943 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5945 if (unformat (i, "queue %d", &queue_id))
5947 else if (unformat (i, "main"))
5949 else if (unformat (i, "worker %d", &thread_index))
5952 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5953 sw_if_index_set = 1;
5954 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5955 sw_if_index_set = 1;
5960 if (sw_if_index_set == 0)
5962 errmsg ("missing interface name or sw_if_index");
5968 /* Construct the API message */
5969 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5970 mp->sw_if_index = ntohl (sw_if_index);
5971 mp->worker_id = ntohl (thread_index);
5972 mp->queue_id = ntohl (queue_id);
5973 mp->is_main = is_main;
5977 /* Wait for a reply, return the good/bad news... */
5982 static void vl_api_sw_interface_rx_placement_details_t_handler
5983 (vl_api_sw_interface_rx_placement_details_t * mp)
5985 vat_main_t *vam = &vat_main;
5986 u32 worker_id = ntohl (mp->worker_id);
5989 "\n%-11d %-11s %-6d %-5d %-9s",
5990 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
5991 worker_id, ntohl (mp->queue_id),
5993 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
5996 static void vl_api_sw_interface_rx_placement_details_t_handler_json
5997 (vl_api_sw_interface_rx_placement_details_t * mp)
5999 vat_main_t *vam = &vat_main;
6000 vat_json_node_t *node = NULL;
6002 if (VAT_JSON_ARRAY != vam->json_tree.type)
6004 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6005 vat_json_init_array (&vam->json_tree);
6007 node = vat_json_array_add (&vam->json_tree);
6009 vat_json_init_object (node);
6010 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6011 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6012 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6013 vat_json_object_add_uint (node, "mode", mp->mode);
6017 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6019 unformat_input_t *i = vam->input;
6020 vl_api_sw_interface_rx_placement_dump_t *mp;
6021 vl_api_control_ping_t *mp_ping;
6024 u8 sw_if_index_set = 0;
6026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6037 "\n%-11s %-11s %-6s %-5s %-4s",
6038 "sw_if_index", "main/worker", "thread", "queue", "mode");
6040 /* Dump Interface rx placement */
6041 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6043 if (sw_if_index_set)
6044 mp->sw_if_index = htonl (sw_if_index);
6046 mp->sw_if_index = ~0;
6050 /* Use a control ping for synchronization */
6051 MPING (CONTROL_PING, mp_ping);
6059 api_sw_interface_clear_stats (vat_main_t * vam)
6061 unformat_input_t *i = vam->input;
6062 vl_api_sw_interface_clear_stats_t *mp;
6064 u8 sw_if_index_set = 0;
6067 /* Parse args required to build the message */
6068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6070 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6071 sw_if_index_set = 1;
6072 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6073 sw_if_index_set = 1;
6078 /* Construct the API message */
6079 M (SW_INTERFACE_CLEAR_STATS, mp);
6081 if (sw_if_index_set == 1)
6082 mp->sw_if_index = ntohl (sw_if_index);
6084 mp->sw_if_index = ~0;
6089 /* Wait for a reply, return the good/bad news... */
6095 api_sw_interface_add_del_address (vat_main_t * vam)
6097 unformat_input_t *i = vam->input;
6098 vl_api_sw_interface_add_del_address_t *mp;
6100 u8 sw_if_index_set = 0;
6101 u8 is_add = 1, del_all = 0;
6102 u32 address_length = 0;
6103 u8 v4_address_set = 0;
6104 u8 v6_address_set = 0;
6105 ip4_address_t v4address;
6106 ip6_address_t v6address;
6109 /* Parse args required to build the message */
6110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6112 if (unformat (i, "del-all"))
6114 else if (unformat (i, "del"))
6117 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6118 sw_if_index_set = 1;
6119 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6120 sw_if_index_set = 1;
6121 else if (unformat (i, "%U/%d",
6122 unformat_ip4_address, &v4address, &address_length))
6124 else if (unformat (i, "%U/%d",
6125 unformat_ip6_address, &v6address, &address_length))
6131 if (sw_if_index_set == 0)
6133 errmsg ("missing interface name or sw_if_index");
6136 if (v4_address_set && v6_address_set)
6138 errmsg ("both v4 and v6 addresses set");
6141 if (!v4_address_set && !v6_address_set && !del_all)
6143 errmsg ("no addresses set");
6147 /* Construct the API message */
6148 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6150 mp->sw_if_index = ntohl (sw_if_index);
6151 mp->is_add = is_add;
6152 mp->del_all = del_all;
6155 mp->prefix.address.af = ADDRESS_IP6;
6156 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6160 mp->prefix.address.af = ADDRESS_IP4;
6161 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6163 mp->prefix.len = address_length;
6168 /* Wait for a reply, return good/bad news */
6174 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6176 unformat_input_t *i = vam->input;
6177 vl_api_sw_interface_set_mpls_enable_t *mp;
6179 u8 sw_if_index_set = 0;
6183 /* Parse args required to build the message */
6184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6186 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6187 sw_if_index_set = 1;
6188 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6189 sw_if_index_set = 1;
6190 else if (unformat (i, "disable"))
6192 else if (unformat (i, "dis"))
6198 if (sw_if_index_set == 0)
6200 errmsg ("missing interface name or sw_if_index");
6204 /* Construct the API message */
6205 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6207 mp->sw_if_index = ntohl (sw_if_index);
6208 mp->enable = enable;
6213 /* Wait for a reply... */
6219 api_sw_interface_set_table (vat_main_t * vam)
6221 unformat_input_t *i = vam->input;
6222 vl_api_sw_interface_set_table_t *mp;
6223 u32 sw_if_index, vrf_id = 0;
6224 u8 sw_if_index_set = 0;
6228 /* Parse args required to build the message */
6229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6231 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6232 sw_if_index_set = 1;
6233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6234 sw_if_index_set = 1;
6235 else if (unformat (i, "vrf %d", &vrf_id))
6237 else if (unformat (i, "ipv6"))
6243 if (sw_if_index_set == 0)
6245 errmsg ("missing interface name or sw_if_index");
6249 /* Construct the API message */
6250 M (SW_INTERFACE_SET_TABLE, mp);
6252 mp->sw_if_index = ntohl (sw_if_index);
6253 mp->is_ipv6 = is_ipv6;
6254 mp->vrf_id = ntohl (vrf_id);
6259 /* Wait for a reply... */
6264 static void vl_api_sw_interface_get_table_reply_t_handler
6265 (vl_api_sw_interface_get_table_reply_t * mp)
6267 vat_main_t *vam = &vat_main;
6269 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6271 vam->retval = ntohl (mp->retval);
6272 vam->result_ready = 1;
6276 static void vl_api_sw_interface_get_table_reply_t_handler_json
6277 (vl_api_sw_interface_get_table_reply_t * mp)
6279 vat_main_t *vam = &vat_main;
6280 vat_json_node_t node;
6282 vat_json_init_object (&node);
6283 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6284 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6286 vat_json_print (vam->ofp, &node);
6287 vat_json_free (&node);
6289 vam->retval = ntohl (mp->retval);
6290 vam->result_ready = 1;
6294 api_sw_interface_get_table (vat_main_t * vam)
6296 unformat_input_t *i = vam->input;
6297 vl_api_sw_interface_get_table_t *mp;
6299 u8 sw_if_index_set = 0;
6303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6306 sw_if_index_set = 1;
6307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6308 sw_if_index_set = 1;
6309 else if (unformat (i, "ipv6"))
6315 if (sw_if_index_set == 0)
6317 errmsg ("missing interface name or sw_if_index");
6321 M (SW_INTERFACE_GET_TABLE, mp);
6322 mp->sw_if_index = htonl (sw_if_index);
6323 mp->is_ipv6 = is_ipv6;
6331 api_sw_interface_set_vpath (vat_main_t * vam)
6333 unformat_input_t *i = vam->input;
6334 vl_api_sw_interface_set_vpath_t *mp;
6335 u32 sw_if_index = 0;
6336 u8 sw_if_index_set = 0;
6340 /* Parse args required to build the message */
6341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6343 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6344 sw_if_index_set = 1;
6345 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6346 sw_if_index_set = 1;
6347 else if (unformat (i, "enable"))
6349 else if (unformat (i, "disable"))
6355 if (sw_if_index_set == 0)
6357 errmsg ("missing interface name or sw_if_index");
6361 /* Construct the API message */
6362 M (SW_INTERFACE_SET_VPATH, mp);
6364 mp->sw_if_index = ntohl (sw_if_index);
6365 mp->enable = is_enable;
6370 /* Wait for a reply... */
6376 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6378 unformat_input_t *i = vam->input;
6379 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6380 u32 sw_if_index = 0;
6381 u8 sw_if_index_set = 0;
6386 /* Parse args required to build the message */
6387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6390 sw_if_index_set = 1;
6391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6392 sw_if_index_set = 1;
6393 else if (unformat (i, "enable"))
6395 else if (unformat (i, "disable"))
6397 else if (unformat (i, "ip4"))
6399 else if (unformat (i, "ip6"))
6405 if (sw_if_index_set == 0)
6407 errmsg ("missing interface name or sw_if_index");
6411 /* Construct the API message */
6412 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6414 mp->sw_if_index = ntohl (sw_if_index);
6415 mp->enable = is_enable;
6416 mp->is_ipv6 = is_ipv6;
6421 /* Wait for a reply... */
6427 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6429 unformat_input_t *i = vam->input;
6430 vl_api_sw_interface_set_geneve_bypass_t *mp;
6431 u32 sw_if_index = 0;
6432 u8 sw_if_index_set = 0;
6437 /* Parse args required to build the message */
6438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6440 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6441 sw_if_index_set = 1;
6442 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6443 sw_if_index_set = 1;
6444 else if (unformat (i, "enable"))
6446 else if (unformat (i, "disable"))
6448 else if (unformat (i, "ip4"))
6450 else if (unformat (i, "ip6"))
6456 if (sw_if_index_set == 0)
6458 errmsg ("missing interface name or sw_if_index");
6462 /* Construct the API message */
6463 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6465 mp->sw_if_index = ntohl (sw_if_index);
6466 mp->enable = is_enable;
6467 mp->is_ipv6 = is_ipv6;
6472 /* Wait for a reply... */
6478 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6480 unformat_input_t *i = vam->input;
6481 vl_api_sw_interface_set_l2_xconnect_t *mp;
6483 u8 rx_sw_if_index_set = 0;
6485 u8 tx_sw_if_index_set = 0;
6489 /* Parse args required to build the message */
6490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6492 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6493 rx_sw_if_index_set = 1;
6494 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6495 tx_sw_if_index_set = 1;
6496 else if (unformat (i, "rx"))
6498 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6500 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6502 rx_sw_if_index_set = 1;
6507 else if (unformat (i, "tx"))
6509 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6511 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6513 tx_sw_if_index_set = 1;
6518 else if (unformat (i, "enable"))
6520 else if (unformat (i, "disable"))
6526 if (rx_sw_if_index_set == 0)
6528 errmsg ("missing rx interface name or rx_sw_if_index");
6532 if (enable && (tx_sw_if_index_set == 0))
6534 errmsg ("missing tx interface name or tx_sw_if_index");
6538 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6540 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6541 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6542 mp->enable = enable;
6550 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6552 unformat_input_t *i = vam->input;
6553 vl_api_sw_interface_set_l2_bridge_t *mp;
6554 vl_api_l2_port_type_t port_type;
6556 u8 rx_sw_if_index_set = 0;
6563 port_type = L2_API_PORT_TYPE_NORMAL;
6565 /* Parse args required to build the message */
6566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6568 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6569 rx_sw_if_index_set = 1;
6570 else if (unformat (i, "bd_id %d", &bd_id))
6574 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6575 rx_sw_if_index_set = 1;
6576 else if (unformat (i, "shg %d", &shg))
6578 else if (unformat (i, "bvi"))
6579 port_type = L2_API_PORT_TYPE_BVI;
6580 else if (unformat (i, "uu-fwd"))
6581 port_type = L2_API_PORT_TYPE_UU_FWD;
6582 else if (unformat (i, "enable"))
6584 else if (unformat (i, "disable"))
6590 if (rx_sw_if_index_set == 0)
6592 errmsg ("missing rx interface name or sw_if_index");
6596 if (enable && (bd_id_set == 0))
6598 errmsg ("missing bridge domain");
6602 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6604 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6605 mp->bd_id = ntohl (bd_id);
6607 mp->port_type = ntohl (port_type);
6608 mp->enable = enable;
6616 api_bridge_domain_dump (vat_main_t * vam)
6618 unformat_input_t *i = vam->input;
6619 vl_api_bridge_domain_dump_t *mp;
6620 vl_api_control_ping_t *mp_ping;
6624 /* Parse args required to build the message */
6625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6627 if (unformat (i, "bd_id %d", &bd_id))
6633 M (BRIDGE_DOMAIN_DUMP, mp);
6634 mp->bd_id = ntohl (bd_id);
6637 /* Use a control ping for synchronization */
6638 MPING (CONTROL_PING, mp_ping);
6646 api_bridge_domain_add_del (vat_main_t * vam)
6648 unformat_input_t *i = vam->input;
6649 vl_api_bridge_domain_add_del_t *mp;
6652 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6657 /* Parse args required to build the message */
6658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6660 if (unformat (i, "bd_id %d", &bd_id))
6662 else if (unformat (i, "flood %d", &flood))
6664 else if (unformat (i, "uu-flood %d", &uu_flood))
6666 else if (unformat (i, "forward %d", &forward))
6668 else if (unformat (i, "learn %d", &learn))
6670 else if (unformat (i, "arp-term %d", &arp_term))
6672 else if (unformat (i, "mac-age %d", &mac_age))
6674 else if (unformat (i, "bd-tag %s", &bd_tag))
6676 else if (unformat (i, "del"))
6679 flood = uu_flood = forward = learn = 0;
6687 errmsg ("missing bridge domain");
6694 errmsg ("mac age must be less than 256 ");
6699 if ((bd_tag) && (vec_len (bd_tag) > 63))
6701 errmsg ("bd-tag cannot be longer than 63");
6706 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6708 mp->bd_id = ntohl (bd_id);
6710 mp->uu_flood = uu_flood;
6711 mp->forward = forward;
6713 mp->arp_term = arp_term;
6714 mp->is_add = is_add;
6715 mp->mac_age = (u8) mac_age;
6718 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6719 mp->bd_tag[vec_len (bd_tag)] = 0;
6730 api_l2fib_flush_bd (vat_main_t * vam)
6732 unformat_input_t *i = vam->input;
6733 vl_api_l2fib_flush_bd_t *mp;
6737 /* Parse args required to build the message */
6738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6740 if (unformat (i, "bd_id %d", &bd_id));
6747 errmsg ("missing bridge domain");
6751 M (L2FIB_FLUSH_BD, mp);
6753 mp->bd_id = htonl (bd_id);
6761 api_l2fib_flush_int (vat_main_t * vam)
6763 unformat_input_t *i = vam->input;
6764 vl_api_l2fib_flush_int_t *mp;
6765 u32 sw_if_index = ~0;
6768 /* Parse args required to build the message */
6769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6771 if (unformat (i, "sw_if_index %d", &sw_if_index));
6773 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6778 if (sw_if_index == ~0)
6780 errmsg ("missing interface name or sw_if_index");
6784 M (L2FIB_FLUSH_INT, mp);
6786 mp->sw_if_index = ntohl (sw_if_index);
6794 api_l2fib_add_del (vat_main_t * vam)
6796 unformat_input_t *i = vam->input;
6797 vl_api_l2fib_add_del_t *mp;
6803 u32 sw_if_index = 0;
6804 u8 sw_if_index_set = 0;
6813 /* Parse args required to build the message */
6814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6816 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6818 else if (unformat (i, "bd_id %d", &bd_id))
6820 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6821 sw_if_index_set = 1;
6822 else if (unformat (i, "sw_if"))
6824 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6827 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6828 sw_if_index_set = 1;
6833 else if (unformat (i, "static"))
6835 else if (unformat (i, "filter"))
6840 else if (unformat (i, "bvi"))
6845 else if (unformat (i, "del"))
6847 else if (unformat (i, "count %d", &count))
6855 errmsg ("missing mac address");
6861 errmsg ("missing bridge domain");
6865 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6867 errmsg ("missing interface name or sw_if_index");
6873 /* Turn on async mode */
6874 vam->async_mode = 1;
6875 vam->async_errors = 0;
6876 before = vat_time_now (vam);
6879 for (j = 0; j < count; j++)
6881 M (L2FIB_ADD_DEL, mp);
6883 clib_memcpy (mp->mac, mac, 6);
6884 mp->bd_id = ntohl (bd_id);
6885 mp->is_add = is_add;
6886 mp->sw_if_index = ntohl (sw_if_index);
6890 mp->static_mac = static_mac;
6891 mp->filter_mac = filter_mac;
6892 mp->bvi_mac = bvi_mac;
6894 increment_mac_address (mac);
6901 vl_api_control_ping_t *mp_ping;
6904 /* Shut off async mode */
6905 vam->async_mode = 0;
6907 MPING (CONTROL_PING, mp_ping);
6910 timeout = vat_time_now (vam) + 1.0;
6911 while (vat_time_now (vam) < timeout)
6912 if (vam->result_ready == 1)
6917 if (vam->retval == -99)
6920 if (vam->async_errors > 0)
6922 errmsg ("%d asynchronous errors", vam->async_errors);
6925 vam->async_errors = 0;
6926 after = vat_time_now (vam);
6928 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6929 count, after - before, count / (after - before));
6935 /* Wait for a reply... */
6939 /* Return the good/bad news */
6940 return (vam->retval);
6944 api_bridge_domain_set_mac_age (vat_main_t * vam)
6946 unformat_input_t *i = vam->input;
6947 vl_api_bridge_domain_set_mac_age_t *mp;
6952 /* Parse args required to build the message */
6953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6955 if (unformat (i, "bd_id %d", &bd_id));
6956 else if (unformat (i, "mac-age %d", &mac_age));
6963 errmsg ("missing bridge domain");
6969 errmsg ("mac age must be less than 256 ");
6973 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6975 mp->bd_id = htonl (bd_id);
6976 mp->mac_age = (u8) mac_age;
6984 api_l2_flags (vat_main_t * vam)
6986 unformat_input_t *i = vam->input;
6987 vl_api_l2_flags_t *mp;
6990 u8 sw_if_index_set = 0;
6994 /* Parse args required to build the message */
6995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6997 if (unformat (i, "sw_if_index %d", &sw_if_index))
6998 sw_if_index_set = 1;
6999 else if (unformat (i, "sw_if"))
7001 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7004 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7005 sw_if_index_set = 1;
7010 else if (unformat (i, "learn"))
7012 else if (unformat (i, "forward"))
7014 else if (unformat (i, "flood"))
7016 else if (unformat (i, "uu-flood"))
7017 flags |= L2_UU_FLOOD;
7018 else if (unformat (i, "arp-term"))
7019 flags |= L2_ARP_TERM;
7020 else if (unformat (i, "off"))
7022 else if (unformat (i, "disable"))
7028 if (sw_if_index_set == 0)
7030 errmsg ("missing interface name or sw_if_index");
7036 mp->sw_if_index = ntohl (sw_if_index);
7037 mp->feature_bitmap = ntohl (flags);
7038 mp->is_set = is_set;
7046 api_bridge_flags (vat_main_t * vam)
7048 unformat_input_t *i = vam->input;
7049 vl_api_bridge_flags_t *mp;
7053 bd_flags_t flags = 0;
7056 /* Parse args required to build the message */
7057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7059 if (unformat (i, "bd_id %d", &bd_id))
7061 else if (unformat (i, "learn"))
7062 flags |= BRIDGE_API_FLAG_LEARN;
7063 else if (unformat (i, "forward"))
7064 flags |= BRIDGE_API_FLAG_FWD;
7065 else if (unformat (i, "flood"))
7066 flags |= BRIDGE_API_FLAG_FLOOD;
7067 else if (unformat (i, "uu-flood"))
7068 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7069 else if (unformat (i, "arp-term"))
7070 flags |= BRIDGE_API_FLAG_ARP_TERM;
7071 else if (unformat (i, "off"))
7073 else if (unformat (i, "disable"))
7081 errmsg ("missing bridge domain");
7085 M (BRIDGE_FLAGS, mp);
7087 mp->bd_id = ntohl (bd_id);
7088 mp->flags = ntohl (flags);
7089 mp->is_set = is_set;
7097 api_bd_ip_mac_add_del (vat_main_t * vam)
7099 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7100 vl_api_mac_address_t mac = { 0 };
7101 unformat_input_t *i = vam->input;
7102 vl_api_bd_ip_mac_add_del_t *mp;
7111 /* Parse args required to build the message */
7112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7114 if (unformat (i, "bd_id %d", &bd_id))
7118 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7122 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7126 else if (unformat (i, "del"))
7134 errmsg ("missing bridge domain");
7137 else if (ip_set == 0)
7139 errmsg ("missing IP address");
7142 else if (mac_set == 0)
7144 errmsg ("missing MAC address");
7148 M (BD_IP_MAC_ADD_DEL, mp);
7150 mp->entry.bd_id = ntohl (bd_id);
7151 mp->is_add = is_add;
7153 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7154 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7162 api_bd_ip_mac_flush (vat_main_t * vam)
7164 unformat_input_t *i = vam->input;
7165 vl_api_bd_ip_mac_flush_t *mp;
7170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 if (unformat (i, "bd_id %d", &bd_id))
7182 errmsg ("missing bridge domain");
7186 M (BD_IP_MAC_FLUSH, mp);
7188 mp->bd_id = ntohl (bd_id);
7195 static void vl_api_bd_ip_mac_details_t_handler
7196 (vl_api_bd_ip_mac_details_t * mp)
7198 vat_main_t *vam = &vat_main;
7202 ntohl (mp->entry.bd_id),
7203 format_vl_api_mac_address, mp->entry.mac,
7204 format_vl_api_address, &mp->entry.ip);
7207 static void vl_api_bd_ip_mac_details_t_handler_json
7208 (vl_api_bd_ip_mac_details_t * mp)
7210 vat_main_t *vam = &vat_main;
7211 vat_json_node_t *node = NULL;
7213 if (VAT_JSON_ARRAY != vam->json_tree.type)
7215 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7216 vat_json_init_array (&vam->json_tree);
7218 node = vat_json_array_add (&vam->json_tree);
7220 vat_json_init_object (node);
7221 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7222 vat_json_object_add_string_copy (node, "mac_address",
7223 format (0, "%U", format_vl_api_mac_address,
7227 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7228 vat_json_object_add_string_copy (node, "ip_address", ip);
7233 api_bd_ip_mac_dump (vat_main_t * vam)
7235 unformat_input_t *i = vam->input;
7236 vl_api_bd_ip_mac_dump_t *mp;
7237 vl_api_control_ping_t *mp_ping;
7242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7244 if (unformat (i, "bd_id %d", &bd_id))
7253 "\n%-5s %-7s %-20s %-30s",
7254 "bd_id", "is_ipv6", "mac_address", "ip_address");
7256 /* Dump Bridge Domain Ip to Mac entries */
7257 M (BD_IP_MAC_DUMP, mp);
7260 mp->bd_id = htonl (bd_id);
7266 /* Use a control ping for synchronization */
7267 MPING (CONTROL_PING, mp_ping);
7275 api_tap_create_v2 (vat_main_t * vam)
7277 unformat_input_t *i = vam->input;
7278 vl_api_tap_create_v2_t *mp;
7279 #define TAP_FLAG_GSO (1 << 0)
7283 u8 *host_if_name = 0;
7285 u8 host_mac_addr[6];
7286 u8 host_mac_addr_set = 0;
7287 u8 *host_bridge = 0;
7288 ip4_address_t host_ip4_addr;
7289 ip4_address_t host_ip4_gw;
7290 u8 host_ip4_gw_set = 0;
7291 u32 host_ip4_prefix_len = 0;
7292 ip6_address_t host_ip6_addr;
7293 ip6_address_t host_ip6_gw;
7294 u8 host_ip6_gw_set = 0;
7295 u32 host_ip6_prefix_len = 0;
7296 u8 host_mtu_set = 0;
7297 u32 host_mtu_size = 0;
7300 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7302 clib_memset (mac_address, 0, sizeof (mac_address));
7304 /* Parse args required to build the message */
7305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7307 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7311 else if (unformat (i, "id %u", &id))
7313 else if (unformat (i, "host-if-name %s", &host_if_name))
7315 else if (unformat (i, "host-ns %s", &host_ns))
7317 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7319 host_mac_addr_set = 1;
7320 else if (unformat (i, "host-bridge %s", &host_bridge))
7322 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7323 &host_ip4_addr, &host_ip4_prefix_len))
7325 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7326 &host_ip6_addr, &host_ip6_prefix_len))
7328 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7330 host_ip4_gw_set = 1;
7331 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7333 host_ip6_gw_set = 1;
7334 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7336 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7338 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7340 else if (unformat (i, "no-gso"))
7341 tap_flags &= ~TAP_FLAG_GSO;
7342 else if (unformat (i, "gso"))
7343 tap_flags |= TAP_FLAG_GSO;
7348 if (vec_len (host_if_name) > 63)
7350 errmsg ("tap name too long. ");
7353 if (vec_len (host_ns) > 63)
7355 errmsg ("host name space too long. ");
7358 if (vec_len (host_bridge) > 63)
7360 errmsg ("host bridge name too long. ");
7363 if (host_ip4_prefix_len > 32)
7365 errmsg ("host ip4 prefix length not valid. ");
7368 if (host_ip6_prefix_len > 128)
7370 errmsg ("host ip6 prefix length not valid. ");
7373 if (!is_pow2 (rx_ring_sz))
7375 errmsg ("rx ring size must be power of 2. ");
7378 if (rx_ring_sz > 32768)
7380 errmsg ("rx ring size must be 32768 or lower. ");
7383 if (!is_pow2 (tx_ring_sz))
7385 errmsg ("tx ring size must be power of 2. ");
7388 if (tx_ring_sz > 32768)
7390 errmsg ("tx ring size must be 32768 or lower. ");
7393 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7395 errmsg ("host MTU size must be in between 64 and 65355. ");
7399 /* Construct the API message */
7400 M (TAP_CREATE_V2, mp);
7402 mp->use_random_mac = random_mac;
7404 mp->id = ntohl (id);
7405 mp->host_namespace_set = host_ns != 0;
7406 mp->host_bridge_set = host_bridge != 0;
7407 mp->host_ip4_prefix_set = host_ip4_prefix_len != 0;
7408 mp->host_ip6_prefix_set = host_ip6_prefix_len != 0;
7409 mp->rx_ring_sz = ntohs (rx_ring_sz);
7410 mp->tx_ring_sz = ntohs (tx_ring_sz);
7411 mp->host_mtu_set = host_mtu_set;
7412 mp->host_mtu_size = ntohl (host_mtu_size);
7413 mp->tap_flags = ntohl (tap_flags);
7415 if (random_mac == 0)
7416 clib_memcpy (mp->mac_address, mac_address, 6);
7417 if (host_mac_addr_set)
7418 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7420 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7422 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7424 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7425 if (host_ip4_prefix_len)
7426 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7427 if (host_ip6_prefix_len)
7428 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7429 if (host_ip4_gw_set)
7430 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7431 if (host_ip6_gw_set)
7432 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7435 vec_free (host_if_name);
7436 vec_free (host_bridge);
7441 /* Wait for a reply... */
7447 api_tap_delete_v2 (vat_main_t * vam)
7449 unformat_input_t *i = vam->input;
7450 vl_api_tap_delete_v2_t *mp;
7451 u32 sw_if_index = ~0;
7452 u8 sw_if_index_set = 0;
7455 /* Parse args required to build the message */
7456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7458 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7459 sw_if_index_set = 1;
7460 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7461 sw_if_index_set = 1;
7466 if (sw_if_index_set == 0)
7468 errmsg ("missing vpp interface name. ");
7472 /* Construct the API message */
7473 M (TAP_DELETE_V2, mp);
7475 mp->sw_if_index = ntohl (sw_if_index);
7480 /* Wait for a reply... */
7486 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7488 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7491 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7494 addr->domain = x[0];
7497 addr->function = x[3];
7503 api_virtio_pci_create (vat_main_t * vam)
7505 unformat_input_t *i = vam->input;
7506 vl_api_virtio_pci_create_t *mp;
7510 u8 checksum_offload_enabled = 0;
7512 u64 features = (u64) ~ (0ULL);
7515 clib_memset (mac_address, 0, sizeof (mac_address));
7517 /* Parse args required to build the message */
7518 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7520 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7524 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7526 else if (unformat (i, "features 0x%llx", &features))
7528 else if (unformat (i, "gso-enabled"))
7530 else if (unformat (i, "csum-offload-enabled"))
7531 checksum_offload_enabled = 1;
7538 errmsg ("pci address must be non zero. ");
7542 /* Construct the API message */
7543 M (VIRTIO_PCI_CREATE, mp);
7545 mp->use_random_mac = random_mac;
7547 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7548 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7549 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7550 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7552 mp->features = clib_host_to_net_u64 (features);
7553 mp->gso_enabled = gso_enabled;
7554 mp->checksum_offload_enabled = checksum_offload_enabled;
7556 if (random_mac == 0)
7557 clib_memcpy (mp->mac_address, mac_address, 6);
7562 /* Wait for a reply... */
7568 api_virtio_pci_delete (vat_main_t * vam)
7570 unformat_input_t *i = vam->input;
7571 vl_api_virtio_pci_delete_t *mp;
7572 u32 sw_if_index = ~0;
7573 u8 sw_if_index_set = 0;
7576 /* Parse args required to build the message */
7577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7579 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7580 sw_if_index_set = 1;
7581 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7582 sw_if_index_set = 1;
7587 if (sw_if_index_set == 0)
7589 errmsg ("missing vpp interface name. ");
7593 /* Construct the API message */
7594 M (VIRTIO_PCI_DELETE, mp);
7596 mp->sw_if_index = htonl (sw_if_index);
7601 /* Wait for a reply... */
7607 api_bond_create (vat_main_t * vam)
7609 unformat_input_t *i = vam->input;
7610 vl_api_bond_create_t *mp;
7620 clib_memset (mac_address, 0, sizeof (mac_address));
7623 /* Parse args required to build the message */
7624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7626 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7628 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7629 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7631 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7634 else if (unformat (i, "numa-only"))
7636 else if (unformat (i, "id %u", &id))
7642 if (mode_is_set == 0)
7644 errmsg ("Missing bond mode. ");
7648 /* Construct the API message */
7649 M (BOND_CREATE, mp);
7651 mp->use_custom_mac = custom_mac;
7653 mp->mode = htonl (mode);
7654 mp->lb = htonl (lb);
7655 mp->id = htonl (id);
7656 mp->numa_only = numa_only;
7659 clib_memcpy (mp->mac_address, mac_address, 6);
7664 /* Wait for a reply... */
7670 api_bond_delete (vat_main_t * vam)
7672 unformat_input_t *i = vam->input;
7673 vl_api_bond_delete_t *mp;
7674 u32 sw_if_index = ~0;
7675 u8 sw_if_index_set = 0;
7678 /* Parse args required to build the message */
7679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7681 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7682 sw_if_index_set = 1;
7683 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7684 sw_if_index_set = 1;
7689 if (sw_if_index_set == 0)
7691 errmsg ("missing vpp interface name. ");
7695 /* Construct the API message */
7696 M (BOND_DELETE, mp);
7698 mp->sw_if_index = ntohl (sw_if_index);
7703 /* Wait for a reply... */
7709 api_bond_enslave (vat_main_t * vam)
7711 unformat_input_t *i = vam->input;
7712 vl_api_bond_enslave_t *mp;
7713 u32 bond_sw_if_index;
7717 u32 bond_sw_if_index_is_set = 0;
7719 u8 sw_if_index_is_set = 0;
7721 /* Parse args required to build the message */
7722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7724 if (unformat (i, "sw_if_index %d", &sw_if_index))
7725 sw_if_index_is_set = 1;
7726 else if (unformat (i, "bond %u", &bond_sw_if_index))
7727 bond_sw_if_index_is_set = 1;
7728 else if (unformat (i, "passive %d", &is_passive))
7730 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7736 if (bond_sw_if_index_is_set == 0)
7738 errmsg ("Missing bond sw_if_index. ");
7741 if (sw_if_index_is_set == 0)
7743 errmsg ("Missing slave sw_if_index. ");
7747 /* Construct the API message */
7748 M (BOND_ENSLAVE, mp);
7750 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7751 mp->sw_if_index = ntohl (sw_if_index);
7752 mp->is_long_timeout = is_long_timeout;
7753 mp->is_passive = is_passive;
7758 /* Wait for a reply... */
7764 api_bond_detach_slave (vat_main_t * vam)
7766 unformat_input_t *i = vam->input;
7767 vl_api_bond_detach_slave_t *mp;
7768 u32 sw_if_index = ~0;
7769 u8 sw_if_index_set = 0;
7772 /* Parse args required to build the message */
7773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7775 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7776 sw_if_index_set = 1;
7777 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7778 sw_if_index_set = 1;
7783 if (sw_if_index_set == 0)
7785 errmsg ("missing vpp interface name. ");
7789 /* Construct the API message */
7790 M (BOND_DETACH_SLAVE, mp);
7792 mp->sw_if_index = ntohl (sw_if_index);
7797 /* Wait for a reply... */
7803 api_ip_table_add_del (vat_main_t * vam)
7805 unformat_input_t *i = vam->input;
7806 vl_api_ip_table_add_del_t *mp;
7812 /* Parse args required to build the message */
7813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7815 if (unformat (i, "ipv6"))
7817 else if (unformat (i, "del"))
7819 else if (unformat (i, "add"))
7821 else if (unformat (i, "table %d", &table_id))
7825 clib_warning ("parse error '%U'", format_unformat_error, i);
7832 errmsg ("missing table-ID");
7836 /* Construct the API message */
7837 M (IP_TABLE_ADD_DEL, mp);
7839 mp->table.table_id = ntohl (table_id);
7840 mp->table.is_ip6 = is_ipv6;
7841 mp->is_add = is_add;
7846 /* Wait for a reply... */
7853 unformat_fib_path (unformat_input_t * input, va_list * args)
7855 vat_main_t *vam = va_arg (*args, vat_main_t *);
7856 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7857 u32 weight, preference;
7858 mpls_label_t out_label;
7860 clib_memset (path, 0, sizeof (*path));
7862 path->sw_if_index = ~0;
7866 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7868 if (unformat (input, "%U %U",
7869 unformat_vl_api_ip4_address,
7870 &path->nh.address.ip4,
7871 api_unformat_sw_if_index, vam, &path->sw_if_index))
7873 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7875 else if (unformat (input, "%U %U",
7876 unformat_vl_api_ip6_address,
7877 &path->nh.address.ip6,
7878 api_unformat_sw_if_index, vam, &path->sw_if_index))
7880 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7882 else if (unformat (input, "weight %u", &weight))
7884 path->weight = weight;
7886 else if (unformat (input, "preference %u", &preference))
7888 path->preference = preference;
7890 else if (unformat (input, "%U next-hop-table %d",
7891 unformat_vl_api_ip4_address,
7892 &path->nh.address.ip4, &path->table_id))
7894 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7896 else if (unformat (input, "%U next-hop-table %d",
7897 unformat_vl_api_ip6_address,
7898 &path->nh.address.ip6, &path->table_id))
7900 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7902 else if (unformat (input, "%U",
7903 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7906 * the recursive next-hops are by default in the default table
7909 path->sw_if_index = ~0;
7910 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7912 else if (unformat (input, "%U",
7913 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7916 * the recursive next-hops are by default in the default table
7919 path->sw_if_index = ~0;
7920 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7922 else if (unformat (input, "resolve-via-host"))
7924 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7926 else if (unformat (input, "resolve-via-attached"))
7928 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7930 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7932 path->type = FIB_API_PATH_TYPE_LOCAL;
7933 path->sw_if_index = ~0;
7934 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7936 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7938 path->type = FIB_API_PATH_TYPE_LOCAL;
7939 path->sw_if_index = ~0;
7940 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7942 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7944 else if (unformat (input, "via-label %d", &path->nh.via_label))
7946 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7947 path->sw_if_index = ~0;
7949 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7951 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7952 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7954 else if (unformat (input, "local"))
7956 path->type = FIB_API_PATH_TYPE_LOCAL;
7958 else if (unformat (input, "out-labels"))
7960 while (unformat (input, "%d", &out_label))
7962 path->label_stack[path->n_labels].label = out_label;
7963 path->label_stack[path->n_labels].is_uniform = 0;
7964 path->label_stack[path->n_labels].ttl = 64;
7968 else if (unformat (input, "via"))
7970 /* new path, back up and return */
7971 unformat_put_input (input);
7972 unformat_put_input (input);
7973 unformat_put_input (input);
7974 unformat_put_input (input);
7983 path->proto = ntohl (path->proto);
7984 path->type = ntohl (path->type);
7985 path->flags = ntohl (path->flags);
7986 path->table_id = ntohl (path->table_id);
7987 path->sw_if_index = ntohl (path->sw_if_index);
7993 api_ip_route_add_del (vat_main_t * vam)
7995 unformat_input_t *i = vam->input;
7996 vl_api_ip_route_add_del_t *mp;
7999 u8 is_multipath = 0;
8002 vl_api_prefix_t pfx = { };
8003 vl_api_fib_path_t paths[8];
8007 u32 random_add_del = 0;
8008 u32 *random_vector = 0;
8009 u32 random_seed = 0xdeaddabe;
8011 /* Parse args required to build the message */
8012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8014 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8016 else if (unformat (i, "del"))
8018 else if (unformat (i, "add"))
8020 else if (unformat (i, "vrf %d", &vrf_id))
8022 else if (unformat (i, "count %d", &count))
8024 else if (unformat (i, "random"))
8026 else if (unformat (i, "multipath"))
8028 else if (unformat (i, "seed %d", &random_seed))
8032 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8035 if (8 == path_count)
8037 errmsg ("max 8 paths");
8043 clib_warning ("parse error '%U'", format_unformat_error, i);
8050 errmsg ("specify a path; via ...");
8053 if (prefix_set == 0)
8055 errmsg ("missing prefix");
8059 /* Generate a pile of unique, random routes */
8062 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8063 u32 this_random_address;
8066 random_hash = hash_create (count, sizeof (uword));
8068 hash_set (random_hash, i->as_u32, 1);
8069 for (j = 0; j <= count; j++)
8073 this_random_address = random_u32 (&random_seed);
8074 this_random_address =
8075 clib_host_to_net_u32 (this_random_address);
8077 while (hash_get (random_hash, this_random_address));
8078 vec_add1 (random_vector, this_random_address);
8079 hash_set (random_hash, this_random_address, 1);
8081 hash_free (random_hash);
8082 set_ip4_address (&pfx.address, random_vector[0]);
8087 /* Turn on async mode */
8088 vam->async_mode = 1;
8089 vam->async_errors = 0;
8090 before = vat_time_now (vam);
8093 for (j = 0; j < count; j++)
8095 /* Construct the API message */
8096 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8098 mp->is_add = is_add;
8099 mp->is_multipath = is_multipath;
8101 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8102 mp->route.table_id = ntohl (vrf_id);
8103 mp->route.n_paths = path_count;
8105 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8108 set_ip4_address (&pfx.address, random_vector[j + 1]);
8110 increment_address (&pfx.address);
8113 /* If we receive SIGTERM, stop now... */
8118 /* When testing multiple add/del ops, use a control-ping to sync */
8121 vl_api_control_ping_t *mp_ping;
8125 /* Shut off async mode */
8126 vam->async_mode = 0;
8128 MPING (CONTROL_PING, mp_ping);
8131 timeout = vat_time_now (vam) + 1.0;
8132 while (vat_time_now (vam) < timeout)
8133 if (vam->result_ready == 1)
8138 if (vam->retval == -99)
8141 if (vam->async_errors > 0)
8143 errmsg ("%d asynchronous errors", vam->async_errors);
8146 vam->async_errors = 0;
8147 after = vat_time_now (vam);
8149 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8153 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8154 count, after - before, count / (after - before));
8160 /* Wait for a reply... */
8165 /* Return the good/bad news */
8166 return (vam->retval);
8170 api_ip_mroute_add_del (vat_main_t * vam)
8172 unformat_input_t *i = vam->input;
8173 u8 path_set = 0, prefix_set = 0, is_add = 1;
8174 vl_api_ip_mroute_add_del_t *mp;
8175 mfib_entry_flags_t eflags = 0;
8176 vl_api_mfib_path_t path;
8177 vl_api_mprefix_t pfx = { };
8181 /* Parse args required to build the message */
8182 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8184 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8187 pfx.grp_address_length = htons (pfx.grp_address_length);
8189 else if (unformat (i, "del"))
8191 else if (unformat (i, "add"))
8193 else if (unformat (i, "vrf %d", &vrf_id))
8195 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8196 path.itf_flags = htonl (path.itf_flags);
8197 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8199 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8203 clib_warning ("parse error '%U'", format_unformat_error, i);
8208 if (prefix_set == 0)
8210 errmsg ("missing addresses\n");
8215 errmsg ("missing path\n");
8219 /* Construct the API message */
8220 M (IP_MROUTE_ADD_DEL, mp);
8222 mp->is_add = is_add;
8223 mp->is_multipath = 1;
8225 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8226 mp->route.table_id = htonl (vrf_id);
8227 mp->route.n_paths = 1;
8228 mp->route.entry_flags = htonl (eflags);
8230 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8234 /* Wait for a reply... */
8240 api_mpls_table_add_del (vat_main_t * vam)
8242 unformat_input_t *i = vam->input;
8243 vl_api_mpls_table_add_del_t *mp;
8248 /* Parse args required to build the message */
8249 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8251 if (unformat (i, "table %d", &table_id))
8253 else if (unformat (i, "del"))
8255 else if (unformat (i, "add"))
8259 clib_warning ("parse error '%U'", format_unformat_error, i);
8266 errmsg ("missing table-ID");
8270 /* Construct the API message */
8271 M (MPLS_TABLE_ADD_DEL, mp);
8273 mp->mt_table.mt_table_id = ntohl (table_id);
8274 mp->mt_is_add = is_add;
8279 /* Wait for a reply... */
8286 api_mpls_route_add_del (vat_main_t * vam)
8288 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8289 mpls_label_t local_label = MPLS_LABEL_INVALID;
8290 unformat_input_t *i = vam->input;
8291 vl_api_mpls_route_add_del_t *mp;
8292 vl_api_fib_path_t paths[8];
8296 /* Parse args required to build the message */
8297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8299 if (unformat (i, "%d", &local_label))
8301 else if (unformat (i, "eos"))
8303 else if (unformat (i, "non-eos"))
8305 else if (unformat (i, "del"))
8307 else if (unformat (i, "add"))
8309 else if (unformat (i, "multipath"))
8311 else if (unformat (i, "count %d", &count))
8315 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8318 if (8 == path_count)
8320 errmsg ("max 8 paths");
8326 clib_warning ("parse error '%U'", format_unformat_error, i);
8333 errmsg ("specify a path; via ...");
8337 if (MPLS_LABEL_INVALID == local_label)
8339 errmsg ("missing label");
8345 /* Turn on async mode */
8346 vam->async_mode = 1;
8347 vam->async_errors = 0;
8348 before = vat_time_now (vam);
8351 for (j = 0; j < count; j++)
8353 /* Construct the API message */
8354 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8356 mp->mr_is_add = is_add;
8357 mp->mr_is_multipath = is_multipath;
8359 mp->mr_route.mr_label = local_label;
8360 mp->mr_route.mr_eos = is_eos;
8361 mp->mr_route.mr_table_id = 0;
8362 mp->mr_route.mr_n_paths = path_count;
8364 clib_memcpy (&mp->mr_route.mr_paths, paths,
8365 sizeof (paths[0]) * path_count);
8371 /* If we receive SIGTERM, stop now... */
8376 /* When testing multiple add/del ops, use a control-ping to sync */
8379 vl_api_control_ping_t *mp_ping;
8383 /* Shut off async mode */
8384 vam->async_mode = 0;
8386 MPING (CONTROL_PING, mp_ping);
8389 timeout = vat_time_now (vam) + 1.0;
8390 while (vat_time_now (vam) < timeout)
8391 if (vam->result_ready == 1)
8396 if (vam->retval == -99)
8399 if (vam->async_errors > 0)
8401 errmsg ("%d asynchronous errors", vam->async_errors);
8404 vam->async_errors = 0;
8405 after = vat_time_now (vam);
8407 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8411 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8412 count, after - before, count / (after - before));
8418 /* Wait for a reply... */
8423 /* Return the good/bad news */
8424 return (vam->retval);
8429 api_mpls_ip_bind_unbind (vat_main_t * vam)
8431 unformat_input_t *i = vam->input;
8432 vl_api_mpls_ip_bind_unbind_t *mp;
8433 u32 ip_table_id = 0;
8435 vl_api_prefix_t pfx;
8437 mpls_label_t local_label = MPLS_LABEL_INVALID;
8440 /* Parse args required to build the message */
8441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8443 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8445 else if (unformat (i, "%d", &local_label))
8447 else if (unformat (i, "table-id %d", &ip_table_id))
8449 else if (unformat (i, "unbind"))
8451 else if (unformat (i, "bind"))
8455 clib_warning ("parse error '%U'", format_unformat_error, i);
8462 errmsg ("IP prefix not set");
8466 if (MPLS_LABEL_INVALID == local_label)
8468 errmsg ("missing label");
8472 /* Construct the API message */
8473 M (MPLS_IP_BIND_UNBIND, mp);
8475 mp->mb_is_bind = is_bind;
8476 mp->mb_ip_table_id = ntohl (ip_table_id);
8477 mp->mb_mpls_table_id = 0;
8478 mp->mb_label = ntohl (local_label);
8479 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8484 /* Wait for a reply... */
8491 api_sr_mpls_policy_add (vat_main_t * vam)
8493 unformat_input_t *i = vam->input;
8494 vl_api_sr_mpls_policy_add_t *mp;
8500 u32 *segments = NULL;
8503 /* Parse args required to build the message */
8504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8506 if (unformat (i, "bsid %d", &bsid))
8508 else if (unformat (i, "weight %d", &weight))
8510 else if (unformat (i, "spray"))
8512 else if (unformat (i, "next %d", &sid))
8515 vec_add1 (segments, htonl (sid));
8519 clib_warning ("parse error '%U'", format_unformat_error, i);
8526 errmsg ("bsid not set");
8530 if (n_segments == 0)
8532 errmsg ("no sid in segment stack");
8536 /* Construct the API message */
8537 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8539 mp->bsid = htonl (bsid);
8540 mp->weight = htonl (weight);
8542 mp->n_segments = n_segments;
8543 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8544 vec_free (segments);
8549 /* Wait for a reply... */
8555 api_sr_mpls_policy_del (vat_main_t * vam)
8557 unformat_input_t *i = vam->input;
8558 vl_api_sr_mpls_policy_del_t *mp;
8562 /* Parse args required to build the message */
8563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8565 if (unformat (i, "bsid %d", &bsid))
8569 clib_warning ("parse error '%U'", format_unformat_error, i);
8576 errmsg ("bsid not set");
8580 /* Construct the API message */
8581 M (SR_MPLS_POLICY_DEL, mp);
8583 mp->bsid = htonl (bsid);
8588 /* Wait for a reply... */
8594 api_bier_table_add_del (vat_main_t * vam)
8596 unformat_input_t *i = vam->input;
8597 vl_api_bier_table_add_del_t *mp;
8599 u32 set = 0, sub_domain = 0, hdr_len = 3;
8600 mpls_label_t local_label = MPLS_LABEL_INVALID;
8603 /* Parse args required to build the message */
8604 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8606 if (unformat (i, "sub-domain %d", &sub_domain))
8608 else if (unformat (i, "set %d", &set))
8610 else if (unformat (i, "label %d", &local_label))
8612 else if (unformat (i, "hdr-len %d", &hdr_len))
8614 else if (unformat (i, "add"))
8616 else if (unformat (i, "del"))
8620 clib_warning ("parse error '%U'", format_unformat_error, i);
8625 if (MPLS_LABEL_INVALID == local_label)
8627 errmsg ("missing label\n");
8631 /* Construct the API message */
8632 M (BIER_TABLE_ADD_DEL, mp);
8634 mp->bt_is_add = is_add;
8635 mp->bt_label = ntohl (local_label);
8636 mp->bt_tbl_id.bt_set = set;
8637 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8638 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8643 /* Wait for a reply... */
8650 api_bier_route_add_del (vat_main_t * vam)
8652 unformat_input_t *i = vam->input;
8653 vl_api_bier_route_add_del_t *mp;
8655 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8656 ip4_address_t v4_next_hop_address;
8657 ip6_address_t v6_next_hop_address;
8658 u8 next_hop_set = 0;
8659 u8 next_hop_proto_is_ip4 = 1;
8660 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8663 /* Parse args required to build the message */
8664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8666 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8668 next_hop_proto_is_ip4 = 1;
8671 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8673 next_hop_proto_is_ip4 = 0;
8676 if (unformat (i, "sub-domain %d", &sub_domain))
8678 else if (unformat (i, "set %d", &set))
8680 else if (unformat (i, "hdr-len %d", &hdr_len))
8682 else if (unformat (i, "bp %d", &bp))
8684 else if (unformat (i, "add"))
8686 else if (unformat (i, "del"))
8688 else if (unformat (i, "out-label %d", &next_hop_out_label))
8692 clib_warning ("parse error '%U'", format_unformat_error, i);
8697 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8699 errmsg ("next hop / label set\n");
8704 errmsg ("bit=position not set\n");
8708 /* Construct the API message */
8709 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8711 mp->br_is_add = is_add;
8712 mp->br_route.br_tbl_id.bt_set = set;
8713 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8714 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8715 mp->br_route.br_bp = ntohs (bp);
8716 mp->br_route.br_n_paths = 1;
8717 mp->br_route.br_paths[0].n_labels = 1;
8718 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8719 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8720 FIB_API_PATH_NH_PROTO_IP4 :
8721 FIB_API_PATH_NH_PROTO_IP6);
8723 if (next_hop_proto_is_ip4)
8725 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8726 &v4_next_hop_address, sizeof (v4_next_hop_address));
8730 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8731 &v6_next_hop_address, sizeof (v6_next_hop_address));
8737 /* Wait for a reply... */
8744 api_mpls_tunnel_add_del (vat_main_t * vam)
8746 unformat_input_t *i = vam->input;
8747 vl_api_mpls_tunnel_add_del_t *mp;
8749 vl_api_fib_path_t paths[8];
8750 u32 sw_if_index = ~0;
8756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8758 if (unformat (i, "add"))
8762 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8764 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8766 else if (unformat (i, "l2-only"))
8770 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8773 if (8 == path_count)
8775 errmsg ("max 8 paths");
8781 clib_warning ("parse error '%U'", format_unformat_error, i);
8786 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8788 mp->mt_is_add = is_add;
8789 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8790 mp->mt_tunnel.mt_l2_only = l2_only;
8791 mp->mt_tunnel.mt_is_multicast = 0;
8792 mp->mt_tunnel.mt_n_paths = path_count;
8794 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8795 sizeof (paths[0]) * path_count);
8803 api_sw_interface_set_unnumbered (vat_main_t * vam)
8805 unformat_input_t *i = vam->input;
8806 vl_api_sw_interface_set_unnumbered_t *mp;
8808 u32 unnum_sw_index = ~0;
8810 u8 sw_if_index_set = 0;
8813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8815 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8816 sw_if_index_set = 1;
8817 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8818 sw_if_index_set = 1;
8819 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8821 else if (unformat (i, "del"))
8825 clib_warning ("parse error '%U'", format_unformat_error, i);
8830 if (sw_if_index_set == 0)
8832 errmsg ("missing interface name or sw_if_index");
8836 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8838 mp->sw_if_index = ntohl (sw_if_index);
8839 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8840 mp->is_add = is_add;
8849 api_create_vlan_subif (vat_main_t * vam)
8851 unformat_input_t *i = vam->input;
8852 vl_api_create_vlan_subif_t *mp;
8854 u8 sw_if_index_set = 0;
8859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8861 if (unformat (i, "sw_if_index %d", &sw_if_index))
8862 sw_if_index_set = 1;
8864 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8865 sw_if_index_set = 1;
8866 else if (unformat (i, "vlan %d", &vlan_id))
8870 clib_warning ("parse error '%U'", format_unformat_error, i);
8875 if (sw_if_index_set == 0)
8877 errmsg ("missing interface name or sw_if_index");
8881 if (vlan_id_set == 0)
8883 errmsg ("missing vlan_id");
8886 M (CREATE_VLAN_SUBIF, mp);
8888 mp->sw_if_index = ntohl (sw_if_index);
8889 mp->vlan_id = ntohl (vlan_id);
8896 #define foreach_create_subif_bit \
8903 _(outer_vlan_id_any) \
8904 _(inner_vlan_id_any)
8906 #define foreach_create_subif_flag \
8911 _(4, "exact_match") \
8912 _(5, "default_sub") \
8913 _(6, "outer_vlan_id_any") \
8914 _(7, "inner_vlan_id_any")
8917 api_create_subif (vat_main_t * vam)
8919 unformat_input_t *i = vam->input;
8920 vl_api_create_subif_t *mp;
8922 u8 sw_if_index_set = 0;
8925 u32 __attribute__ ((unused)) no_tags = 0;
8926 u32 __attribute__ ((unused)) one_tag = 0;
8927 u32 __attribute__ ((unused)) two_tags = 0;
8928 u32 __attribute__ ((unused)) dot1ad = 0;
8929 u32 __attribute__ ((unused)) exact_match = 0;
8930 u32 __attribute__ ((unused)) default_sub = 0;
8931 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8932 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8934 u16 outer_vlan_id = 0;
8935 u16 inner_vlan_id = 0;
8938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8940 if (unformat (i, "sw_if_index %d", &sw_if_index))
8941 sw_if_index_set = 1;
8943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8944 sw_if_index_set = 1;
8945 else if (unformat (i, "sub_id %d", &sub_id))
8947 else if (unformat (i, "outer_vlan_id %d", &tmp))
8948 outer_vlan_id = tmp;
8949 else if (unformat (i, "inner_vlan_id %d", &tmp))
8950 inner_vlan_id = tmp;
8952 #define _(a) else if (unformat (i, #a)) a = 1 ;
8953 foreach_create_subif_bit
8957 clib_warning ("parse error '%U'", format_unformat_error, i);
8962 if (sw_if_index_set == 0)
8964 errmsg ("missing interface name or sw_if_index");
8968 if (sub_id_set == 0)
8970 errmsg ("missing sub_id");
8973 M (CREATE_SUBIF, mp);
8975 mp->sw_if_index = ntohl (sw_if_index);
8976 mp->sub_id = ntohl (sub_id);
8978 #define _(a,b) mp->sub_if_flags |= (1 << a);
8979 foreach_create_subif_flag;
8982 mp->outer_vlan_id = ntohs (outer_vlan_id);
8983 mp->inner_vlan_id = ntohs (inner_vlan_id);
8991 api_ip_table_replace_begin (vat_main_t * vam)
8993 unformat_input_t *i = vam->input;
8994 vl_api_ip_table_replace_begin_t *mp;
8999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9001 if (unformat (i, "table %d", &table_id))
9003 else if (unformat (i, "ipv6"))
9007 clib_warning ("parse error '%U'", format_unformat_error, i);
9012 M (IP_TABLE_REPLACE_BEGIN, mp);
9014 mp->table.table_id = ntohl (table_id);
9015 mp->table.is_ip6 = is_ipv6;
9023 api_ip_table_flush (vat_main_t * vam)
9025 unformat_input_t *i = vam->input;
9026 vl_api_ip_table_flush_t *mp;
9031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9033 if (unformat (i, "table %d", &table_id))
9035 else if (unformat (i, "ipv6"))
9039 clib_warning ("parse error '%U'", format_unformat_error, i);
9044 M (IP_TABLE_FLUSH, mp);
9046 mp->table.table_id = ntohl (table_id);
9047 mp->table.is_ip6 = is_ipv6;
9055 api_ip_table_replace_end (vat_main_t * vam)
9057 unformat_input_t *i = vam->input;
9058 vl_api_ip_table_replace_end_t *mp;
9063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9065 if (unformat (i, "table %d", &table_id))
9067 else if (unformat (i, "ipv6"))
9071 clib_warning ("parse error '%U'", format_unformat_error, i);
9076 M (IP_TABLE_REPLACE_END, mp);
9078 mp->table.table_id = ntohl (table_id);
9079 mp->table.is_ip6 = is_ipv6;
9087 api_set_ip_flow_hash (vat_main_t * vam)
9089 unformat_input_t *i = vam->input;
9090 vl_api_set_ip_flow_hash_t *mp;
9102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9104 if (unformat (i, "vrf %d", &vrf_id))
9106 else if (unformat (i, "ipv6"))
9108 else if (unformat (i, "src"))
9110 else if (unformat (i, "dst"))
9112 else if (unformat (i, "sport"))
9114 else if (unformat (i, "dport"))
9116 else if (unformat (i, "proto"))
9118 else if (unformat (i, "reverse"))
9123 clib_warning ("parse error '%U'", format_unformat_error, i);
9128 if (vrf_id_set == 0)
9130 errmsg ("missing vrf id");
9134 M (SET_IP_FLOW_HASH, mp);
9140 mp->reverse = reverse;
9141 mp->vrf_id = ntohl (vrf_id);
9142 mp->is_ipv6 = is_ipv6;
9150 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9152 unformat_input_t *i = vam->input;
9153 vl_api_sw_interface_ip6_enable_disable_t *mp;
9155 u8 sw_if_index_set = 0;
9159 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9161 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9162 sw_if_index_set = 1;
9163 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9164 sw_if_index_set = 1;
9165 else if (unformat (i, "enable"))
9167 else if (unformat (i, "disable"))
9171 clib_warning ("parse error '%U'", format_unformat_error, i);
9176 if (sw_if_index_set == 0)
9178 errmsg ("missing interface name or sw_if_index");
9182 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9184 mp->sw_if_index = ntohl (sw_if_index);
9185 mp->enable = enable;
9194 api_l2_patch_add_del (vat_main_t * vam)
9196 unformat_input_t *i = vam->input;
9197 vl_api_l2_patch_add_del_t *mp;
9199 u8 rx_sw_if_index_set = 0;
9201 u8 tx_sw_if_index_set = 0;
9205 /* Parse args required to build the message */
9206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9208 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9209 rx_sw_if_index_set = 1;
9210 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9211 tx_sw_if_index_set = 1;
9212 else if (unformat (i, "rx"))
9214 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9216 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9218 rx_sw_if_index_set = 1;
9223 else if (unformat (i, "tx"))
9225 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9227 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9229 tx_sw_if_index_set = 1;
9234 else if (unformat (i, "del"))
9240 if (rx_sw_if_index_set == 0)
9242 errmsg ("missing rx interface name or rx_sw_if_index");
9246 if (tx_sw_if_index_set == 0)
9248 errmsg ("missing tx interface name or tx_sw_if_index");
9252 M (L2_PATCH_ADD_DEL, mp);
9254 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9255 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9256 mp->is_add = is_add;
9264 u8 localsid_addr[16];
9273 api_sr_localsid_add_del (vat_main_t * vam)
9275 unformat_input_t *i = vam->input;
9276 vl_api_sr_localsid_add_del_t *mp;
9279 ip6_address_t localsid;
9283 u32 fib_table = ~(u32) 0;
9284 ip6_address_t nh_addr6;
9285 ip4_address_t nh_addr4;
9286 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9287 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9289 bool nexthop_set = 0;
9293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9295 if (unformat (i, "del"))
9297 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9298 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9300 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9302 else if (unformat (i, "behavior %u", &behavior));
9303 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9304 else if (unformat (i, "fib-table %u", &fib_table));
9305 else if (unformat (i, "end.psp %u", &behavior));
9310 M (SR_LOCALSID_ADD_DEL, mp);
9312 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9316 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9317 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9319 mp->behavior = behavior;
9320 mp->sw_if_index = ntohl (sw_if_index);
9321 mp->fib_table = ntohl (fib_table);
9322 mp->end_psp = end_psp;
9323 mp->is_del = is_del;
9331 api_ioam_enable (vat_main_t * vam)
9333 unformat_input_t *input = vam->input;
9334 vl_api_ioam_enable_t *mp;
9336 int has_trace_option = 0;
9337 int has_pot_option = 0;
9338 int has_seqno_option = 0;
9339 int has_analyse_option = 0;
9342 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9344 if (unformat (input, "trace"))
9345 has_trace_option = 1;
9346 else if (unformat (input, "pot"))
9348 else if (unformat (input, "seqno"))
9349 has_seqno_option = 1;
9350 else if (unformat (input, "analyse"))
9351 has_analyse_option = 1;
9355 M (IOAM_ENABLE, mp);
9356 mp->id = htons (id);
9357 mp->seqno = has_seqno_option;
9358 mp->analyse = has_analyse_option;
9359 mp->pot_enable = has_pot_option;
9360 mp->trace_enable = has_trace_option;
9369 api_ioam_disable (vat_main_t * vam)
9371 vl_api_ioam_disable_t *mp;
9374 M (IOAM_DISABLE, mp);
9380 #define foreach_tcp_proto_field \
9384 #define foreach_udp_proto_field \
9388 #define foreach_ip4_proto_field \
9400 u16 src_port, dst_port;
9403 #if VPP_API_TEST_BUILTIN == 0
9405 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9407 u8 **maskp = va_arg (*args, u8 **);
9409 u8 found_something = 0;
9412 #define _(a) u8 a=0;
9413 foreach_tcp_proto_field;
9416 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9419 #define _(a) else if (unformat (input, #a)) a=1;
9420 foreach_tcp_proto_field
9426 #define _(a) found_something += a;
9427 foreach_tcp_proto_field;
9430 if (found_something == 0)
9433 vec_validate (mask, sizeof (*tcp) - 1);
9435 tcp = (tcp_header_t *) mask;
9437 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9438 foreach_tcp_proto_field;
9446 unformat_udp_mask (unformat_input_t * input, va_list * args)
9448 u8 **maskp = va_arg (*args, u8 **);
9450 u8 found_something = 0;
9453 #define _(a) u8 a=0;
9454 foreach_udp_proto_field;
9457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9460 #define _(a) else if (unformat (input, #a)) a=1;
9461 foreach_udp_proto_field
9467 #define _(a) found_something += a;
9468 foreach_udp_proto_field;
9471 if (found_something == 0)
9474 vec_validate (mask, sizeof (*udp) - 1);
9476 udp = (udp_header_t *) mask;
9478 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9479 foreach_udp_proto_field;
9487 unformat_l4_mask (unformat_input_t * input, va_list * args)
9489 u8 **maskp = va_arg (*args, u8 **);
9490 u16 src_port = 0, dst_port = 0;
9491 tcpudp_header_t *tcpudp;
9493 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9495 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9497 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9499 else if (unformat (input, "src_port"))
9501 else if (unformat (input, "dst_port"))
9507 if (!src_port && !dst_port)
9511 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9513 tcpudp = (tcpudp_header_t *) mask;
9514 tcpudp->src_port = src_port;
9515 tcpudp->dst_port = dst_port;
9523 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9525 u8 **maskp = va_arg (*args, u8 **);
9527 u8 found_something = 0;
9530 #define _(a) u8 a=0;
9531 foreach_ip4_proto_field;
9537 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9539 if (unformat (input, "version"))
9541 else if (unformat (input, "hdr_length"))
9543 else if (unformat (input, "src"))
9545 else if (unformat (input, "dst"))
9547 else if (unformat (input, "proto"))
9550 #define _(a) else if (unformat (input, #a)) a=1;
9551 foreach_ip4_proto_field
9557 #define _(a) found_something += a;
9558 foreach_ip4_proto_field;
9561 if (found_something == 0)
9564 vec_validate (mask, sizeof (*ip) - 1);
9566 ip = (ip4_header_t *) mask;
9568 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9569 foreach_ip4_proto_field;
9572 ip->ip_version_and_header_length = 0;
9575 ip->ip_version_and_header_length |= 0xF0;
9578 ip->ip_version_and_header_length |= 0x0F;
9584 #define foreach_ip6_proto_field \
9592 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9594 u8 **maskp = va_arg (*args, u8 **);
9596 u8 found_something = 0;
9598 u32 ip_version_traffic_class_and_flow_label;
9600 #define _(a) u8 a=0;
9601 foreach_ip6_proto_field;
9604 u8 traffic_class = 0;
9607 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9609 if (unformat (input, "version"))
9611 else if (unformat (input, "traffic-class"))
9613 else if (unformat (input, "flow-label"))
9615 else if (unformat (input, "src"))
9617 else if (unformat (input, "dst"))
9619 else if (unformat (input, "proto"))
9622 #define _(a) else if (unformat (input, #a)) a=1;
9623 foreach_ip6_proto_field
9629 #define _(a) found_something += a;
9630 foreach_ip6_proto_field;
9633 if (found_something == 0)
9636 vec_validate (mask, sizeof (*ip) - 1);
9638 ip = (ip6_header_t *) mask;
9640 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9641 foreach_ip6_proto_field;
9644 ip_version_traffic_class_and_flow_label = 0;
9647 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9650 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9653 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9655 ip->ip_version_traffic_class_and_flow_label =
9656 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9663 unformat_l3_mask (unformat_input_t * input, va_list * args)
9665 u8 **maskp = va_arg (*args, u8 **);
9667 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9669 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9671 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9680 unformat_l2_mask (unformat_input_t * input, va_list * args)
9682 u8 **maskp = va_arg (*args, u8 **);
9697 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9699 if (unformat (input, "src"))
9701 else if (unformat (input, "dst"))
9703 else if (unformat (input, "proto"))
9705 else if (unformat (input, "tag1"))
9707 else if (unformat (input, "tag2"))
9709 else if (unformat (input, "ignore-tag1"))
9711 else if (unformat (input, "ignore-tag2"))
9713 else if (unformat (input, "cos1"))
9715 else if (unformat (input, "cos2"))
9717 else if (unformat (input, "dot1q"))
9719 else if (unformat (input, "dot1ad"))
9724 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9725 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9728 if (tag1 || ignore_tag1 || cos1 || dot1q)
9730 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9733 vec_validate (mask, len - 1);
9736 clib_memset (mask, 0xff, 6);
9739 clib_memset (mask + 6, 0xff, 6);
9743 /* inner vlan tag */
9752 mask[21] = mask[20] = 0xff;
9773 mask[16] = mask[17] = 0xff;
9783 mask[12] = mask[13] = 0xff;
9790 unformat_classify_mask (unformat_input_t * input, va_list * args)
9792 u8 **maskp = va_arg (*args, u8 **);
9793 u32 *skipp = va_arg (*args, u32 *);
9794 u32 *matchp = va_arg (*args, u32 *);
9802 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9804 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9806 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9808 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9810 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9824 if (mask || l2 || l3 || l4)
9828 /* "With a free Ethernet header in every package" */
9830 vec_validate (l2, 13);
9834 vec_append (mask, l3);
9839 vec_append (mask, l4);
9844 /* Scan forward looking for the first significant mask octet */
9845 for (i = 0; i < vec_len (mask); i++)
9849 /* compute (skip, match) params */
9850 *skipp = i / sizeof (u32x4);
9851 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9853 /* Pad mask to an even multiple of the vector size */
9854 while (vec_len (mask) % sizeof (u32x4))
9857 match = vec_len (mask) / sizeof (u32x4);
9859 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9861 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9862 if (*tmp || *(tmp + 1))
9867 clib_warning ("BUG: match 0");
9869 _vec_len (mask) = match * sizeof (u32x4);
9879 #endif /* VPP_API_TEST_BUILTIN */
9881 #define foreach_l2_next \
9883 _(ethernet, ETHERNET_INPUT) \
9888 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9890 u32 *miss_next_indexp = va_arg (*args, u32 *);
9895 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9899 if (unformat (input, "%d", &tmp))
9908 *miss_next_indexp = next_index;
9912 #define foreach_ip_next \
9918 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9920 u32 *miss_next_indexp = va_arg (*args, u32 *);
9925 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9929 if (unformat (input, "%d", &tmp))
9938 *miss_next_indexp = next_index;
9942 #define foreach_acl_next \
9946 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9948 u32 *miss_next_indexp = va_arg (*args, u32 *);
9953 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9957 if (unformat (input, "permit"))
9962 else if (unformat (input, "%d", &tmp))
9971 *miss_next_indexp = next_index;
9976 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9978 u32 *r = va_arg (*args, u32 *);
9980 if (unformat (input, "conform-color"))
9981 *r = POLICE_CONFORM;
9982 else if (unformat (input, "exceed-color"))
9991 api_classify_add_del_table (vat_main_t * vam)
9993 unformat_input_t *i = vam->input;
9994 vl_api_classify_add_del_table_t *mp;
10001 u32 table_index = ~0;
10002 u32 next_table_index = ~0;
10003 u32 miss_next_index = ~0;
10004 u32 memory_size = 32 << 20;
10006 u32 current_data_flag = 0;
10007 int current_data_offset = 0;
10010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10012 if (unformat (i, "del"))
10014 else if (unformat (i, "del-chain"))
10019 else if (unformat (i, "buckets %d", &nbuckets))
10021 else if (unformat (i, "memory_size %d", &memory_size))
10023 else if (unformat (i, "skip %d", &skip))
10025 else if (unformat (i, "match %d", &match))
10027 else if (unformat (i, "table %d", &table_index))
10029 else if (unformat (i, "mask %U", unformat_classify_mask,
10030 &mask, &skip, &match))
10032 else if (unformat (i, "next-table %d", &next_table_index))
10034 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10037 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10040 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10043 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10045 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10051 if (is_add && mask == 0)
10053 errmsg ("Mask required");
10057 if (is_add && skip == ~0)
10059 errmsg ("skip count required");
10063 if (is_add && match == ~0)
10065 errmsg ("match count required");
10069 if (!is_add && table_index == ~0)
10071 errmsg ("table index required for delete");
10075 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10077 mp->is_add = is_add;
10078 mp->del_chain = del_chain;
10079 mp->table_index = ntohl (table_index);
10080 mp->nbuckets = ntohl (nbuckets);
10081 mp->memory_size = ntohl (memory_size);
10082 mp->skip_n_vectors = ntohl (skip);
10083 mp->match_n_vectors = ntohl (match);
10084 mp->next_table_index = ntohl (next_table_index);
10085 mp->miss_next_index = ntohl (miss_next_index);
10086 mp->current_data_flag = ntohl (current_data_flag);
10087 mp->current_data_offset = ntohl (current_data_offset);
10088 mp->mask_len = ntohl (vec_len (mask));
10089 clib_memcpy (mp->mask, mask, vec_len (mask));
10098 #if VPP_API_TEST_BUILTIN == 0
10100 unformat_l4_match (unformat_input_t * input, va_list * args)
10102 u8 **matchp = va_arg (*args, u8 **);
10104 u8 *proto_header = 0;
10110 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10112 if (unformat (input, "src_port %d", &src_port))
10114 else if (unformat (input, "dst_port %d", &dst_port))
10120 h.src_port = clib_host_to_net_u16 (src_port);
10121 h.dst_port = clib_host_to_net_u16 (dst_port);
10122 vec_validate (proto_header, sizeof (h) - 1);
10123 memcpy (proto_header, &h, sizeof (h));
10125 *matchp = proto_header;
10131 unformat_ip4_match (unformat_input_t * input, va_list * args)
10133 u8 **matchp = va_arg (*args, u8 **);
10138 int hdr_length = 0;
10139 u32 hdr_length_val;
10140 int src = 0, dst = 0;
10141 ip4_address_t src_val, dst_val;
10148 int fragment_id = 0;
10149 u32 fragment_id_val;
10155 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10157 if (unformat (input, "version %d", &version_val))
10159 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10161 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10163 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10165 else if (unformat (input, "proto %d", &proto_val))
10167 else if (unformat (input, "tos %d", &tos_val))
10169 else if (unformat (input, "length %d", &length_val))
10171 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10173 else if (unformat (input, "ttl %d", &ttl_val))
10175 else if (unformat (input, "checksum %d", &checksum_val))
10181 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10182 + ttl + checksum == 0)
10186 * Aligned because we use the real comparison functions
10188 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10190 ip = (ip4_header_t *) match;
10192 /* These are realistically matched in practice */
10194 ip->src_address.as_u32 = src_val.as_u32;
10197 ip->dst_address.as_u32 = dst_val.as_u32;
10200 ip->protocol = proto_val;
10203 /* These are not, but they're included for completeness */
10205 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10208 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10214 ip->length = clib_host_to_net_u16 (length_val);
10220 ip->checksum = clib_host_to_net_u16 (checksum_val);
10227 unformat_ip6_match (unformat_input_t * input, va_list * args)
10229 u8 **matchp = va_arg (*args, u8 **);
10234 u8 traffic_class = 0;
10235 u32 traffic_class_val = 0;
10238 int src = 0, dst = 0;
10239 ip6_address_t src_val, dst_val;
10242 int payload_length = 0;
10243 u32 payload_length_val;
10246 u32 ip_version_traffic_class_and_flow_label;
10248 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10250 if (unformat (input, "version %d", &version_val))
10252 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10254 else if (unformat (input, "flow_label %d", &flow_label_val))
10256 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10258 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10260 else if (unformat (input, "proto %d", &proto_val))
10262 else if (unformat (input, "payload_length %d", &payload_length_val))
10263 payload_length = 1;
10264 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10270 if (version + traffic_class + flow_label + src + dst + proto +
10271 payload_length + hop_limit == 0)
10275 * Aligned because we use the real comparison functions
10277 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10279 ip = (ip6_header_t *) match;
10282 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10285 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10288 ip->protocol = proto_val;
10290 ip_version_traffic_class_and_flow_label = 0;
10293 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10296 ip_version_traffic_class_and_flow_label |=
10297 (traffic_class_val & 0xFF) << 20;
10300 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10302 ip->ip_version_traffic_class_and_flow_label =
10303 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10305 if (payload_length)
10306 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10309 ip->hop_limit = hop_limit_val;
10316 unformat_l3_match (unformat_input_t * input, va_list * args)
10318 u8 **matchp = va_arg (*args, u8 **);
10320 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10322 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10324 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10333 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10335 u8 *tagp = va_arg (*args, u8 *);
10338 if (unformat (input, "%d", &tag))
10340 tagp[0] = (tag >> 8) & 0x0F;
10341 tagp[1] = tag & 0xFF;
10349 unformat_l2_match (unformat_input_t * input, va_list * args)
10351 u8 **matchp = va_arg (*args, u8 **);
10364 u8 ignore_tag1 = 0;
10365 u8 ignore_tag2 = 0;
10371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10373 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10376 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10378 else if (unformat (input, "proto %U",
10379 unformat_ethernet_type_host_byte_order, &proto_val))
10381 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10383 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10385 else if (unformat (input, "ignore-tag1"))
10387 else if (unformat (input, "ignore-tag2"))
10389 else if (unformat (input, "cos1 %d", &cos1_val))
10391 else if (unformat (input, "cos2 %d", &cos2_val))
10396 if ((src + dst + proto + tag1 + tag2 +
10397 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10400 if (tag1 || ignore_tag1 || cos1)
10402 if (tag2 || ignore_tag2 || cos2)
10405 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10408 clib_memcpy (match, dst_val, 6);
10411 clib_memcpy (match + 6, src_val, 6);
10415 /* inner vlan tag */
10416 match[19] = tag2_val[1];
10417 match[18] = tag2_val[0];
10419 match[18] |= (cos2_val & 0x7) << 5;
10422 match[21] = proto_val & 0xff;
10423 match[20] = proto_val >> 8;
10427 match[15] = tag1_val[1];
10428 match[14] = tag1_val[0];
10431 match[14] |= (cos1_val & 0x7) << 5;
10437 match[15] = tag1_val[1];
10438 match[14] = tag1_val[0];
10441 match[17] = proto_val & 0xff;
10442 match[16] = proto_val >> 8;
10445 match[14] |= (cos1_val & 0x7) << 5;
10451 match[18] |= (cos2_val & 0x7) << 5;
10453 match[14] |= (cos1_val & 0x7) << 5;
10456 match[13] = proto_val & 0xff;
10457 match[12] = proto_val >> 8;
10465 unformat_qos_source (unformat_input_t * input, va_list * args)
10467 int *qs = va_arg (*args, int *);
10469 if (unformat (input, "ip"))
10470 *qs = QOS_SOURCE_IP;
10471 else if (unformat (input, "mpls"))
10472 *qs = QOS_SOURCE_MPLS;
10473 else if (unformat (input, "ext"))
10474 *qs = QOS_SOURCE_EXT;
10475 else if (unformat (input, "vlan"))
10476 *qs = QOS_SOURCE_VLAN;
10485 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10487 u8 **matchp = va_arg (*args, u8 **);
10488 u32 skip_n_vectors = va_arg (*args, u32);
10489 u32 match_n_vectors = va_arg (*args, u32);
10496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10498 if (unformat (input, "hex %U", unformat_hex_string, &match))
10500 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10502 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10504 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10518 if (match || l2 || l3 || l4)
10520 if (l2 || l3 || l4)
10522 /* "Win a free Ethernet header in every packet" */
10524 vec_validate_aligned (l2, 13, sizeof (u32x4));
10528 vec_append_aligned (match, l3, sizeof (u32x4));
10533 vec_append_aligned (match, l4, sizeof (u32x4));
10538 /* Make sure the vector is big enough even if key is all 0's */
10539 vec_validate_aligned
10540 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10543 /* Set size, include skipped vectors */
10544 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10555 api_classify_add_del_session (vat_main_t * vam)
10557 unformat_input_t *i = vam->input;
10558 vl_api_classify_add_del_session_t *mp;
10560 u32 table_index = ~0;
10561 u32 hit_next_index = ~0;
10562 u32 opaque_index = ~0;
10565 u32 skip_n_vectors = 0;
10566 u32 match_n_vectors = 0;
10572 * Warning: you have to supply skip_n and match_n
10573 * because the API client cant simply look at the classify
10577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10579 if (unformat (i, "del"))
10581 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10584 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10587 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10590 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10592 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10594 else if (unformat (i, "opaque-index %d", &opaque_index))
10596 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10598 else if (unformat (i, "match_n %d", &match_n_vectors))
10600 else if (unformat (i, "match %U", api_unformat_classify_match,
10601 &match, skip_n_vectors, match_n_vectors))
10603 else if (unformat (i, "advance %d", &advance))
10605 else if (unformat (i, "table-index %d", &table_index))
10607 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10609 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10611 else if (unformat (i, "action %d", &action))
10613 else if (unformat (i, "metadata %d", &metadata))
10619 if (table_index == ~0)
10621 errmsg ("Table index required");
10625 if (is_add && match == 0)
10627 errmsg ("Match value required");
10631 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10633 mp->is_add = is_add;
10634 mp->table_index = ntohl (table_index);
10635 mp->hit_next_index = ntohl (hit_next_index);
10636 mp->opaque_index = ntohl (opaque_index);
10637 mp->advance = ntohl (advance);
10638 mp->action = action;
10639 mp->metadata = ntohl (metadata);
10640 mp->match_len = ntohl (vec_len (match));
10641 clib_memcpy (mp->match, match, vec_len (match));
10650 api_classify_set_interface_ip_table (vat_main_t * vam)
10652 unformat_input_t *i = vam->input;
10653 vl_api_classify_set_interface_ip_table_t *mp;
10655 int sw_if_index_set;
10656 u32 table_index = ~0;
10660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10662 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10663 sw_if_index_set = 1;
10664 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10665 sw_if_index_set = 1;
10666 else if (unformat (i, "table %d", &table_index))
10670 clib_warning ("parse error '%U'", format_unformat_error, i);
10675 if (sw_if_index_set == 0)
10677 errmsg ("missing interface name or sw_if_index");
10682 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10684 mp->sw_if_index = ntohl (sw_if_index);
10685 mp->table_index = ntohl (table_index);
10686 mp->is_ipv6 = is_ipv6;
10694 api_classify_set_interface_l2_tables (vat_main_t * vam)
10696 unformat_input_t *i = vam->input;
10697 vl_api_classify_set_interface_l2_tables_t *mp;
10699 int sw_if_index_set;
10700 u32 ip4_table_index = ~0;
10701 u32 ip6_table_index = ~0;
10702 u32 other_table_index = ~0;
10706 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10708 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10709 sw_if_index_set = 1;
10710 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10711 sw_if_index_set = 1;
10712 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10714 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10716 else if (unformat (i, "other-table %d", &other_table_index))
10718 else if (unformat (i, "is-input %d", &is_input))
10722 clib_warning ("parse error '%U'", format_unformat_error, i);
10727 if (sw_if_index_set == 0)
10729 errmsg ("missing interface name or sw_if_index");
10734 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10736 mp->sw_if_index = ntohl (sw_if_index);
10737 mp->ip4_table_index = ntohl (ip4_table_index);
10738 mp->ip6_table_index = ntohl (ip6_table_index);
10739 mp->other_table_index = ntohl (other_table_index);
10740 mp->is_input = (u8) is_input;
10748 api_set_ipfix_exporter (vat_main_t * vam)
10750 unformat_input_t *i = vam->input;
10751 vl_api_set_ipfix_exporter_t *mp;
10752 ip4_address_t collector_address;
10753 u8 collector_address_set = 0;
10754 u32 collector_port = ~0;
10755 ip4_address_t src_address;
10756 u8 src_address_set = 0;
10759 u32 template_interval = ~0;
10760 u8 udp_checksum = 0;
10763 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10765 if (unformat (i, "collector_address %U", unformat_ip4_address,
10766 &collector_address))
10767 collector_address_set = 1;
10768 else if (unformat (i, "collector_port %d", &collector_port))
10770 else if (unformat (i, "src_address %U", unformat_ip4_address,
10772 src_address_set = 1;
10773 else if (unformat (i, "vrf_id %d", &vrf_id))
10775 else if (unformat (i, "path_mtu %d", &path_mtu))
10777 else if (unformat (i, "template_interval %d", &template_interval))
10779 else if (unformat (i, "udp_checksum"))
10785 if (collector_address_set == 0)
10787 errmsg ("collector_address required");
10791 if (src_address_set == 0)
10793 errmsg ("src_address required");
10797 M (SET_IPFIX_EXPORTER, mp);
10799 memcpy (mp->collector_address.un.ip4, collector_address.data,
10800 sizeof (collector_address.data));
10801 mp->collector_port = htons ((u16) collector_port);
10802 memcpy (mp->src_address.un.ip4, src_address.data,
10803 sizeof (src_address.data));
10804 mp->vrf_id = htonl (vrf_id);
10805 mp->path_mtu = htonl (path_mtu);
10806 mp->template_interval = htonl (template_interval);
10807 mp->udp_checksum = udp_checksum;
10815 api_set_ipfix_classify_stream (vat_main_t * vam)
10817 unformat_input_t *i = vam->input;
10818 vl_api_set_ipfix_classify_stream_t *mp;
10820 u32 src_port = UDP_DST_PORT_ipfix;
10823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10825 if (unformat (i, "domain %d", &domain_id))
10827 else if (unformat (i, "src_port %d", &src_port))
10831 errmsg ("unknown input `%U'", format_unformat_error, i);
10836 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10838 mp->domain_id = htonl (domain_id);
10839 mp->src_port = htons ((u16) src_port);
10847 api_ipfix_classify_table_add_del (vat_main_t * vam)
10849 unformat_input_t *i = vam->input;
10850 vl_api_ipfix_classify_table_add_del_t *mp;
10852 u32 classify_table_index = ~0;
10854 u8 transport_protocol = 255;
10857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10859 if (unformat (i, "add"))
10861 else if (unformat (i, "del"))
10863 else if (unformat (i, "table %d", &classify_table_index))
10865 else if (unformat (i, "ip4"))
10867 else if (unformat (i, "ip6"))
10869 else if (unformat (i, "tcp"))
10870 transport_protocol = 6;
10871 else if (unformat (i, "udp"))
10872 transport_protocol = 17;
10875 errmsg ("unknown input `%U'", format_unformat_error, i);
10882 errmsg ("expecting: add|del");
10885 if (classify_table_index == ~0)
10887 errmsg ("classifier table not specified");
10890 if (ip_version == 0)
10892 errmsg ("IP version not specified");
10896 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10898 mp->is_add = is_add;
10899 mp->table_id = htonl (classify_table_index);
10900 mp->ip_version = ip_version;
10901 mp->transport_protocol = transport_protocol;
10909 api_get_node_index (vat_main_t * vam)
10911 unformat_input_t *i = vam->input;
10912 vl_api_get_node_index_t *mp;
10916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10918 if (unformat (i, "node %s", &name))
10925 errmsg ("node name required");
10928 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10930 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10934 M (GET_NODE_INDEX, mp);
10935 clib_memcpy (mp->node_name, name, vec_len (name));
10944 api_get_next_index (vat_main_t * vam)
10946 unformat_input_t *i = vam->input;
10947 vl_api_get_next_index_t *mp;
10948 u8 *node_name = 0, *next_node_name = 0;
10951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10953 if (unformat (i, "node-name %s", &node_name))
10955 else if (unformat (i, "next-node-name %s", &next_node_name))
10959 if (node_name == 0)
10961 errmsg ("node name required");
10964 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10966 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10970 if (next_node_name == 0)
10972 errmsg ("next node name required");
10975 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10977 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10981 M (GET_NEXT_INDEX, mp);
10982 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10983 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10984 vec_free (node_name);
10985 vec_free (next_node_name);
10993 api_add_node_next (vat_main_t * vam)
10995 unformat_input_t *i = vam->input;
10996 vl_api_add_node_next_t *mp;
11001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11003 if (unformat (i, "node %s", &name))
11005 else if (unformat (i, "next %s", &next))
11012 errmsg ("node name required");
11015 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11017 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11022 errmsg ("next node required");
11025 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11027 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11031 M (ADD_NODE_NEXT, mp);
11032 clib_memcpy (mp->node_name, name, vec_len (name));
11033 clib_memcpy (mp->next_name, next, vec_len (next));
11043 api_l2tpv3_create_tunnel (vat_main_t * vam)
11045 unformat_input_t *i = vam->input;
11046 ip6_address_t client_address, our_address;
11047 int client_address_set = 0;
11048 int our_address_set = 0;
11049 u32 local_session_id = 0;
11050 u32 remote_session_id = 0;
11051 u64 local_cookie = 0;
11052 u64 remote_cookie = 0;
11053 u8 l2_sublayer_present = 0;
11054 vl_api_l2tpv3_create_tunnel_t *mp;
11057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11059 if (unformat (i, "client_address %U", unformat_ip6_address,
11061 client_address_set = 1;
11062 else if (unformat (i, "our_address %U", unformat_ip6_address,
11064 our_address_set = 1;
11065 else if (unformat (i, "local_session_id %d", &local_session_id))
11067 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11069 else if (unformat (i, "local_cookie %lld", &local_cookie))
11071 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11073 else if (unformat (i, "l2-sublayer-present"))
11074 l2_sublayer_present = 1;
11079 if (client_address_set == 0)
11081 errmsg ("client_address required");
11085 if (our_address_set == 0)
11087 errmsg ("our_address required");
11091 M (L2TPV3_CREATE_TUNNEL, mp);
11093 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11094 sizeof (ip6_address_t));
11096 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11097 sizeof (ip6_address_t));
11099 mp->local_session_id = ntohl (local_session_id);
11100 mp->remote_session_id = ntohl (remote_session_id);
11101 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11102 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11103 mp->l2_sublayer_present = l2_sublayer_present;
11111 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11113 unformat_input_t *i = vam->input;
11115 u8 sw_if_index_set = 0;
11116 u64 new_local_cookie = 0;
11117 u64 new_remote_cookie = 0;
11118 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11123 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11124 sw_if_index_set = 1;
11125 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11126 sw_if_index_set = 1;
11127 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11129 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11135 if (sw_if_index_set == 0)
11137 errmsg ("missing interface name or sw_if_index");
11141 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11143 mp->sw_if_index = ntohl (sw_if_index);
11144 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11145 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11153 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11155 unformat_input_t *i = vam->input;
11156 vl_api_l2tpv3_interface_enable_disable_t *mp;
11158 u8 sw_if_index_set = 0;
11159 u8 enable_disable = 1;
11162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11164 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11165 sw_if_index_set = 1;
11166 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11167 sw_if_index_set = 1;
11168 else if (unformat (i, "enable"))
11169 enable_disable = 1;
11170 else if (unformat (i, "disable"))
11171 enable_disable = 0;
11176 if (sw_if_index_set == 0)
11178 errmsg ("missing interface name or sw_if_index");
11182 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11184 mp->sw_if_index = ntohl (sw_if_index);
11185 mp->enable_disable = enable_disable;
11193 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11195 unformat_input_t *i = vam->input;
11196 vl_api_l2tpv3_set_lookup_key_t *mp;
11200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11202 if (unformat (i, "lookup_v6_src"))
11203 key = L2T_LOOKUP_SRC_ADDRESS;
11204 else if (unformat (i, "lookup_v6_dst"))
11205 key = L2T_LOOKUP_DST_ADDRESS;
11206 else if (unformat (i, "lookup_session_id"))
11207 key = L2T_LOOKUP_SESSION_ID;
11212 if (key == (u8) ~ 0)
11214 errmsg ("l2tp session lookup key unset");
11218 M (L2TPV3_SET_LOOKUP_KEY, mp);
11227 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11228 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11230 vat_main_t *vam = &vat_main;
11232 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11233 format_ip6_address, mp->our_address,
11234 format_ip6_address, mp->client_address,
11235 clib_net_to_host_u32 (mp->sw_if_index));
11238 " local cookies %016llx %016llx remote cookie %016llx",
11239 clib_net_to_host_u64 (mp->local_cookie[0]),
11240 clib_net_to_host_u64 (mp->local_cookie[1]),
11241 clib_net_to_host_u64 (mp->remote_cookie));
11243 print (vam->ofp, " local session-id %d remote session-id %d",
11244 clib_net_to_host_u32 (mp->local_session_id),
11245 clib_net_to_host_u32 (mp->remote_session_id));
11247 print (vam->ofp, " l2 specific sublayer %s\n",
11248 mp->l2_sublayer_present ? "preset" : "absent");
11252 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11253 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11255 vat_main_t *vam = &vat_main;
11256 vat_json_node_t *node = NULL;
11257 struct in6_addr addr;
11259 if (VAT_JSON_ARRAY != vam->json_tree.type)
11261 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11262 vat_json_init_array (&vam->json_tree);
11264 node = vat_json_array_add (&vam->json_tree);
11266 vat_json_init_object (node);
11268 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11269 vat_json_object_add_ip6 (node, "our_address", addr);
11270 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11271 vat_json_object_add_ip6 (node, "client_address", addr);
11273 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11274 vat_json_init_array (lc);
11275 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11276 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11277 vat_json_object_add_uint (node, "remote_cookie",
11278 clib_net_to_host_u64 (mp->remote_cookie));
11280 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11281 vat_json_object_add_uint (node, "local_session_id",
11282 clib_net_to_host_u32 (mp->local_session_id));
11283 vat_json_object_add_uint (node, "remote_session_id",
11284 clib_net_to_host_u32 (mp->remote_session_id));
11285 vat_json_object_add_string_copy (node, "l2_sublayer",
11286 mp->l2_sublayer_present ? (u8 *) "present"
11287 : (u8 *) "absent");
11291 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11293 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11294 vl_api_control_ping_t *mp_ping;
11297 /* Get list of l2tpv3-tunnel interfaces */
11298 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11301 /* Use a control ping for synchronization */
11302 MPING (CONTROL_PING, mp_ping);
11310 static void vl_api_sw_interface_tap_v2_details_t_handler
11311 (vl_api_sw_interface_tap_v2_details_t * mp)
11313 vat_main_t *vam = &vat_main;
11316 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11317 mp->host_ip4_prefix.len);
11319 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11320 mp->host_ip6_prefix.len);
11323 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11324 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11325 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11326 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11327 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11333 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11334 (vl_api_sw_interface_tap_v2_details_t * mp)
11336 vat_main_t *vam = &vat_main;
11337 vat_json_node_t *node = NULL;
11339 if (VAT_JSON_ARRAY != vam->json_tree.type)
11341 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11342 vat_json_init_array (&vam->json_tree);
11344 node = vat_json_array_add (&vam->json_tree);
11346 vat_json_init_object (node);
11347 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11348 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11349 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11350 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11351 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11352 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11353 vat_json_object_add_string_copy (node, "host_mac_addr",
11354 format (0, "%U", format_ethernet_address,
11355 &mp->host_mac_addr));
11356 vat_json_object_add_string_copy (node, "host_namespace",
11357 mp->host_namespace);
11358 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11359 vat_json_object_add_string_copy (node, "host_ip4_addr",
11360 format (0, "%U/%d", format_ip4_address,
11361 mp->host_ip4_prefix.address,
11362 mp->host_ip4_prefix.len));
11363 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11364 format (0, "%U/%d", format_ip6_address,
11365 mp->host_ip6_prefix.address,
11366 mp->host_ip6_prefix.len));
11371 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11373 vl_api_sw_interface_tap_v2_dump_t *mp;
11374 vl_api_control_ping_t *mp_ping;
11378 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11379 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11380 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11383 /* Get list of tap interfaces */
11384 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11387 /* Use a control ping for synchronization */
11388 MPING (CONTROL_PING, mp_ping);
11395 static void vl_api_sw_interface_virtio_pci_details_t_handler
11396 (vl_api_sw_interface_virtio_pci_details_t * mp)
11398 vat_main_t *vam = &vat_main;
11413 addr.domain = ntohs (mp->pci_addr.domain);
11414 addr.bus = mp->pci_addr.bus;
11415 addr.slot = mp->pci_addr.slot;
11416 addr.function = mp->pci_addr.function;
11418 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11419 addr.slot, addr.function);
11422 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11423 pci_addr, ntohl (mp->sw_if_index),
11424 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11425 format_ethernet_address, mp->mac_addr,
11426 clib_net_to_host_u64 (mp->features));
11427 vec_free (pci_addr);
11430 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11431 (vl_api_sw_interface_virtio_pci_details_t * mp)
11433 vat_main_t *vam = &vat_main;
11434 vat_json_node_t *node = NULL;
11435 vlib_pci_addr_t pci_addr;
11437 if (VAT_JSON_ARRAY != vam->json_tree.type)
11439 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11440 vat_json_init_array (&vam->json_tree);
11442 node = vat_json_array_add (&vam->json_tree);
11444 pci_addr.domain = ntohs (mp->pci_addr.domain);
11445 pci_addr.bus = mp->pci_addr.bus;
11446 pci_addr.slot = mp->pci_addr.slot;
11447 pci_addr.function = mp->pci_addr.function;
11449 vat_json_init_object (node);
11450 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11451 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11452 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11453 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11454 vat_json_object_add_uint (node, "features",
11455 clib_net_to_host_u64 (mp->features));
11456 vat_json_object_add_string_copy (node, "mac_addr",
11457 format (0, "%U", format_ethernet_address,
11462 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11464 vl_api_sw_interface_virtio_pci_dump_t *mp;
11465 vl_api_control_ping_t *mp_ping;
11469 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11470 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11471 "mac_addr", "features");
11473 /* Get list of tap interfaces */
11474 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11477 /* Use a control ping for synchronization */
11478 MPING (CONTROL_PING, mp_ping);
11486 api_vxlan_offload_rx (vat_main_t * vam)
11488 unformat_input_t *line_input = vam->input;
11489 vl_api_vxlan_offload_rx_t *mp;
11490 u32 hw_if_index = ~0, rx_if_index = ~0;
11494 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11496 if (unformat (line_input, "del"))
11498 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11501 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11503 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11506 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11510 errmsg ("parse error '%U'", format_unformat_error, line_input);
11515 if (hw_if_index == ~0)
11517 errmsg ("no hw interface");
11521 if (rx_if_index == ~0)
11523 errmsg ("no rx tunnel");
11527 M (VXLAN_OFFLOAD_RX, mp);
11529 mp->hw_if_index = ntohl (hw_if_index);
11530 mp->sw_if_index = ntohl (rx_if_index);
11531 mp->enable = is_add;
11538 static uword unformat_vxlan_decap_next
11539 (unformat_input_t * input, va_list * args)
11541 u32 *result = va_arg (*args, u32 *);
11544 if (unformat (input, "l2"))
11545 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11546 else if (unformat (input, "%d", &tmp))
11554 api_vxlan_add_del_tunnel (vat_main_t * vam)
11556 unformat_input_t *line_input = vam->input;
11557 vl_api_vxlan_add_del_tunnel_t *mp;
11558 ip46_address_t src, dst;
11560 u8 ipv4_set = 0, ipv6_set = 0;
11565 u32 mcast_sw_if_index = ~0;
11566 u32 encap_vrf_id = 0;
11567 u32 decap_next_index = ~0;
11571 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11572 clib_memset (&src, 0, sizeof src);
11573 clib_memset (&dst, 0, sizeof dst);
11575 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11577 if (unformat (line_input, "del"))
11579 else if (unformat (line_input, "instance %d", &instance))
11582 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11588 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11594 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11600 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11605 else if (unformat (line_input, "group %U %U",
11606 unformat_ip4_address, &dst.ip4,
11607 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11609 grp_set = dst_set = 1;
11612 else if (unformat (line_input, "group %U",
11613 unformat_ip4_address, &dst.ip4))
11615 grp_set = dst_set = 1;
11618 else if (unformat (line_input, "group %U %U",
11619 unformat_ip6_address, &dst.ip6,
11620 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11622 grp_set = dst_set = 1;
11625 else if (unformat (line_input, "group %U",
11626 unformat_ip6_address, &dst.ip6))
11628 grp_set = dst_set = 1;
11632 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11634 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11636 else if (unformat (line_input, "decap-next %U",
11637 unformat_vxlan_decap_next, &decap_next_index))
11639 else if (unformat (line_input, "vni %d", &vni))
11643 errmsg ("parse error '%U'", format_unformat_error, line_input);
11650 errmsg ("tunnel src address not specified");
11655 errmsg ("tunnel dst address not specified");
11659 if (grp_set && !ip46_address_is_multicast (&dst))
11661 errmsg ("tunnel group address not multicast");
11664 if (grp_set && mcast_sw_if_index == ~0)
11666 errmsg ("tunnel nonexistent multicast device");
11669 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11671 errmsg ("tunnel dst address must be unicast");
11676 if (ipv4_set && ipv6_set)
11678 errmsg ("both IPv4 and IPv6 addresses specified");
11682 if ((vni == 0) || (vni >> 24))
11684 errmsg ("vni not specified or out of range");
11688 M (VXLAN_ADD_DEL_TUNNEL, mp);
11692 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11693 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11697 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11698 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11701 mp->instance = htonl (instance);
11702 mp->encap_vrf_id = ntohl (encap_vrf_id);
11703 mp->decap_next_index = ntohl (decap_next_index);
11704 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11705 mp->vni = ntohl (vni);
11706 mp->is_add = is_add;
11707 mp->is_ipv6 = ipv6_set;
11714 static void vl_api_vxlan_tunnel_details_t_handler
11715 (vl_api_vxlan_tunnel_details_t * mp)
11717 vat_main_t *vam = &vat_main;
11718 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11719 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11721 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11722 ntohl (mp->sw_if_index),
11723 ntohl (mp->instance),
11724 format_ip46_address, &src, IP46_TYPE_ANY,
11725 format_ip46_address, &dst, IP46_TYPE_ANY,
11726 ntohl (mp->encap_vrf_id),
11727 ntohl (mp->decap_next_index), ntohl (mp->vni),
11728 ntohl (mp->mcast_sw_if_index));
11731 static void vl_api_vxlan_tunnel_details_t_handler_json
11732 (vl_api_vxlan_tunnel_details_t * mp)
11734 vat_main_t *vam = &vat_main;
11735 vat_json_node_t *node = NULL;
11737 if (VAT_JSON_ARRAY != vam->json_tree.type)
11739 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11740 vat_json_init_array (&vam->json_tree);
11742 node = vat_json_array_add (&vam->json_tree);
11744 vat_json_init_object (node);
11745 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11747 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11751 struct in6_addr ip6;
11753 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11754 vat_json_object_add_ip6 (node, "src_address", ip6);
11755 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11756 vat_json_object_add_ip6 (node, "dst_address", ip6);
11760 struct in_addr ip4;
11762 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11763 vat_json_object_add_ip4 (node, "src_address", ip4);
11764 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11765 vat_json_object_add_ip4 (node, "dst_address", ip4);
11767 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11768 vat_json_object_add_uint (node, "decap_next_index",
11769 ntohl (mp->decap_next_index));
11770 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11771 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11772 vat_json_object_add_uint (node, "mcast_sw_if_index",
11773 ntohl (mp->mcast_sw_if_index));
11777 api_vxlan_tunnel_dump (vat_main_t * vam)
11779 unformat_input_t *i = vam->input;
11780 vl_api_vxlan_tunnel_dump_t *mp;
11781 vl_api_control_ping_t *mp_ping;
11783 u8 sw_if_index_set = 0;
11786 /* Parse args required to build the message */
11787 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11789 if (unformat (i, "sw_if_index %d", &sw_if_index))
11790 sw_if_index_set = 1;
11795 if (sw_if_index_set == 0)
11800 if (!vam->json_output)
11802 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11803 "sw_if_index", "instance", "src_address", "dst_address",
11804 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11807 /* Get list of vxlan-tunnel interfaces */
11808 M (VXLAN_TUNNEL_DUMP, mp);
11810 mp->sw_if_index = htonl (sw_if_index);
11814 /* Use a control ping for synchronization */
11815 MPING (CONTROL_PING, mp_ping);
11822 static uword unformat_geneve_decap_next
11823 (unformat_input_t * input, va_list * args)
11825 u32 *result = va_arg (*args, u32 *);
11828 if (unformat (input, "l2"))
11829 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11830 else if (unformat (input, "%d", &tmp))
11838 api_geneve_add_del_tunnel (vat_main_t * vam)
11840 unformat_input_t *line_input = vam->input;
11841 vl_api_geneve_add_del_tunnel_t *mp;
11842 ip46_address_t src, dst;
11844 u8 ipv4_set = 0, ipv6_set = 0;
11848 u32 mcast_sw_if_index = ~0;
11849 u32 encap_vrf_id = 0;
11850 u32 decap_next_index = ~0;
11854 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11855 clib_memset (&src, 0, sizeof src);
11856 clib_memset (&dst, 0, sizeof dst);
11858 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11860 if (unformat (line_input, "del"))
11863 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11869 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11875 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11881 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11886 else if (unformat (line_input, "group %U %U",
11887 unformat_ip4_address, &dst.ip4,
11888 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11890 grp_set = dst_set = 1;
11893 else if (unformat (line_input, "group %U",
11894 unformat_ip4_address, &dst.ip4))
11896 grp_set = dst_set = 1;
11899 else if (unformat (line_input, "group %U %U",
11900 unformat_ip6_address, &dst.ip6,
11901 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11903 grp_set = dst_set = 1;
11906 else if (unformat (line_input, "group %U",
11907 unformat_ip6_address, &dst.ip6))
11909 grp_set = dst_set = 1;
11913 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11915 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11917 else if (unformat (line_input, "decap-next %U",
11918 unformat_geneve_decap_next, &decap_next_index))
11920 else if (unformat (line_input, "vni %d", &vni))
11924 errmsg ("parse error '%U'", format_unformat_error, line_input);
11931 errmsg ("tunnel src address not specified");
11936 errmsg ("tunnel dst address not specified");
11940 if (grp_set && !ip46_address_is_multicast (&dst))
11942 errmsg ("tunnel group address not multicast");
11945 if (grp_set && mcast_sw_if_index == ~0)
11947 errmsg ("tunnel nonexistent multicast device");
11950 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11952 errmsg ("tunnel dst address must be unicast");
11957 if (ipv4_set && ipv6_set)
11959 errmsg ("both IPv4 and IPv6 addresses specified");
11963 if ((vni == 0) || (vni >> 24))
11965 errmsg ("vni not specified or out of range");
11969 M (GENEVE_ADD_DEL_TUNNEL, mp);
11973 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
11974 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11978 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
11979 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11981 mp->encap_vrf_id = ntohl (encap_vrf_id);
11982 mp->decap_next_index = ntohl (decap_next_index);
11983 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11984 mp->vni = ntohl (vni);
11985 mp->is_add = is_add;
11992 static void vl_api_geneve_tunnel_details_t_handler
11993 (vl_api_geneve_tunnel_details_t * mp)
11995 vat_main_t *vam = &vat_main;
11996 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
11997 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
11999 if (mp->src_address.af == ADDRESS_IP6)
12001 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12002 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12006 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12007 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12010 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12011 ntohl (mp->sw_if_index),
12012 format_ip46_address, &src, IP46_TYPE_ANY,
12013 format_ip46_address, &dst, IP46_TYPE_ANY,
12014 ntohl (mp->encap_vrf_id),
12015 ntohl (mp->decap_next_index), ntohl (mp->vni),
12016 ntohl (mp->mcast_sw_if_index));
12019 static void vl_api_geneve_tunnel_details_t_handler_json
12020 (vl_api_geneve_tunnel_details_t * mp)
12022 vat_main_t *vam = &vat_main;
12023 vat_json_node_t *node = NULL;
12026 if (VAT_JSON_ARRAY != vam->json_tree.type)
12028 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12029 vat_json_init_array (&vam->json_tree);
12031 node = vat_json_array_add (&vam->json_tree);
12033 vat_json_init_object (node);
12034 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12035 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12038 struct in6_addr ip6;
12040 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12041 vat_json_object_add_ip6 (node, "src_address", ip6);
12042 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12043 vat_json_object_add_ip6 (node, "dst_address", ip6);
12047 struct in_addr ip4;
12049 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12050 vat_json_object_add_ip4 (node, "src_address", ip4);
12051 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12052 vat_json_object_add_ip4 (node, "dst_address", ip4);
12054 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12055 vat_json_object_add_uint (node, "decap_next_index",
12056 ntohl (mp->decap_next_index));
12057 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12058 vat_json_object_add_uint (node, "mcast_sw_if_index",
12059 ntohl (mp->mcast_sw_if_index));
12063 api_geneve_tunnel_dump (vat_main_t * vam)
12065 unformat_input_t *i = vam->input;
12066 vl_api_geneve_tunnel_dump_t *mp;
12067 vl_api_control_ping_t *mp_ping;
12069 u8 sw_if_index_set = 0;
12072 /* Parse args required to build the message */
12073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12075 if (unformat (i, "sw_if_index %d", &sw_if_index))
12076 sw_if_index_set = 1;
12081 if (sw_if_index_set == 0)
12086 if (!vam->json_output)
12088 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12089 "sw_if_index", "local_address", "remote_address",
12090 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12093 /* Get list of geneve-tunnel interfaces */
12094 M (GENEVE_TUNNEL_DUMP, mp);
12096 mp->sw_if_index = htonl (sw_if_index);
12100 /* Use a control ping for synchronization */
12101 M (CONTROL_PING, mp_ping);
12109 api_gre_tunnel_add_del (vat_main_t * vam)
12111 unformat_input_t *line_input = vam->input;
12112 vl_api_address_t src = { }, dst =
12115 vl_api_gre_tunnel_add_del_t *mp;
12116 vl_api_gre_tunnel_type_t t_type;
12120 u32 outer_table_id = 0;
12121 u32 session_id = 0;
12125 t_type = GRE_API_TUNNEL_TYPE_L3;
12127 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12129 if (unformat (line_input, "del"))
12131 else if (unformat (line_input, "instance %d", &instance))
12133 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12137 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12141 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12143 else if (unformat (line_input, "teb"))
12144 t_type = GRE_API_TUNNEL_TYPE_TEB;
12145 else if (unformat (line_input, "erspan %d", &session_id))
12146 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12149 errmsg ("parse error '%U'", format_unformat_error, line_input);
12156 errmsg ("tunnel src address not specified");
12161 errmsg ("tunnel dst address not specified");
12165 M (GRE_TUNNEL_ADD_DEL, mp);
12167 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12168 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12170 mp->tunnel.instance = htonl (instance);
12171 mp->tunnel.outer_table_id = htonl (outer_table_id);
12172 mp->is_add = is_add;
12173 mp->tunnel.session_id = htons ((u16) session_id);
12174 mp->tunnel.type = htonl (t_type);
12181 static void vl_api_gre_tunnel_details_t_handler
12182 (vl_api_gre_tunnel_details_t * mp)
12184 vat_main_t *vam = &vat_main;
12186 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12187 ntohl (mp->tunnel.sw_if_index),
12188 ntohl (mp->tunnel.instance),
12189 format_vl_api_address, &mp->tunnel.src,
12190 format_vl_api_address, &mp->tunnel.dst,
12191 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12192 ntohl (mp->tunnel.session_id));
12195 static void vl_api_gre_tunnel_details_t_handler_json
12196 (vl_api_gre_tunnel_details_t * mp)
12198 vat_main_t *vam = &vat_main;
12199 vat_json_node_t *node = NULL;
12201 if (VAT_JSON_ARRAY != vam->json_tree.type)
12203 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12204 vat_json_init_array (&vam->json_tree);
12206 node = vat_json_array_add (&vam->json_tree);
12208 vat_json_init_object (node);
12209 vat_json_object_add_uint (node, "sw_if_index",
12210 ntohl (mp->tunnel.sw_if_index));
12211 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12213 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12214 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12215 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12216 vat_json_object_add_uint (node, "outer_table_id",
12217 ntohl (mp->tunnel.outer_table_id));
12218 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12222 api_gre_tunnel_dump (vat_main_t * vam)
12224 unformat_input_t *i = vam->input;
12225 vl_api_gre_tunnel_dump_t *mp;
12226 vl_api_control_ping_t *mp_ping;
12228 u8 sw_if_index_set = 0;
12231 /* Parse args required to build the message */
12232 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12234 if (unformat (i, "sw_if_index %d", &sw_if_index))
12235 sw_if_index_set = 1;
12240 if (sw_if_index_set == 0)
12245 if (!vam->json_output)
12247 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12248 "sw_if_index", "instance", "src_address", "dst_address",
12249 "tunnel_type", "outer_fib_id", "session_id");
12252 /* Get list of gre-tunnel interfaces */
12253 M (GRE_TUNNEL_DUMP, mp);
12255 mp->sw_if_index = htonl (sw_if_index);
12259 /* Use a control ping for synchronization */
12260 MPING (CONTROL_PING, mp_ping);
12268 api_l2_fib_clear_table (vat_main_t * vam)
12270 // unformat_input_t * i = vam->input;
12271 vl_api_l2_fib_clear_table_t *mp;
12274 M (L2_FIB_CLEAR_TABLE, mp);
12282 api_l2_interface_efp_filter (vat_main_t * vam)
12284 unformat_input_t *i = vam->input;
12285 vl_api_l2_interface_efp_filter_t *mp;
12288 u8 sw_if_index_set = 0;
12291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12293 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12294 sw_if_index_set = 1;
12295 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12296 sw_if_index_set = 1;
12297 else if (unformat (i, "enable"))
12299 else if (unformat (i, "disable"))
12303 clib_warning ("parse error '%U'", format_unformat_error, i);
12308 if (sw_if_index_set == 0)
12310 errmsg ("missing sw_if_index");
12314 M (L2_INTERFACE_EFP_FILTER, mp);
12316 mp->sw_if_index = ntohl (sw_if_index);
12317 mp->enable_disable = enable;
12324 #define foreach_vtr_op \
12325 _("disable", L2_VTR_DISABLED) \
12326 _("push-1", L2_VTR_PUSH_1) \
12327 _("push-2", L2_VTR_PUSH_2) \
12328 _("pop-1", L2_VTR_POP_1) \
12329 _("pop-2", L2_VTR_POP_2) \
12330 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12331 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12332 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12333 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12336 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12338 unformat_input_t *i = vam->input;
12339 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12341 u8 sw_if_index_set = 0;
12344 u32 push_dot1q = 1;
12349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12351 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12352 sw_if_index_set = 1;
12353 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12354 sw_if_index_set = 1;
12355 else if (unformat (i, "vtr_op %d", &vtr_op))
12357 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12360 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12362 else if (unformat (i, "tag1 %d", &tag1))
12364 else if (unformat (i, "tag2 %d", &tag2))
12368 clib_warning ("parse error '%U'", format_unformat_error, i);
12373 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12375 errmsg ("missing vtr operation or sw_if_index");
12379 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12380 mp->sw_if_index = ntohl (sw_if_index);
12381 mp->vtr_op = ntohl (vtr_op);
12382 mp->push_dot1q = ntohl (push_dot1q);
12383 mp->tag1 = ntohl (tag1);
12384 mp->tag2 = ntohl (tag2);
12392 api_create_vhost_user_if (vat_main_t * vam)
12394 unformat_input_t *i = vam->input;
12395 vl_api_create_vhost_user_if_t *mp;
12398 u8 file_name_set = 0;
12399 u32 custom_dev_instance = ~0;
12401 u8 use_custom_mac = 0;
12402 u8 disable_mrg_rxbuf = 0;
12403 u8 disable_indirect_desc = 0;
12408 /* Shut up coverity */
12409 clib_memset (hwaddr, 0, sizeof (hwaddr));
12411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12413 if (unformat (i, "socket %s", &file_name))
12417 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12419 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12420 use_custom_mac = 1;
12421 else if (unformat (i, "server"))
12423 else if (unformat (i, "disable_mrg_rxbuf"))
12424 disable_mrg_rxbuf = 1;
12425 else if (unformat (i, "disable_indirect_desc"))
12426 disable_indirect_desc = 1;
12427 else if (unformat (i, "gso"))
12429 else if (unformat (i, "tag %s", &tag))
12435 if (file_name_set == 0)
12437 errmsg ("missing socket file name");
12441 if (vec_len (file_name) > 255)
12443 errmsg ("socket file name too long");
12446 vec_add1 (file_name, 0);
12448 M (CREATE_VHOST_USER_IF, mp);
12450 mp->is_server = is_server;
12451 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12452 mp->disable_indirect_desc = disable_indirect_desc;
12453 mp->enable_gso = enable_gso;
12454 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12455 vec_free (file_name);
12456 if (custom_dev_instance != ~0)
12459 mp->custom_dev_instance = ntohl (custom_dev_instance);
12462 mp->use_custom_mac = use_custom_mac;
12463 clib_memcpy (mp->mac_address, hwaddr, 6);
12465 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12474 api_modify_vhost_user_if (vat_main_t * vam)
12476 unformat_input_t *i = vam->input;
12477 vl_api_modify_vhost_user_if_t *mp;
12480 u8 file_name_set = 0;
12481 u32 custom_dev_instance = ~0;
12482 u8 sw_if_index_set = 0;
12483 u32 sw_if_index = (u32) ~ 0;
12487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12489 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12490 sw_if_index_set = 1;
12491 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12492 sw_if_index_set = 1;
12493 else if (unformat (i, "socket %s", &file_name))
12497 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12499 else if (unformat (i, "server"))
12501 else if (unformat (i, "gso"))
12507 if (sw_if_index_set == 0)
12509 errmsg ("missing sw_if_index or interface name");
12513 if (file_name_set == 0)
12515 errmsg ("missing socket file name");
12519 if (vec_len (file_name) > 255)
12521 errmsg ("socket file name too long");
12524 vec_add1 (file_name, 0);
12526 M (MODIFY_VHOST_USER_IF, mp);
12528 mp->sw_if_index = ntohl (sw_if_index);
12529 mp->is_server = is_server;
12530 mp->enable_gso = enable_gso;
12531 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12532 vec_free (file_name);
12533 if (custom_dev_instance != ~0)
12536 mp->custom_dev_instance = ntohl (custom_dev_instance);
12545 api_delete_vhost_user_if (vat_main_t * vam)
12547 unformat_input_t *i = vam->input;
12548 vl_api_delete_vhost_user_if_t *mp;
12549 u32 sw_if_index = ~0;
12550 u8 sw_if_index_set = 0;
12553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12555 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12556 sw_if_index_set = 1;
12557 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12558 sw_if_index_set = 1;
12563 if (sw_if_index_set == 0)
12565 errmsg ("missing sw_if_index or interface name");
12570 M (DELETE_VHOST_USER_IF, mp);
12572 mp->sw_if_index = ntohl (sw_if_index);
12579 static void vl_api_sw_interface_vhost_user_details_t_handler
12580 (vl_api_sw_interface_vhost_user_details_t * mp)
12582 vat_main_t *vam = &vat_main;
12586 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12587 clib_net_to_host_u32
12588 (mp->features_last_32) <<
12591 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12592 (char *) mp->interface_name,
12593 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12594 features, mp->is_server,
12595 ntohl (mp->num_regions), (char *) mp->sock_filename);
12596 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12599 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12600 (vl_api_sw_interface_vhost_user_details_t * mp)
12602 vat_main_t *vam = &vat_main;
12603 vat_json_node_t *node = NULL;
12605 if (VAT_JSON_ARRAY != vam->json_tree.type)
12607 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12608 vat_json_init_array (&vam->json_tree);
12610 node = vat_json_array_add (&vam->json_tree);
12612 vat_json_init_object (node);
12613 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12614 vat_json_object_add_string_copy (node, "interface_name",
12615 mp->interface_name);
12616 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12617 ntohl (mp->virtio_net_hdr_sz));
12618 vat_json_object_add_uint (node, "features_first_32",
12619 clib_net_to_host_u32 (mp->features_first_32));
12620 vat_json_object_add_uint (node, "features_last_32",
12621 clib_net_to_host_u32 (mp->features_last_32));
12622 vat_json_object_add_uint (node, "is_server", mp->is_server);
12623 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12624 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12625 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12629 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12631 vl_api_sw_interface_vhost_user_dump_t *mp;
12632 vl_api_control_ping_t *mp_ping;
12635 "Interface name idx hdr_sz features server regions filename");
12637 /* Get list of vhost-user interfaces */
12638 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12641 /* Use a control ping for synchronization */
12642 MPING (CONTROL_PING, mp_ping);
12650 api_show_version (vat_main_t * vam)
12652 vl_api_show_version_t *mp;
12655 M (SHOW_VERSION, mp);
12664 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12666 unformat_input_t *line_input = vam->input;
12667 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12668 ip4_address_t local4, remote4;
12669 ip6_address_t local6, remote6;
12671 u8 ipv4_set = 0, ipv6_set = 0;
12675 u32 mcast_sw_if_index = ~0;
12676 u32 encap_vrf_id = 0;
12677 u32 decap_vrf_id = 0;
12683 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12684 clib_memset (&local4, 0, sizeof local4);
12685 clib_memset (&remote4, 0, sizeof remote4);
12686 clib_memset (&local6, 0, sizeof local6);
12687 clib_memset (&remote6, 0, sizeof remote6);
12689 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12691 if (unformat (line_input, "del"))
12693 else if (unformat (line_input, "local %U",
12694 unformat_ip4_address, &local4))
12699 else if (unformat (line_input, "remote %U",
12700 unformat_ip4_address, &remote4))
12705 else if (unformat (line_input, "local %U",
12706 unformat_ip6_address, &local6))
12711 else if (unformat (line_input, "remote %U",
12712 unformat_ip6_address, &remote6))
12717 else if (unformat (line_input, "group %U %U",
12718 unformat_ip4_address, &remote4,
12719 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12721 grp_set = remote_set = 1;
12724 else if (unformat (line_input, "group %U",
12725 unformat_ip4_address, &remote4))
12727 grp_set = remote_set = 1;
12730 else if (unformat (line_input, "group %U %U",
12731 unformat_ip6_address, &remote6,
12732 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12734 grp_set = remote_set = 1;
12737 else if (unformat (line_input, "group %U",
12738 unformat_ip6_address, &remote6))
12740 grp_set = remote_set = 1;
12744 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12746 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12748 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12750 else if (unformat (line_input, "vni %d", &vni))
12752 else if (unformat (line_input, "next-ip4"))
12754 else if (unformat (line_input, "next-ip6"))
12756 else if (unformat (line_input, "next-ethernet"))
12758 else if (unformat (line_input, "next-nsh"))
12762 errmsg ("parse error '%U'", format_unformat_error, line_input);
12767 if (local_set == 0)
12769 errmsg ("tunnel local address not specified");
12772 if (remote_set == 0)
12774 errmsg ("tunnel remote address not specified");
12777 if (grp_set && mcast_sw_if_index == ~0)
12779 errmsg ("tunnel nonexistent multicast device");
12782 if (ipv4_set && ipv6_set)
12784 errmsg ("both IPv4 and IPv6 addresses specified");
12790 errmsg ("vni not specified");
12794 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12799 clib_memcpy (&mp->local, &local6, sizeof (local6));
12800 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12804 clib_memcpy (&mp->local, &local4, sizeof (local4));
12805 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12808 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12809 mp->encap_vrf_id = ntohl (encap_vrf_id);
12810 mp->decap_vrf_id = ntohl (decap_vrf_id);
12811 mp->protocol = protocol;
12812 mp->vni = ntohl (vni);
12813 mp->is_add = is_add;
12814 mp->is_ipv6 = ipv6_set;
12821 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12822 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12824 vat_main_t *vam = &vat_main;
12825 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12826 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12828 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12829 ntohl (mp->sw_if_index),
12830 format_ip46_address, &local, IP46_TYPE_ANY,
12831 format_ip46_address, &remote, IP46_TYPE_ANY,
12832 ntohl (mp->vni), mp->protocol,
12833 ntohl (mp->mcast_sw_if_index),
12834 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12838 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12839 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12841 vat_main_t *vam = &vat_main;
12842 vat_json_node_t *node = NULL;
12843 struct in_addr ip4;
12844 struct in6_addr ip6;
12846 if (VAT_JSON_ARRAY != vam->json_tree.type)
12848 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12849 vat_json_init_array (&vam->json_tree);
12851 node = vat_json_array_add (&vam->json_tree);
12853 vat_json_init_object (node);
12854 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12857 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12858 vat_json_object_add_ip6 (node, "local", ip6);
12859 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12860 vat_json_object_add_ip6 (node, "remote", ip6);
12864 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12865 vat_json_object_add_ip4 (node, "local", ip4);
12866 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12867 vat_json_object_add_ip4 (node, "remote", ip4);
12869 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12870 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12871 vat_json_object_add_uint (node, "mcast_sw_if_index",
12872 ntohl (mp->mcast_sw_if_index));
12873 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12874 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12875 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12879 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12881 unformat_input_t *i = vam->input;
12882 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12883 vl_api_control_ping_t *mp_ping;
12885 u8 sw_if_index_set = 0;
12888 /* Parse args required to build the message */
12889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12891 if (unformat (i, "sw_if_index %d", &sw_if_index))
12892 sw_if_index_set = 1;
12897 if (sw_if_index_set == 0)
12902 if (!vam->json_output)
12904 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12905 "sw_if_index", "local", "remote", "vni",
12906 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12909 /* Get list of vxlan-tunnel interfaces */
12910 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12912 mp->sw_if_index = htonl (sw_if_index);
12916 /* Use a control ping for synchronization */
12917 MPING (CONTROL_PING, mp_ping);
12924 static void vl_api_l2_fib_table_details_t_handler
12925 (vl_api_l2_fib_table_details_t * mp)
12927 vat_main_t *vam = &vat_main;
12929 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12931 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12932 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12936 static void vl_api_l2_fib_table_details_t_handler_json
12937 (vl_api_l2_fib_table_details_t * mp)
12939 vat_main_t *vam = &vat_main;
12940 vat_json_node_t *node = NULL;
12942 if (VAT_JSON_ARRAY != vam->json_tree.type)
12944 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12945 vat_json_init_array (&vam->json_tree);
12947 node = vat_json_array_add (&vam->json_tree);
12949 vat_json_init_object (node);
12950 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12951 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12952 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12953 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12954 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12955 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12959 api_l2_fib_table_dump (vat_main_t * vam)
12961 unformat_input_t *i = vam->input;
12962 vl_api_l2_fib_table_dump_t *mp;
12963 vl_api_control_ping_t *mp_ping;
12968 /* Parse args required to build the message */
12969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12971 if (unformat (i, "bd_id %d", &bd_id))
12977 if (bd_id_set == 0)
12979 errmsg ("missing bridge domain");
12983 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12985 /* Get list of l2 fib entries */
12986 M (L2_FIB_TABLE_DUMP, mp);
12988 mp->bd_id = ntohl (bd_id);
12991 /* Use a control ping for synchronization */
12992 MPING (CONTROL_PING, mp_ping);
13001 api_interface_name_renumber (vat_main_t * vam)
13003 unformat_input_t *line_input = vam->input;
13004 vl_api_interface_name_renumber_t *mp;
13005 u32 sw_if_index = ~0;
13006 u32 new_show_dev_instance = ~0;
13009 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13011 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13014 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13016 else if (unformat (line_input, "new_show_dev_instance %d",
13017 &new_show_dev_instance))
13023 if (sw_if_index == ~0)
13025 errmsg ("missing interface name or sw_if_index");
13029 if (new_show_dev_instance == ~0)
13031 errmsg ("missing new_show_dev_instance");
13035 M (INTERFACE_NAME_RENUMBER, mp);
13037 mp->sw_if_index = ntohl (sw_if_index);
13038 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13046 api_want_l2_macs_events (vat_main_t * vam)
13048 unformat_input_t *line_input = vam->input;
13049 vl_api_want_l2_macs_events_t *mp;
13050 u8 enable_disable = 1;
13051 u32 scan_delay = 0;
13052 u32 max_macs_in_event = 0;
13053 u32 learn_limit = 0;
13056 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13058 if (unformat (line_input, "learn-limit %d", &learn_limit))
13060 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13062 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13064 else if (unformat (line_input, "disable"))
13065 enable_disable = 0;
13070 M (WANT_L2_MACS_EVENTS, mp);
13071 mp->enable_disable = enable_disable;
13072 mp->pid = htonl (getpid ());
13073 mp->learn_limit = htonl (learn_limit);
13074 mp->scan_delay = (u8) scan_delay;
13075 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13082 api_input_acl_set_interface (vat_main_t * vam)
13084 unformat_input_t *i = vam->input;
13085 vl_api_input_acl_set_interface_t *mp;
13087 int sw_if_index_set;
13088 u32 ip4_table_index = ~0;
13089 u32 ip6_table_index = ~0;
13090 u32 l2_table_index = ~0;
13094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13096 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13097 sw_if_index_set = 1;
13098 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13099 sw_if_index_set = 1;
13100 else if (unformat (i, "del"))
13102 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13104 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13106 else if (unformat (i, "l2-table %d", &l2_table_index))
13110 clib_warning ("parse error '%U'", format_unformat_error, i);
13115 if (sw_if_index_set == 0)
13117 errmsg ("missing interface name or sw_if_index");
13121 M (INPUT_ACL_SET_INTERFACE, mp);
13123 mp->sw_if_index = ntohl (sw_if_index);
13124 mp->ip4_table_index = ntohl (ip4_table_index);
13125 mp->ip6_table_index = ntohl (ip6_table_index);
13126 mp->l2_table_index = ntohl (l2_table_index);
13127 mp->is_add = is_add;
13135 api_output_acl_set_interface (vat_main_t * vam)
13137 unformat_input_t *i = vam->input;
13138 vl_api_output_acl_set_interface_t *mp;
13140 int sw_if_index_set;
13141 u32 ip4_table_index = ~0;
13142 u32 ip6_table_index = ~0;
13143 u32 l2_table_index = ~0;
13147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13149 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13150 sw_if_index_set = 1;
13151 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13152 sw_if_index_set = 1;
13153 else if (unformat (i, "del"))
13155 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13157 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13159 else if (unformat (i, "l2-table %d", &l2_table_index))
13163 clib_warning ("parse error '%U'", format_unformat_error, i);
13168 if (sw_if_index_set == 0)
13170 errmsg ("missing interface name or sw_if_index");
13174 M (OUTPUT_ACL_SET_INTERFACE, mp);
13176 mp->sw_if_index = ntohl (sw_if_index);
13177 mp->ip4_table_index = ntohl (ip4_table_index);
13178 mp->ip6_table_index = ntohl (ip6_table_index);
13179 mp->l2_table_index = ntohl (l2_table_index);
13180 mp->is_add = is_add;
13188 api_ip_address_dump (vat_main_t * vam)
13190 unformat_input_t *i = vam->input;
13191 vl_api_ip_address_dump_t *mp;
13192 vl_api_control_ping_t *mp_ping;
13193 u32 sw_if_index = ~0;
13194 u8 sw_if_index_set = 0;
13199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13201 if (unformat (i, "sw_if_index %d", &sw_if_index))
13202 sw_if_index_set = 1;
13204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13205 sw_if_index_set = 1;
13206 else if (unformat (i, "ipv4"))
13208 else if (unformat (i, "ipv6"))
13214 if (ipv4_set && ipv6_set)
13216 errmsg ("ipv4 and ipv6 flags cannot be both set");
13220 if ((!ipv4_set) && (!ipv6_set))
13222 errmsg ("no ipv4 nor ipv6 flag set");
13226 if (sw_if_index_set == 0)
13228 errmsg ("missing interface name or sw_if_index");
13232 vam->current_sw_if_index = sw_if_index;
13233 vam->is_ipv6 = ipv6_set;
13235 M (IP_ADDRESS_DUMP, mp);
13236 mp->sw_if_index = ntohl (sw_if_index);
13237 mp->is_ipv6 = ipv6_set;
13240 /* Use a control ping for synchronization */
13241 MPING (CONTROL_PING, mp_ping);
13249 api_ip_dump (vat_main_t * vam)
13251 vl_api_ip_dump_t *mp;
13252 vl_api_control_ping_t *mp_ping;
13253 unformat_input_t *in = vam->input;
13260 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13262 if (unformat (in, "ipv4"))
13264 else if (unformat (in, "ipv6"))
13270 if (ipv4_set && ipv6_set)
13272 errmsg ("ipv4 and ipv6 flags cannot be both set");
13276 if ((!ipv4_set) && (!ipv6_set))
13278 errmsg ("no ipv4 nor ipv6 flag set");
13282 is_ipv6 = ipv6_set;
13283 vam->is_ipv6 = is_ipv6;
13285 /* free old data */
13286 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13288 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13290 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13293 mp->is_ipv6 = ipv6_set;
13296 /* Use a control ping for synchronization */
13297 MPING (CONTROL_PING, mp_ping);
13305 api_ipsec_spd_add_del (vat_main_t * vam)
13307 unformat_input_t *i = vam->input;
13308 vl_api_ipsec_spd_add_del_t *mp;
13313 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13315 if (unformat (i, "spd_id %d", &spd_id))
13317 else if (unformat (i, "del"))
13321 clib_warning ("parse error '%U'", format_unformat_error, i);
13327 errmsg ("spd_id must be set");
13331 M (IPSEC_SPD_ADD_DEL, mp);
13333 mp->spd_id = ntohl (spd_id);
13334 mp->is_add = is_add;
13342 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13344 unformat_input_t *i = vam->input;
13345 vl_api_ipsec_interface_add_del_spd_t *mp;
13347 u8 sw_if_index_set = 0;
13348 u32 spd_id = (u32) ~ 0;
13352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13354 if (unformat (i, "del"))
13356 else if (unformat (i, "spd_id %d", &spd_id))
13359 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13360 sw_if_index_set = 1;
13361 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13362 sw_if_index_set = 1;
13365 clib_warning ("parse error '%U'", format_unformat_error, i);
13371 if (spd_id == (u32) ~ 0)
13373 errmsg ("spd_id must be set");
13377 if (sw_if_index_set == 0)
13379 errmsg ("missing interface name or sw_if_index");
13383 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13385 mp->spd_id = ntohl (spd_id);
13386 mp->sw_if_index = ntohl (sw_if_index);
13387 mp->is_add = is_add;
13395 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13397 unformat_input_t *i = vam->input;
13398 vl_api_ipsec_spd_entry_add_del_t *mp;
13399 u8 is_add = 1, is_outbound = 0;
13400 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13402 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13403 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13404 vl_api_address_t laddr_start = { }, laddr_stop =
13413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13415 if (unformat (i, "del"))
13417 if (unformat (i, "outbound"))
13419 if (unformat (i, "inbound"))
13421 else if (unformat (i, "spd_id %d", &spd_id))
13423 else if (unformat (i, "sa_id %d", &sa_id))
13425 else if (unformat (i, "priority %d", &priority))
13427 else if (unformat (i, "protocol %d", &protocol))
13429 else if (unformat (i, "lport_start %d", &lport_start))
13431 else if (unformat (i, "lport_stop %d", &lport_stop))
13433 else if (unformat (i, "rport_start %d", &rport_start))
13435 else if (unformat (i, "rport_stop %d", &rport_stop))
13437 else if (unformat (i, "laddr_start %U",
13438 unformat_vl_api_address, &laddr_start))
13440 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13443 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13446 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13450 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13452 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13454 clib_warning ("unsupported action: 'resolve'");
13460 clib_warning ("parse error '%U'", format_unformat_error, i);
13466 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13468 mp->is_add = is_add;
13470 mp->entry.spd_id = ntohl (spd_id);
13471 mp->entry.priority = ntohl (priority);
13472 mp->entry.is_outbound = is_outbound;
13474 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13475 sizeof (vl_api_address_t));
13476 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13477 sizeof (vl_api_address_t));
13478 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13479 sizeof (vl_api_address_t));
13480 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13481 sizeof (vl_api_address_t));
13483 mp->entry.protocol = (u8) protocol;
13484 mp->entry.local_port_start = ntohs ((u16) lport_start);
13485 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13486 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13487 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13488 mp->entry.policy = (u8) policy;
13489 mp->entry.sa_id = ntohl (sa_id);
13497 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13499 unformat_input_t *i = vam->input;
13500 vl_api_ipsec_sad_entry_add_del_t *mp;
13501 u32 sad_id = 0, spi = 0;
13502 u8 *ck = 0, *ik = 0;
13505 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13506 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13507 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13508 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13509 vl_api_address_t tun_src, tun_dst;
13512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13514 if (unformat (i, "del"))
13516 else if (unformat (i, "sad_id %d", &sad_id))
13518 else if (unformat (i, "spi %d", &spi))
13520 else if (unformat (i, "esp"))
13521 protocol = IPSEC_API_PROTO_ESP;
13523 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13525 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13526 if (ADDRESS_IP6 == tun_src.af)
13527 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13530 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13532 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13533 if (ADDRESS_IP6 == tun_src.af)
13534 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13537 if (unformat (i, "crypto_alg %U",
13538 unformat_ipsec_api_crypto_alg, &crypto_alg))
13540 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13542 else if (unformat (i, "integ_alg %U",
13543 unformat_ipsec_api_integ_alg, &integ_alg))
13545 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13549 clib_warning ("parse error '%U'", format_unformat_error, i);
13555 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13557 mp->is_add = is_add;
13558 mp->entry.sad_id = ntohl (sad_id);
13559 mp->entry.protocol = protocol;
13560 mp->entry.spi = ntohl (spi);
13561 mp->entry.flags = flags;
13563 mp->entry.crypto_algorithm = crypto_alg;
13564 mp->entry.integrity_algorithm = integ_alg;
13565 mp->entry.crypto_key.length = vec_len (ck);
13566 mp->entry.integrity_key.length = vec_len (ik);
13568 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13569 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13571 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13572 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13575 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13577 clib_memcpy (mp->entry.integrity_key.data, ik,
13578 mp->entry.integrity_key.length);
13580 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13582 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13583 sizeof (mp->entry.tunnel_src));
13584 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13585 sizeof (mp->entry.tunnel_dst));
13594 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13596 unformat_input_t *i = vam->input;
13597 vl_api_ipsec_tunnel_if_add_del_t *mp;
13598 u32 local_spi = 0, remote_spi = 0;
13599 u32 crypto_alg = 0, integ_alg = 0;
13600 u8 *lck = NULL, *rck = NULL;
13601 u8 *lik = NULL, *rik = NULL;
13602 vl_api_address_t local_ip = { 0 };
13603 vl_api_address_t remote_ip = { 0 };
13607 u8 anti_replay = 0;
13613 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13615 if (unformat (i, "del"))
13617 else if (unformat (i, "esn"))
13619 else if (unformat (i, "anti-replay"))
13621 else if (unformat (i, "count %d", &count))
13623 else if (unformat (i, "local_spi %d", &local_spi))
13625 else if (unformat (i, "remote_spi %d", &remote_spi))
13628 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13631 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13633 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13636 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13638 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13640 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13644 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13646 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13648 errmsg ("unsupported crypto-alg: '%U'\n",
13649 format_ipsec_crypto_alg, crypto_alg);
13655 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13657 if (integ_alg >= IPSEC_INTEG_N_ALG)
13659 errmsg ("unsupported integ-alg: '%U'\n",
13660 format_ipsec_integ_alg, integ_alg);
13664 else if (unformat (i, "instance %u", &instance))
13668 errmsg ("parse error '%U'\n", format_unformat_error, i);
13675 /* Turn on async mode */
13676 vam->async_mode = 1;
13677 vam->async_errors = 0;
13678 before = vat_time_now (vam);
13681 for (jj = 0; jj < count; jj++)
13683 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13685 mp->is_add = is_add;
13687 mp->anti_replay = anti_replay;
13690 increment_address (&remote_ip);
13692 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13693 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13695 mp->local_spi = htonl (local_spi + jj);
13696 mp->remote_spi = htonl (remote_spi + jj);
13697 mp->crypto_alg = (u8) crypto_alg;
13699 mp->local_crypto_key_len = 0;
13702 mp->local_crypto_key_len = vec_len (lck);
13703 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13704 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13705 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13708 mp->remote_crypto_key_len = 0;
13711 mp->remote_crypto_key_len = vec_len (rck);
13712 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13713 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13714 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13717 mp->integ_alg = (u8) integ_alg;
13719 mp->local_integ_key_len = 0;
13722 mp->local_integ_key_len = vec_len (lik);
13723 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13724 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13725 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13728 mp->remote_integ_key_len = 0;
13731 mp->remote_integ_key_len = vec_len (rik);
13732 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13733 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13734 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13739 mp->renumber = renumber;
13740 mp->show_instance = ntohl (instance);
13745 /* When testing multiple add/del ops, use a control-ping to sync */
13748 vl_api_control_ping_t *mp_ping;
13752 /* Shut off async mode */
13753 vam->async_mode = 0;
13755 MPING (CONTROL_PING, mp_ping);
13758 timeout = vat_time_now (vam) + 1.0;
13759 while (vat_time_now (vam) < timeout)
13760 if (vam->result_ready == 1)
13765 if (vam->retval == -99)
13766 errmsg ("timeout");
13768 if (vam->async_errors > 0)
13770 errmsg ("%d asynchronous errors", vam->async_errors);
13773 vam->async_errors = 0;
13774 after = vat_time_now (vam);
13776 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13780 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13781 count, after - before, count / (after - before));
13785 /* Wait for a reply... */
13794 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13796 vat_main_t *vam = &vat_main;
13798 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13799 "crypto_key %U integ_alg %u integ_key %U flags %x "
13800 "tunnel_src_addr %U tunnel_dst_addr %U "
13801 "salt %u seq_outbound %lu last_seq_inbound %lu "
13802 "replay_window %lu\n",
13803 ntohl (mp->entry.sad_id),
13804 ntohl (mp->sw_if_index),
13805 ntohl (mp->entry.spi),
13806 ntohl (mp->entry.protocol),
13807 ntohl (mp->entry.crypto_algorithm),
13808 format_hex_bytes, mp->entry.crypto_key.data,
13809 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13810 format_hex_bytes, mp->entry.integrity_key.data,
13811 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13812 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13813 &mp->entry.tunnel_dst, ntohl (mp->salt),
13814 clib_net_to_host_u64 (mp->seq_outbound),
13815 clib_net_to_host_u64 (mp->last_seq_inbound),
13816 clib_net_to_host_u64 (mp->replay_window));
13819 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13820 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13822 static void vl_api_ipsec_sa_details_t_handler_json
13823 (vl_api_ipsec_sa_details_t * mp)
13825 vat_main_t *vam = &vat_main;
13826 vat_json_node_t *node = NULL;
13827 vl_api_ipsec_sad_flags_t flags;
13829 if (VAT_JSON_ARRAY != vam->json_tree.type)
13831 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13832 vat_json_init_array (&vam->json_tree);
13834 node = vat_json_array_add (&vam->json_tree);
13836 vat_json_init_object (node);
13837 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13838 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13839 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13840 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13841 vat_json_object_add_uint (node, "crypto_alg",
13842 ntohl (mp->entry.crypto_algorithm));
13843 vat_json_object_add_uint (node, "integ_alg",
13844 ntohl (mp->entry.integrity_algorithm));
13845 flags = ntohl (mp->entry.flags);
13846 vat_json_object_add_uint (node, "use_esn",
13847 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13848 vat_json_object_add_uint (node, "use_anti_replay",
13849 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13850 vat_json_object_add_uint (node, "is_tunnel",
13851 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13852 vat_json_object_add_uint (node, "is_tunnel_ip6",
13853 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13854 vat_json_object_add_uint (node, "udp_encap",
13855 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13856 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13857 mp->entry.crypto_key.length);
13858 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13859 mp->entry.integrity_key.length);
13860 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13861 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13862 vat_json_object_add_uint (node, "replay_window",
13863 clib_net_to_host_u64 (mp->replay_window));
13867 api_ipsec_sa_dump (vat_main_t * vam)
13869 unformat_input_t *i = vam->input;
13870 vl_api_ipsec_sa_dump_t *mp;
13871 vl_api_control_ping_t *mp_ping;
13875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13877 if (unformat (i, "sa_id %d", &sa_id))
13881 clib_warning ("parse error '%U'", format_unformat_error, i);
13886 M (IPSEC_SA_DUMP, mp);
13888 mp->sa_id = ntohl (sa_id);
13892 /* Use a control ping for synchronization */
13893 M (CONTROL_PING, mp_ping);
13901 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13903 unformat_input_t *i = vam->input;
13904 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13905 u32 sw_if_index = ~0;
13907 u8 is_outbound = (u8) ~ 0;
13910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13914 else if (unformat (i, "sa_id %d", &sa_id))
13916 else if (unformat (i, "outbound"))
13918 else if (unformat (i, "inbound"))
13922 clib_warning ("parse error '%U'", format_unformat_error, i);
13927 if (sw_if_index == ~0)
13929 errmsg ("interface must be specified");
13935 errmsg ("SA ID must be specified");
13939 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13941 mp->sw_if_index = htonl (sw_if_index);
13942 mp->sa_id = htonl (sa_id);
13943 mp->is_outbound = is_outbound;
13952 api_get_first_msg_id (vat_main_t * vam)
13954 vl_api_get_first_msg_id_t *mp;
13955 unformat_input_t *i = vam->input;
13960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13962 if (unformat (i, "client %s", &name))
13970 errmsg ("missing client name");
13973 vec_add1 (name, 0);
13975 if (vec_len (name) > 63)
13977 errmsg ("client name too long");
13981 M (GET_FIRST_MSG_ID, mp);
13982 clib_memcpy (mp->name, name, vec_len (name));
13989 api_cop_interface_enable_disable (vat_main_t * vam)
13991 unformat_input_t *line_input = vam->input;
13992 vl_api_cop_interface_enable_disable_t *mp;
13993 u32 sw_if_index = ~0;
13994 u8 enable_disable = 1;
13997 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13999 if (unformat (line_input, "disable"))
14000 enable_disable = 0;
14001 if (unformat (line_input, "enable"))
14002 enable_disable = 1;
14003 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14004 vam, &sw_if_index))
14006 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14012 if (sw_if_index == ~0)
14014 errmsg ("missing interface name or sw_if_index");
14018 /* Construct the API message */
14019 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14020 mp->sw_if_index = ntohl (sw_if_index);
14021 mp->enable_disable = enable_disable;
14025 /* Wait for the reply */
14031 api_cop_whitelist_enable_disable (vat_main_t * vam)
14033 unformat_input_t *line_input = vam->input;
14034 vl_api_cop_whitelist_enable_disable_t *mp;
14035 u32 sw_if_index = ~0;
14036 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14040 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14042 if (unformat (line_input, "ip4"))
14044 else if (unformat (line_input, "ip6"))
14046 else if (unformat (line_input, "default"))
14048 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14049 vam, &sw_if_index))
14051 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14053 else if (unformat (line_input, "fib-id %d", &fib_id))
14059 if (sw_if_index == ~0)
14061 errmsg ("missing interface name or sw_if_index");
14065 /* Construct the API message */
14066 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14067 mp->sw_if_index = ntohl (sw_if_index);
14068 mp->fib_id = ntohl (fib_id);
14071 mp->default_cop = default_cop;
14075 /* Wait for the reply */
14081 api_get_node_graph (vat_main_t * vam)
14083 vl_api_get_node_graph_t *mp;
14086 M (GET_NODE_GRAPH, mp);
14090 /* Wait for the reply */
14096 /** Used for parsing LISP eids */
14097 typedef CLIB_PACKED(struct{
14098 u8 addr[16]; /**< eid address */
14099 u32 len; /**< prefix length if IP */
14100 u8 type; /**< type of eid */
14105 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14107 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14109 clib_memset (a, 0, sizeof (a[0]));
14111 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14113 a->type = 0; /* ipv4 type */
14115 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14117 a->type = 1; /* ipv6 type */
14119 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14121 a->type = 2; /* mac type */
14123 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14125 a->type = 3; /* NSH type */
14126 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14127 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14134 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14143 lisp_eid_size_vat (u8 type)
14160 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14162 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14166 api_one_add_del_locator_set (vat_main_t * vam)
14168 unformat_input_t *input = vam->input;
14169 vl_api_one_add_del_locator_set_t *mp;
14171 u8 *locator_set_name = NULL;
14172 u8 locator_set_name_set = 0;
14173 vl_api_local_locator_t locator, *locators = 0;
14174 u32 sw_if_index, priority, weight;
14178 /* Parse args required to build the message */
14179 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14181 if (unformat (input, "del"))
14185 else if (unformat (input, "locator-set %s", &locator_set_name))
14187 locator_set_name_set = 1;
14189 else if (unformat (input, "sw_if_index %u p %u w %u",
14190 &sw_if_index, &priority, &weight))
14192 locator.sw_if_index = htonl (sw_if_index);
14193 locator.priority = priority;
14194 locator.weight = weight;
14195 vec_add1 (locators, locator);
14199 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14200 &sw_if_index, &priority, &weight))
14202 locator.sw_if_index = htonl (sw_if_index);
14203 locator.priority = priority;
14204 locator.weight = weight;
14205 vec_add1 (locators, locator);
14211 if (locator_set_name_set == 0)
14213 errmsg ("missing locator-set name");
14214 vec_free (locators);
14218 if (vec_len (locator_set_name) > 64)
14220 errmsg ("locator-set name too long");
14221 vec_free (locator_set_name);
14222 vec_free (locators);
14225 vec_add1 (locator_set_name, 0);
14227 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14229 /* Construct the API message */
14230 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14232 mp->is_add = is_add;
14233 clib_memcpy (mp->locator_set_name, locator_set_name,
14234 vec_len (locator_set_name));
14235 vec_free (locator_set_name);
14237 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14239 clib_memcpy (mp->locators, locators, data_len);
14240 vec_free (locators);
14245 /* Wait for a reply... */
14250 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14253 api_one_add_del_locator (vat_main_t * vam)
14255 unformat_input_t *input = vam->input;
14256 vl_api_one_add_del_locator_t *mp;
14257 u32 tmp_if_index = ~0;
14258 u32 sw_if_index = ~0;
14259 u8 sw_if_index_set = 0;
14260 u8 sw_if_index_if_name_set = 0;
14262 u8 priority_set = 0;
14266 u8 *locator_set_name = NULL;
14267 u8 locator_set_name_set = 0;
14270 /* Parse args required to build the message */
14271 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14273 if (unformat (input, "del"))
14277 else if (unformat (input, "locator-set %s", &locator_set_name))
14279 locator_set_name_set = 1;
14281 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14284 sw_if_index_if_name_set = 1;
14285 sw_if_index = tmp_if_index;
14287 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14289 sw_if_index_set = 1;
14290 sw_if_index = tmp_if_index;
14292 else if (unformat (input, "p %d", &priority))
14296 else if (unformat (input, "w %d", &weight))
14304 if (locator_set_name_set == 0)
14306 errmsg ("missing locator-set name");
14310 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14312 errmsg ("missing sw_if_index");
14313 vec_free (locator_set_name);
14317 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14319 errmsg ("cannot use both params interface name and sw_if_index");
14320 vec_free (locator_set_name);
14324 if (priority_set == 0)
14326 errmsg ("missing locator-set priority");
14327 vec_free (locator_set_name);
14331 if (weight_set == 0)
14333 errmsg ("missing locator-set weight");
14334 vec_free (locator_set_name);
14338 if (vec_len (locator_set_name) > 64)
14340 errmsg ("locator-set name too long");
14341 vec_free (locator_set_name);
14344 vec_add1 (locator_set_name, 0);
14346 /* Construct the API message */
14347 M (ONE_ADD_DEL_LOCATOR, mp);
14349 mp->is_add = is_add;
14350 mp->sw_if_index = ntohl (sw_if_index);
14351 mp->priority = priority;
14352 mp->weight = weight;
14353 clib_memcpy (mp->locator_set_name, locator_set_name,
14354 vec_len (locator_set_name));
14355 vec_free (locator_set_name);
14360 /* Wait for a reply... */
14365 #define api_lisp_add_del_locator api_one_add_del_locator
14368 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14370 u32 *key_id = va_arg (*args, u32 *);
14373 if (unformat (input, "%s", &s))
14375 if (!strcmp ((char *) s, "sha1"))
14376 key_id[0] = HMAC_SHA_1_96;
14377 else if (!strcmp ((char *) s, "sha256"))
14378 key_id[0] = HMAC_SHA_256_128;
14381 clib_warning ("invalid key_id: '%s'", s);
14382 key_id[0] = HMAC_NO_KEY;
14393 api_one_add_del_local_eid (vat_main_t * vam)
14395 unformat_input_t *input = vam->input;
14396 vl_api_one_add_del_local_eid_t *mp;
14399 lisp_eid_vat_t _eid, *eid = &_eid;
14400 u8 *locator_set_name = 0;
14401 u8 locator_set_name_set = 0;
14407 /* Parse args required to build the message */
14408 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14410 if (unformat (input, "del"))
14414 else if (unformat (input, "vni %d", &vni))
14418 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14422 else if (unformat (input, "locator-set %s", &locator_set_name))
14424 locator_set_name_set = 1;
14426 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14428 else if (unformat (input, "secret-key %_%v%_", &key))
14434 if (locator_set_name_set == 0)
14436 errmsg ("missing locator-set name");
14442 errmsg ("EID address not set!");
14443 vec_free (locator_set_name);
14447 if (key && (0 == key_id))
14449 errmsg ("invalid key_id!");
14453 if (vec_len (key) > 64)
14455 errmsg ("key too long");
14460 if (vec_len (locator_set_name) > 64)
14462 errmsg ("locator-set name too long");
14463 vec_free (locator_set_name);
14466 vec_add1 (locator_set_name, 0);
14468 /* Construct the API message */
14469 M (ONE_ADD_DEL_LOCAL_EID, mp);
14471 mp->is_add = is_add;
14472 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14473 mp->eid_type = eid->type;
14474 mp->prefix_len = eid->len;
14475 mp->vni = clib_host_to_net_u32 (vni);
14476 mp->key_id = clib_host_to_net_u16 (key_id);
14477 clib_memcpy (mp->locator_set_name, locator_set_name,
14478 vec_len (locator_set_name));
14479 clib_memcpy (mp->key, key, vec_len (key));
14481 vec_free (locator_set_name);
14487 /* Wait for a reply... */
14492 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14495 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14497 u32 dp_table = 0, vni = 0;;
14498 unformat_input_t *input = vam->input;
14499 vl_api_gpe_add_del_fwd_entry_t *mp;
14501 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14502 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14503 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14504 u32 action = ~0, w;
14505 ip4_address_t rmt_rloc4, lcl_rloc4;
14506 ip6_address_t rmt_rloc6, lcl_rloc6;
14507 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14510 clib_memset (&rloc, 0, sizeof (rloc));
14512 /* Parse args required to build the message */
14513 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14515 if (unformat (input, "del"))
14517 else if (unformat (input, "add"))
14519 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14523 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14527 else if (unformat (input, "vrf %d", &dp_table))
14529 else if (unformat (input, "bd %d", &dp_table))
14531 else if (unformat (input, "vni %d", &vni))
14533 else if (unformat (input, "w %d", &w))
14537 errmsg ("No RLOC configured for setting priority/weight!");
14540 curr_rloc->weight = w;
14542 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14543 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14547 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14549 vec_add1 (lcl_locs, rloc);
14551 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14552 vec_add1 (rmt_locs, rloc);
14553 /* weight saved in rmt loc */
14554 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14556 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14557 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14560 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14562 vec_add1 (lcl_locs, rloc);
14564 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14565 vec_add1 (rmt_locs, rloc);
14566 /* weight saved in rmt loc */
14567 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14569 else if (unformat (input, "action %d", &action))
14575 clib_warning ("parse error '%U'", format_unformat_error, input);
14582 errmsg ("remote eid addresses not set");
14586 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14588 errmsg ("eid types don't match");
14592 if (0 == rmt_locs && (u32) ~ 0 == action)
14594 errmsg ("action not set for negative mapping");
14598 /* Construct the API message */
14599 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14600 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14602 mp->is_add = is_add;
14603 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14604 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14605 mp->eid_type = rmt_eid->type;
14606 mp->dp_table = clib_host_to_net_u32 (dp_table);
14607 mp->vni = clib_host_to_net_u32 (vni);
14608 mp->rmt_len = rmt_eid->len;
14609 mp->lcl_len = lcl_eid->len;
14610 mp->action = action;
14612 if (0 != rmt_locs && 0 != lcl_locs)
14614 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14615 clib_memcpy (mp->locs, lcl_locs,
14616 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14618 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14619 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14620 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14622 vec_free (lcl_locs);
14623 vec_free (rmt_locs);
14628 /* Wait for a reply... */
14634 api_one_add_del_map_server (vat_main_t * vam)
14636 unformat_input_t *input = vam->input;
14637 vl_api_one_add_del_map_server_t *mp;
14641 ip4_address_t ipv4;
14642 ip6_address_t ipv6;
14645 /* Parse args required to build the message */
14646 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14648 if (unformat (input, "del"))
14652 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14656 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14664 if (ipv4_set && ipv6_set)
14666 errmsg ("both eid v4 and v6 addresses set");
14670 if (!ipv4_set && !ipv6_set)
14672 errmsg ("eid addresses not set");
14676 /* Construct the API message */
14677 M (ONE_ADD_DEL_MAP_SERVER, mp);
14679 mp->is_add = is_add;
14683 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14688 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14694 /* Wait for a reply... */
14699 #define api_lisp_add_del_map_server api_one_add_del_map_server
14702 api_one_add_del_map_resolver (vat_main_t * vam)
14704 unformat_input_t *input = vam->input;
14705 vl_api_one_add_del_map_resolver_t *mp;
14709 ip4_address_t ipv4;
14710 ip6_address_t ipv6;
14713 /* Parse args required to build the message */
14714 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14716 if (unformat (input, "del"))
14720 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14724 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14732 if (ipv4_set && ipv6_set)
14734 errmsg ("both eid v4 and v6 addresses set");
14738 if (!ipv4_set && !ipv6_set)
14740 errmsg ("eid addresses not set");
14744 /* Construct the API message */
14745 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14747 mp->is_add = is_add;
14751 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14756 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14762 /* Wait for a reply... */
14767 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14770 api_lisp_gpe_enable_disable (vat_main_t * vam)
14772 unformat_input_t *input = vam->input;
14773 vl_api_gpe_enable_disable_t *mp;
14778 /* Parse args required to build the message */
14779 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14781 if (unformat (input, "enable"))
14786 else if (unformat (input, "disable"))
14797 errmsg ("Value not set");
14801 /* Construct the API message */
14802 M (GPE_ENABLE_DISABLE, mp);
14809 /* Wait for a reply... */
14815 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14817 unformat_input_t *input = vam->input;
14818 vl_api_one_rloc_probe_enable_disable_t *mp;
14823 /* Parse args required to build the message */
14824 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14826 if (unformat (input, "enable"))
14831 else if (unformat (input, "disable"))
14839 errmsg ("Value not set");
14843 /* Construct the API message */
14844 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14846 mp->is_enabled = is_en;
14851 /* Wait for a reply... */
14856 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14859 api_one_map_register_enable_disable (vat_main_t * vam)
14861 unformat_input_t *input = vam->input;
14862 vl_api_one_map_register_enable_disable_t *mp;
14867 /* Parse args required to build the message */
14868 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14870 if (unformat (input, "enable"))
14875 else if (unformat (input, "disable"))
14883 errmsg ("Value not set");
14887 /* Construct the API message */
14888 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14890 mp->is_enabled = is_en;
14895 /* Wait for a reply... */
14900 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14903 api_one_enable_disable (vat_main_t * vam)
14905 unformat_input_t *input = vam->input;
14906 vl_api_one_enable_disable_t *mp;
14911 /* Parse args required to build the message */
14912 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14914 if (unformat (input, "enable"))
14919 else if (unformat (input, "disable"))
14929 errmsg ("Value not set");
14933 /* Construct the API message */
14934 M (ONE_ENABLE_DISABLE, mp);
14941 /* Wait for a reply... */
14946 #define api_lisp_enable_disable api_one_enable_disable
14949 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14951 unformat_input_t *input = vam->input;
14952 vl_api_one_enable_disable_xtr_mode_t *mp;
14957 /* Parse args required to build the message */
14958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14960 if (unformat (input, "enable"))
14965 else if (unformat (input, "disable"))
14975 errmsg ("Value not set");
14979 /* Construct the API message */
14980 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
14987 /* Wait for a reply... */
14993 api_one_show_xtr_mode (vat_main_t * vam)
14995 vl_api_one_show_xtr_mode_t *mp;
14998 /* Construct the API message */
14999 M (ONE_SHOW_XTR_MODE, mp);
15004 /* Wait for a reply... */
15010 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15012 unformat_input_t *input = vam->input;
15013 vl_api_one_enable_disable_pitr_mode_t *mp;
15018 /* Parse args required to build the message */
15019 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15021 if (unformat (input, "enable"))
15026 else if (unformat (input, "disable"))
15036 errmsg ("Value not set");
15040 /* Construct the API message */
15041 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15048 /* Wait for a reply... */
15054 api_one_show_pitr_mode (vat_main_t * vam)
15056 vl_api_one_show_pitr_mode_t *mp;
15059 /* Construct the API message */
15060 M (ONE_SHOW_PITR_MODE, mp);
15065 /* Wait for a reply... */
15071 api_one_enable_disable_petr_mode (vat_main_t * vam)
15073 unformat_input_t *input = vam->input;
15074 vl_api_one_enable_disable_petr_mode_t *mp;
15079 /* Parse args required to build the message */
15080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15082 if (unformat (input, "enable"))
15087 else if (unformat (input, "disable"))
15097 errmsg ("Value not set");
15101 /* Construct the API message */
15102 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15109 /* Wait for a reply... */
15115 api_one_show_petr_mode (vat_main_t * vam)
15117 vl_api_one_show_petr_mode_t *mp;
15120 /* Construct the API message */
15121 M (ONE_SHOW_PETR_MODE, mp);
15126 /* Wait for a reply... */
15132 api_show_one_map_register_state (vat_main_t * vam)
15134 vl_api_show_one_map_register_state_t *mp;
15137 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15142 /* wait for reply */
15147 #define api_show_lisp_map_register_state api_show_one_map_register_state
15150 api_show_one_rloc_probe_state (vat_main_t * vam)
15152 vl_api_show_one_rloc_probe_state_t *mp;
15155 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15160 /* wait for reply */
15165 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15168 api_one_add_del_ndp_entry (vat_main_t * vam)
15170 vl_api_one_add_del_ndp_entry_t *mp;
15171 unformat_input_t *input = vam->input;
15176 u8 mac[6] = { 0, };
15177 u8 ip6[16] = { 0, };
15181 /* Parse args required to build the message */
15182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15184 if (unformat (input, "del"))
15186 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15188 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15190 else if (unformat (input, "bd %d", &bd))
15194 errmsg ("parse error '%U'", format_unformat_error, input);
15199 if (!bd_set || !ip_set || (!mac_set && is_add))
15201 errmsg ("Missing BD, IP or MAC!");
15205 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15206 mp->is_add = is_add;
15207 clib_memcpy (mp->mac, mac, 6);
15208 mp->bd = clib_host_to_net_u32 (bd);
15209 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15214 /* wait for reply */
15220 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15222 vl_api_one_add_del_l2_arp_entry_t *mp;
15223 unformat_input_t *input = vam->input;
15228 u8 mac[6] = { 0, };
15229 u32 ip4 = 0, bd = ~0;
15232 /* Parse args required to build the message */
15233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15235 if (unformat (input, "del"))
15237 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15239 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15241 else if (unformat (input, "bd %d", &bd))
15245 errmsg ("parse error '%U'", format_unformat_error, input);
15250 if (!bd_set || !ip_set || (!mac_set && is_add))
15252 errmsg ("Missing BD, IP or MAC!");
15256 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15257 mp->is_add = is_add;
15258 clib_memcpy (mp->mac, mac, 6);
15259 mp->bd = clib_host_to_net_u32 (bd);
15265 /* wait for reply */
15271 api_one_ndp_bd_get (vat_main_t * vam)
15273 vl_api_one_ndp_bd_get_t *mp;
15276 M (ONE_NDP_BD_GET, mp);
15281 /* wait for reply */
15287 api_one_ndp_entries_get (vat_main_t * vam)
15289 vl_api_one_ndp_entries_get_t *mp;
15290 unformat_input_t *input = vam->input;
15295 /* Parse args required to build the message */
15296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15298 if (unformat (input, "bd %d", &bd))
15302 errmsg ("parse error '%U'", format_unformat_error, input);
15309 errmsg ("Expected bridge domain!");
15313 M (ONE_NDP_ENTRIES_GET, mp);
15314 mp->bd = clib_host_to_net_u32 (bd);
15319 /* wait for reply */
15325 api_one_l2_arp_bd_get (vat_main_t * vam)
15327 vl_api_one_l2_arp_bd_get_t *mp;
15330 M (ONE_L2_ARP_BD_GET, mp);
15335 /* wait for reply */
15341 api_one_l2_arp_entries_get (vat_main_t * vam)
15343 vl_api_one_l2_arp_entries_get_t *mp;
15344 unformat_input_t *input = vam->input;
15349 /* Parse args required to build the message */
15350 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15352 if (unformat (input, "bd %d", &bd))
15356 errmsg ("parse error '%U'", format_unformat_error, input);
15363 errmsg ("Expected bridge domain!");
15367 M (ONE_L2_ARP_ENTRIES_GET, mp);
15368 mp->bd = clib_host_to_net_u32 (bd);
15373 /* wait for reply */
15379 api_one_stats_enable_disable (vat_main_t * vam)
15381 vl_api_one_stats_enable_disable_t *mp;
15382 unformat_input_t *input = vam->input;
15387 /* Parse args required to build the message */
15388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15390 if (unformat (input, "enable"))
15395 else if (unformat (input, "disable"))
15405 errmsg ("Value not set");
15409 M (ONE_STATS_ENABLE_DISABLE, mp);
15415 /* wait for reply */
15421 api_show_one_stats_enable_disable (vat_main_t * vam)
15423 vl_api_show_one_stats_enable_disable_t *mp;
15426 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15431 /* wait for reply */
15437 api_show_one_map_request_mode (vat_main_t * vam)
15439 vl_api_show_one_map_request_mode_t *mp;
15442 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15447 /* wait for reply */
15452 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15455 api_one_map_request_mode (vat_main_t * vam)
15457 unformat_input_t *input = vam->input;
15458 vl_api_one_map_request_mode_t *mp;
15462 /* Parse args required to build the message */
15463 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15465 if (unformat (input, "dst-only"))
15467 else if (unformat (input, "src-dst"))
15471 errmsg ("parse error '%U'", format_unformat_error, input);
15476 M (ONE_MAP_REQUEST_MODE, mp);
15483 /* wait for reply */
15488 #define api_lisp_map_request_mode api_one_map_request_mode
15491 * Enable/disable ONE proxy ITR.
15493 * @param vam vpp API test context
15494 * @return return code
15497 api_one_pitr_set_locator_set (vat_main_t * vam)
15499 u8 ls_name_set = 0;
15500 unformat_input_t *input = vam->input;
15501 vl_api_one_pitr_set_locator_set_t *mp;
15506 /* Parse args required to build the message */
15507 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15509 if (unformat (input, "del"))
15511 else if (unformat (input, "locator-set %s", &ls_name))
15515 errmsg ("parse error '%U'", format_unformat_error, input);
15522 errmsg ("locator-set name not set!");
15526 M (ONE_PITR_SET_LOCATOR_SET, mp);
15528 mp->is_add = is_add;
15529 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15530 vec_free (ls_name);
15535 /* wait for reply */
15540 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15543 api_one_nsh_set_locator_set (vat_main_t * vam)
15545 u8 ls_name_set = 0;
15546 unformat_input_t *input = vam->input;
15547 vl_api_one_nsh_set_locator_set_t *mp;
15552 /* Parse args required to build the message */
15553 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15555 if (unformat (input, "del"))
15557 else if (unformat (input, "ls %s", &ls_name))
15561 errmsg ("parse error '%U'", format_unformat_error, input);
15566 if (!ls_name_set && is_add)
15568 errmsg ("locator-set name not set!");
15572 M (ONE_NSH_SET_LOCATOR_SET, mp);
15574 mp->is_add = is_add;
15575 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15576 vec_free (ls_name);
15581 /* wait for reply */
15587 api_show_one_pitr (vat_main_t * vam)
15589 vl_api_show_one_pitr_t *mp;
15592 if (!vam->json_output)
15594 print (vam->ofp, "%=20s", "lisp status:");
15597 M (SHOW_ONE_PITR, mp);
15601 /* Wait for a reply... */
15606 #define api_show_lisp_pitr api_show_one_pitr
15609 api_one_use_petr (vat_main_t * vam)
15611 unformat_input_t *input = vam->input;
15612 vl_api_one_use_petr_t *mp;
15617 clib_memset (&ip, 0, sizeof (ip));
15619 /* Parse args required to build the message */
15620 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15622 if (unformat (input, "disable"))
15625 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15628 ip_addr_version (&ip) = AF_IP4;
15631 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15634 ip_addr_version (&ip) = AF_IP6;
15638 errmsg ("parse error '%U'", format_unformat_error, input);
15643 M (ONE_USE_PETR, mp);
15645 mp->is_add = is_add;
15648 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15650 clib_memcpy (mp->address, &ip, 4);
15652 clib_memcpy (mp->address, &ip, 16);
15658 /* wait for reply */
15663 #define api_lisp_use_petr api_one_use_petr
15666 api_show_one_nsh_mapping (vat_main_t * vam)
15668 vl_api_show_one_use_petr_t *mp;
15671 if (!vam->json_output)
15673 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15676 M (SHOW_ONE_NSH_MAPPING, mp);
15680 /* Wait for a reply... */
15686 api_show_one_use_petr (vat_main_t * vam)
15688 vl_api_show_one_use_petr_t *mp;
15691 if (!vam->json_output)
15693 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15696 M (SHOW_ONE_USE_PETR, mp);
15700 /* Wait for a reply... */
15705 #define api_show_lisp_use_petr api_show_one_use_petr
15708 * Add/delete mapping between vni and vrf
15711 api_one_eid_table_add_del_map (vat_main_t * vam)
15713 unformat_input_t *input = vam->input;
15714 vl_api_one_eid_table_add_del_map_t *mp;
15715 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15716 u32 vni, vrf, bd_index;
15719 /* Parse args required to build the message */
15720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15722 if (unformat (input, "del"))
15724 else if (unformat (input, "vrf %d", &vrf))
15726 else if (unformat (input, "bd_index %d", &bd_index))
15728 else if (unformat (input, "vni %d", &vni))
15734 if (!vni_set || (!vrf_set && !bd_index_set))
15736 errmsg ("missing arguments!");
15740 if (vrf_set && bd_index_set)
15742 errmsg ("error: both vrf and bd entered!");
15746 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15748 mp->is_add = is_add;
15749 mp->vni = htonl (vni);
15750 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15751 mp->is_l2 = bd_index_set;
15756 /* wait for reply */
15761 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15764 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15766 u32 *action = va_arg (*args, u32 *);
15769 if (unformat (input, "%s", &s))
15771 if (!strcmp ((char *) s, "no-action"))
15773 else if (!strcmp ((char *) s, "natively-forward"))
15775 else if (!strcmp ((char *) s, "send-map-request"))
15777 else if (!strcmp ((char *) s, "drop"))
15781 clib_warning ("invalid action: '%s'", s);
15793 * Add/del remote mapping to/from ONE control plane
15795 * @param vam vpp API test context
15796 * @return return code
15799 api_one_add_del_remote_mapping (vat_main_t * vam)
15801 unformat_input_t *input = vam->input;
15802 vl_api_one_add_del_remote_mapping_t *mp;
15804 lisp_eid_vat_t _eid, *eid = &_eid;
15805 lisp_eid_vat_t _seid, *seid = &_seid;
15806 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15807 u32 action = ~0, p, w, data_len;
15808 ip4_address_t rloc4;
15809 ip6_address_t rloc6;
15810 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15813 clib_memset (&rloc, 0, sizeof (rloc));
15815 /* Parse args required to build the message */
15816 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15818 if (unformat (input, "del-all"))
15822 else if (unformat (input, "del"))
15826 else if (unformat (input, "add"))
15830 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15834 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15838 else if (unformat (input, "vni %d", &vni))
15842 else if (unformat (input, "p %d w %d", &p, &w))
15846 errmsg ("No RLOC configured for setting priority/weight!");
15849 curr_rloc->priority = p;
15850 curr_rloc->weight = w;
15852 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15855 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15856 vec_add1 (rlocs, rloc);
15857 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15859 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15862 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15863 vec_add1 (rlocs, rloc);
15864 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15866 else if (unformat (input, "action %U",
15867 unformat_negative_mapping_action, &action))
15873 clib_warning ("parse error '%U'", format_unformat_error, input);
15880 errmsg ("missing params!");
15884 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15886 errmsg ("no action set for negative map-reply!");
15890 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15892 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15893 mp->is_add = is_add;
15894 mp->vni = htonl (vni);
15895 mp->action = (u8) action;
15896 mp->is_src_dst = seid_set;
15897 mp->eid_len = eid->len;
15898 mp->seid_len = seid->len;
15899 mp->del_all = del_all;
15900 mp->eid_type = eid->type;
15901 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15902 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15904 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15905 clib_memcpy (mp->rlocs, rlocs, data_len);
15911 /* Wait for a reply... */
15916 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15919 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15920 * forwarding entries in data-plane accordingly.
15922 * @param vam vpp API test context
15923 * @return return code
15926 api_one_add_del_adjacency (vat_main_t * vam)
15928 unformat_input_t *input = vam->input;
15929 vl_api_one_add_del_adjacency_t *mp;
15931 ip4_address_t leid4, reid4;
15932 ip6_address_t leid6, reid6;
15933 u8 reid_mac[6] = { 0 };
15934 u8 leid_mac[6] = { 0 };
15935 u8 reid_type, leid_type;
15936 u32 leid_len = 0, reid_len = 0, len;
15940 leid_type = reid_type = (u8) ~ 0;
15942 /* Parse args required to build the message */
15943 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15945 if (unformat (input, "del"))
15949 else if (unformat (input, "add"))
15953 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15956 reid_type = 0; /* ipv4 */
15959 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15962 reid_type = 1; /* ipv6 */
15965 else if (unformat (input, "reid %U", unformat_ethernet_address,
15968 reid_type = 2; /* mac */
15970 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15973 leid_type = 0; /* ipv4 */
15976 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15979 leid_type = 1; /* ipv6 */
15982 else if (unformat (input, "leid %U", unformat_ethernet_address,
15985 leid_type = 2; /* mac */
15987 else if (unformat (input, "vni %d", &vni))
15993 errmsg ("parse error '%U'", format_unformat_error, input);
15998 if ((u8) ~ 0 == reid_type)
16000 errmsg ("missing params!");
16004 if (leid_type != reid_type)
16006 errmsg ("remote and local EIDs are of different types!");
16010 M (ONE_ADD_DEL_ADJACENCY, mp);
16011 mp->is_add = is_add;
16012 mp->vni = htonl (vni);
16013 mp->leid_len = leid_len;
16014 mp->reid_len = reid_len;
16015 mp->eid_type = reid_type;
16017 switch (mp->eid_type)
16020 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16021 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16024 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16025 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16028 clib_memcpy (mp->leid, leid_mac, 6);
16029 clib_memcpy (mp->reid, reid_mac, 6);
16032 errmsg ("unknown EID type %d!", mp->eid_type);
16039 /* Wait for a reply... */
16044 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16047 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16049 u32 *mode = va_arg (*args, u32 *);
16051 if (unformat (input, "lisp"))
16053 else if (unformat (input, "vxlan"))
16062 api_gpe_get_encap_mode (vat_main_t * vam)
16064 vl_api_gpe_get_encap_mode_t *mp;
16067 /* Construct the API message */
16068 M (GPE_GET_ENCAP_MODE, mp);
16073 /* Wait for a reply... */
16079 api_gpe_set_encap_mode (vat_main_t * vam)
16081 unformat_input_t *input = vam->input;
16082 vl_api_gpe_set_encap_mode_t *mp;
16086 /* Parse args required to build the message */
16087 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16089 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16095 /* Construct the API message */
16096 M (GPE_SET_ENCAP_MODE, mp);
16103 /* Wait for a reply... */
16109 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16111 unformat_input_t *input = vam->input;
16112 vl_api_gpe_add_del_iface_t *mp;
16113 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16114 u32 dp_table = 0, vni = 0;
16117 /* Parse args required to build the message */
16118 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16120 if (unformat (input, "up"))
16125 else if (unformat (input, "down"))
16130 else if (unformat (input, "table_id %d", &dp_table))
16134 else if (unformat (input, "bd_id %d", &dp_table))
16139 else if (unformat (input, "vni %d", &vni))
16147 if (action_set == 0)
16149 errmsg ("Action not set");
16152 if (dp_table_set == 0 || vni_set == 0)
16154 errmsg ("vni and dp_table must be set");
16158 /* Construct the API message */
16159 M (GPE_ADD_DEL_IFACE, mp);
16161 mp->is_add = is_add;
16162 mp->dp_table = clib_host_to_net_u32 (dp_table);
16164 mp->vni = clib_host_to_net_u32 (vni);
16169 /* Wait for a reply... */
16175 api_one_map_register_fallback_threshold (vat_main_t * vam)
16177 unformat_input_t *input = vam->input;
16178 vl_api_one_map_register_fallback_threshold_t *mp;
16183 /* Parse args required to build the message */
16184 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16186 if (unformat (input, "%u", &value))
16190 clib_warning ("parse error '%U'", format_unformat_error, input);
16197 errmsg ("fallback threshold value is missing!");
16201 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16202 mp->value = clib_host_to_net_u32 (value);
16207 /* Wait for a reply... */
16213 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16215 vl_api_show_one_map_register_fallback_threshold_t *mp;
16218 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16223 /* Wait for a reply... */
16229 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16231 u32 *proto = va_arg (*args, u32 *);
16233 if (unformat (input, "udp"))
16235 else if (unformat (input, "api"))
16244 api_one_set_transport_protocol (vat_main_t * vam)
16246 unformat_input_t *input = vam->input;
16247 vl_api_one_set_transport_protocol_t *mp;
16252 /* Parse args required to build the message */
16253 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16255 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16259 clib_warning ("parse error '%U'", format_unformat_error, input);
16266 errmsg ("Transport protocol missing!");
16270 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16271 mp->protocol = (u8) protocol;
16276 /* Wait for a reply... */
16282 api_one_get_transport_protocol (vat_main_t * vam)
16284 vl_api_one_get_transport_protocol_t *mp;
16287 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16292 /* Wait for a reply... */
16298 api_one_map_register_set_ttl (vat_main_t * vam)
16300 unformat_input_t *input = vam->input;
16301 vl_api_one_map_register_set_ttl_t *mp;
16306 /* Parse args required to build the message */
16307 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16309 if (unformat (input, "%u", &ttl))
16313 clib_warning ("parse error '%U'", format_unformat_error, input);
16320 errmsg ("TTL value missing!");
16324 M (ONE_MAP_REGISTER_SET_TTL, mp);
16325 mp->ttl = clib_host_to_net_u32 (ttl);
16330 /* Wait for a reply... */
16336 api_show_one_map_register_ttl (vat_main_t * vam)
16338 vl_api_show_one_map_register_ttl_t *mp;
16341 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16346 /* Wait for a reply... */
16352 * Add/del map request itr rlocs from ONE control plane and updates
16354 * @param vam vpp API test context
16355 * @return return code
16358 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16360 unformat_input_t *input = vam->input;
16361 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16362 u8 *locator_set_name = 0;
16363 u8 locator_set_name_set = 0;
16367 /* Parse args required to build the message */
16368 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16370 if (unformat (input, "del"))
16374 else if (unformat (input, "%_%v%_", &locator_set_name))
16376 locator_set_name_set = 1;
16380 clib_warning ("parse error '%U'", format_unformat_error, input);
16385 if (is_add && !locator_set_name_set)
16387 errmsg ("itr-rloc is not set!");
16391 if (is_add && vec_len (locator_set_name) > 64)
16393 errmsg ("itr-rloc locator-set name too long");
16394 vec_free (locator_set_name);
16398 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16399 mp->is_add = is_add;
16402 clib_memcpy (mp->locator_set_name, locator_set_name,
16403 vec_len (locator_set_name));
16407 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16409 vec_free (locator_set_name);
16414 /* Wait for a reply... */
16419 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16422 api_one_locator_dump (vat_main_t * vam)
16424 unformat_input_t *input = vam->input;
16425 vl_api_one_locator_dump_t *mp;
16426 vl_api_control_ping_t *mp_ping;
16427 u8 is_index_set = 0, is_name_set = 0;
16432 /* Parse args required to build the message */
16433 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16435 if (unformat (input, "ls_name %_%v%_", &ls_name))
16439 else if (unformat (input, "ls_index %d", &ls_index))
16445 errmsg ("parse error '%U'", format_unformat_error, input);
16450 if (!is_index_set && !is_name_set)
16452 errmsg ("error: expected one of index or name!");
16456 if (is_index_set && is_name_set)
16458 errmsg ("error: only one param expected!");
16462 if (vec_len (ls_name) > 62)
16464 errmsg ("error: locator set name too long!");
16468 if (!vam->json_output)
16470 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16473 M (ONE_LOCATOR_DUMP, mp);
16474 mp->is_index_set = is_index_set;
16477 mp->ls_index = clib_host_to_net_u32 (ls_index);
16480 vec_add1 (ls_name, 0);
16481 strncpy ((char *) mp->ls_name, (char *) ls_name,
16482 sizeof (mp->ls_name) - 1);
16488 /* Use a control ping for synchronization */
16489 MPING (CONTROL_PING, mp_ping);
16492 /* Wait for a reply... */
16497 #define api_lisp_locator_dump api_one_locator_dump
16500 api_one_locator_set_dump (vat_main_t * vam)
16502 vl_api_one_locator_set_dump_t *mp;
16503 vl_api_control_ping_t *mp_ping;
16504 unformat_input_t *input = vam->input;
16508 /* Parse args required to build the message */
16509 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16511 if (unformat (input, "local"))
16515 else if (unformat (input, "remote"))
16521 errmsg ("parse error '%U'", format_unformat_error, input);
16526 if (!vam->json_output)
16528 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16531 M (ONE_LOCATOR_SET_DUMP, mp);
16533 mp->filter = filter;
16538 /* Use a control ping for synchronization */
16539 MPING (CONTROL_PING, mp_ping);
16542 /* Wait for a reply... */
16547 #define api_lisp_locator_set_dump api_one_locator_set_dump
16550 api_one_eid_table_map_dump (vat_main_t * vam)
16554 unformat_input_t *input = vam->input;
16555 vl_api_one_eid_table_map_dump_t *mp;
16556 vl_api_control_ping_t *mp_ping;
16559 /* Parse args required to build the message */
16560 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16562 if (unformat (input, "l2"))
16567 else if (unformat (input, "l3"))
16574 errmsg ("parse error '%U'", format_unformat_error, input);
16581 errmsg ("expected one of 'l2' or 'l3' parameter!");
16585 if (!vam->json_output)
16587 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16590 M (ONE_EID_TABLE_MAP_DUMP, mp);
16596 /* Use a control ping for synchronization */
16597 MPING (CONTROL_PING, mp_ping);
16600 /* Wait for a reply... */
16605 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16608 api_one_eid_table_vni_dump (vat_main_t * vam)
16610 vl_api_one_eid_table_vni_dump_t *mp;
16611 vl_api_control_ping_t *mp_ping;
16614 if (!vam->json_output)
16616 print (vam->ofp, "VNI");
16619 M (ONE_EID_TABLE_VNI_DUMP, mp);
16624 /* Use a control ping for synchronization */
16625 MPING (CONTROL_PING, mp_ping);
16628 /* Wait for a reply... */
16633 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16636 api_one_eid_table_dump (vat_main_t * vam)
16638 unformat_input_t *i = vam->input;
16639 vl_api_one_eid_table_dump_t *mp;
16640 vl_api_control_ping_t *mp_ping;
16641 struct in_addr ip4;
16642 struct in6_addr ip6;
16644 u8 eid_type = ~0, eid_set = 0;
16645 u32 prefix_length = ~0, t, vni = 0;
16648 lisp_nsh_api_t nsh;
16650 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16652 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16658 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16664 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16669 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16674 else if (unformat (i, "vni %d", &t))
16678 else if (unformat (i, "local"))
16682 else if (unformat (i, "remote"))
16688 errmsg ("parse error '%U'", format_unformat_error, i);
16693 if (!vam->json_output)
16695 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16696 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16699 M (ONE_EID_TABLE_DUMP, mp);
16701 mp->filter = filter;
16705 mp->vni = htonl (vni);
16706 mp->eid_type = eid_type;
16710 mp->prefix_length = prefix_length;
16711 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16714 mp->prefix_length = prefix_length;
16715 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16718 clib_memcpy (mp->eid, mac, sizeof (mac));
16721 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16724 errmsg ("unknown EID type %d!", eid_type);
16732 /* Use a control ping for synchronization */
16733 MPING (CONTROL_PING, mp_ping);
16736 /* Wait for a reply... */
16741 #define api_lisp_eid_table_dump api_one_eid_table_dump
16744 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16746 unformat_input_t *i = vam->input;
16747 vl_api_gpe_fwd_entries_get_t *mp;
16752 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16754 if (unformat (i, "vni %d", &vni))
16760 errmsg ("parse error '%U'", format_unformat_error, i);
16767 errmsg ("vni not set!");
16771 if (!vam->json_output)
16773 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16777 M (GPE_FWD_ENTRIES_GET, mp);
16778 mp->vni = clib_host_to_net_u32 (vni);
16783 /* Wait for a reply... */
16788 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16789 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16790 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16791 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16792 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16793 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16794 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16795 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16798 api_one_adjacencies_get (vat_main_t * vam)
16800 unformat_input_t *i = vam->input;
16801 vl_api_one_adjacencies_get_t *mp;
16806 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16808 if (unformat (i, "vni %d", &vni))
16814 errmsg ("parse error '%U'", format_unformat_error, i);
16821 errmsg ("vni not set!");
16825 if (!vam->json_output)
16827 print (vam->ofp, "%s %40s", "leid", "reid");
16830 M (ONE_ADJACENCIES_GET, mp);
16831 mp->vni = clib_host_to_net_u32 (vni);
16836 /* Wait for a reply... */
16841 #define api_lisp_adjacencies_get api_one_adjacencies_get
16844 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16846 unformat_input_t *i = vam->input;
16847 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16849 u8 ip_family_set = 0, is_ip4 = 1;
16851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16853 if (unformat (i, "ip4"))
16858 else if (unformat (i, "ip6"))
16865 errmsg ("parse error '%U'", format_unformat_error, i);
16870 if (!ip_family_set)
16872 errmsg ("ip family not set!");
16876 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16877 mp->is_ip4 = is_ip4;
16882 /* Wait for a reply... */
16888 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16890 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16893 if (!vam->json_output)
16895 print (vam->ofp, "VNIs");
16898 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16903 /* Wait for a reply... */
16909 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16911 unformat_input_t *i = vam->input;
16912 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16914 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16915 struct in_addr ip4;
16916 struct in6_addr ip6;
16917 u32 table_id = 0, nh_sw_if_index = ~0;
16919 clib_memset (&ip4, 0, sizeof (ip4));
16920 clib_memset (&ip6, 0, sizeof (ip6));
16922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16924 if (unformat (i, "del"))
16926 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16927 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16932 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16933 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16938 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16942 nh_sw_if_index = ~0;
16944 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16948 nh_sw_if_index = ~0;
16950 else if (unformat (i, "table %d", &table_id))
16954 errmsg ("parse error '%U'", format_unformat_error, i);
16961 errmsg ("nh addr not set!");
16965 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16966 mp->is_add = is_add;
16967 mp->table_id = clib_host_to_net_u32 (table_id);
16968 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16969 mp->is_ip4 = is_ip4;
16971 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16973 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16978 /* Wait for a reply... */
16984 api_one_map_server_dump (vat_main_t * vam)
16986 vl_api_one_map_server_dump_t *mp;
16987 vl_api_control_ping_t *mp_ping;
16990 if (!vam->json_output)
16992 print (vam->ofp, "%=20s", "Map server");
16995 M (ONE_MAP_SERVER_DUMP, mp);
16999 /* Use a control ping for synchronization */
17000 MPING (CONTROL_PING, mp_ping);
17003 /* Wait for a reply... */
17008 #define api_lisp_map_server_dump api_one_map_server_dump
17011 api_one_map_resolver_dump (vat_main_t * vam)
17013 vl_api_one_map_resolver_dump_t *mp;
17014 vl_api_control_ping_t *mp_ping;
17017 if (!vam->json_output)
17019 print (vam->ofp, "%=20s", "Map resolver");
17022 M (ONE_MAP_RESOLVER_DUMP, mp);
17026 /* Use a control ping for synchronization */
17027 MPING (CONTROL_PING, mp_ping);
17030 /* Wait for a reply... */
17035 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17038 api_one_stats_flush (vat_main_t * vam)
17040 vl_api_one_stats_flush_t *mp;
17043 M (ONE_STATS_FLUSH, mp);
17050 api_one_stats_dump (vat_main_t * vam)
17052 vl_api_one_stats_dump_t *mp;
17053 vl_api_control_ping_t *mp_ping;
17056 M (ONE_STATS_DUMP, mp);
17060 /* Use a control ping for synchronization */
17061 MPING (CONTROL_PING, mp_ping);
17064 /* Wait for a reply... */
17070 api_show_one_status (vat_main_t * vam)
17072 vl_api_show_one_status_t *mp;
17075 if (!vam->json_output)
17077 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17080 M (SHOW_ONE_STATUS, mp);
17083 /* Wait for a reply... */
17088 #define api_show_lisp_status api_show_one_status
17091 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17093 vl_api_gpe_fwd_entry_path_dump_t *mp;
17094 vl_api_control_ping_t *mp_ping;
17095 unformat_input_t *i = vam->input;
17096 u32 fwd_entry_index = ~0;
17099 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17101 if (unformat (i, "index %d", &fwd_entry_index))
17107 if (~0 == fwd_entry_index)
17109 errmsg ("no index specified!");
17113 if (!vam->json_output)
17115 print (vam->ofp, "first line");
17118 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17122 /* Use a control ping for synchronization */
17123 MPING (CONTROL_PING, mp_ping);
17126 /* Wait for a reply... */
17132 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17134 vl_api_one_get_map_request_itr_rlocs_t *mp;
17137 if (!vam->json_output)
17139 print (vam->ofp, "%=20s", "itr-rlocs:");
17142 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17145 /* Wait for a reply... */
17150 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17153 api_af_packet_create (vat_main_t * vam)
17155 unformat_input_t *i = vam->input;
17156 vl_api_af_packet_create_t *mp;
17157 u8 *host_if_name = 0;
17159 u8 random_hw_addr = 1;
17162 clib_memset (hw_addr, 0, sizeof (hw_addr));
17164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17166 if (unformat (i, "name %s", &host_if_name))
17167 vec_add1 (host_if_name, 0);
17168 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17169 random_hw_addr = 0;
17174 if (!vec_len (host_if_name))
17176 errmsg ("host-interface name must be specified");
17180 if (vec_len (host_if_name) > 64)
17182 errmsg ("host-interface name too long");
17186 M (AF_PACKET_CREATE, mp);
17188 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17189 clib_memcpy (mp->hw_addr, hw_addr, 6);
17190 mp->use_random_hw_addr = random_hw_addr;
17191 vec_free (host_if_name);
17199 fprintf (vam->ofp ? vam->ofp : stderr,
17200 " new sw_if_index = %d\n", vam->sw_if_index);
17207 api_af_packet_delete (vat_main_t * vam)
17209 unformat_input_t *i = vam->input;
17210 vl_api_af_packet_delete_t *mp;
17211 u8 *host_if_name = 0;
17214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17216 if (unformat (i, "name %s", &host_if_name))
17217 vec_add1 (host_if_name, 0);
17222 if (!vec_len (host_if_name))
17224 errmsg ("host-interface name must be specified");
17228 if (vec_len (host_if_name) > 64)
17230 errmsg ("host-interface name too long");
17234 M (AF_PACKET_DELETE, mp);
17236 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17237 vec_free (host_if_name);
17244 static void vl_api_af_packet_details_t_handler
17245 (vl_api_af_packet_details_t * mp)
17247 vat_main_t *vam = &vat_main;
17249 print (vam->ofp, "%-16s %d",
17250 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17253 static void vl_api_af_packet_details_t_handler_json
17254 (vl_api_af_packet_details_t * mp)
17256 vat_main_t *vam = &vat_main;
17257 vat_json_node_t *node = NULL;
17259 if (VAT_JSON_ARRAY != vam->json_tree.type)
17261 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17262 vat_json_init_array (&vam->json_tree);
17264 node = vat_json_array_add (&vam->json_tree);
17266 vat_json_init_object (node);
17267 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17268 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17272 api_af_packet_dump (vat_main_t * vam)
17274 vl_api_af_packet_dump_t *mp;
17275 vl_api_control_ping_t *mp_ping;
17278 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17279 /* Get list of tap interfaces */
17280 M (AF_PACKET_DUMP, mp);
17283 /* Use a control ping for synchronization */
17284 MPING (CONTROL_PING, mp_ping);
17292 api_policer_add_del (vat_main_t * vam)
17294 unformat_input_t *i = vam->input;
17295 vl_api_policer_add_del_t *mp;
17305 u8 color_aware = 0;
17306 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17309 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17310 conform_action.dscp = 0;
17311 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17312 exceed_action.dscp = 0;
17313 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17314 violate_action.dscp = 0;
17316 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17318 if (unformat (i, "del"))
17320 else if (unformat (i, "name %s", &name))
17321 vec_add1 (name, 0);
17322 else if (unformat (i, "cir %u", &cir))
17324 else if (unformat (i, "eir %u", &eir))
17326 else if (unformat (i, "cb %u", &cb))
17328 else if (unformat (i, "eb %u", &eb))
17330 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17333 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17336 else if (unformat (i, "type %U", unformat_policer_type, &type))
17338 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17341 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17344 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17347 else if (unformat (i, "color-aware"))
17353 if (!vec_len (name))
17355 errmsg ("policer name must be specified");
17359 if (vec_len (name) > 64)
17361 errmsg ("policer name too long");
17365 M (POLICER_ADD_DEL, mp);
17367 clib_memcpy (mp->name, name, vec_len (name));
17369 mp->is_add = is_add;
17370 mp->cir = ntohl (cir);
17371 mp->eir = ntohl (eir);
17372 mp->cb = clib_net_to_host_u64 (cb);
17373 mp->eb = clib_net_to_host_u64 (eb);
17374 mp->rate_type = rate_type;
17375 mp->round_type = round_type;
17377 mp->conform_action_type = conform_action.action_type;
17378 mp->conform_dscp = conform_action.dscp;
17379 mp->exceed_action_type = exceed_action.action_type;
17380 mp->exceed_dscp = exceed_action.dscp;
17381 mp->violate_action_type = violate_action.action_type;
17382 mp->violate_dscp = violate_action.dscp;
17383 mp->color_aware = color_aware;
17391 api_policer_dump (vat_main_t * vam)
17393 unformat_input_t *i = vam->input;
17394 vl_api_policer_dump_t *mp;
17395 vl_api_control_ping_t *mp_ping;
17396 u8 *match_name = 0;
17397 u8 match_name_valid = 0;
17400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17402 if (unformat (i, "name %s", &match_name))
17404 vec_add1 (match_name, 0);
17405 match_name_valid = 1;
17411 M (POLICER_DUMP, mp);
17412 mp->match_name_valid = match_name_valid;
17413 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17414 vec_free (match_name);
17418 /* Use a control ping for synchronization */
17419 MPING (CONTROL_PING, mp_ping);
17422 /* Wait for a reply... */
17428 api_policer_classify_set_interface (vat_main_t * vam)
17430 unformat_input_t *i = vam->input;
17431 vl_api_policer_classify_set_interface_t *mp;
17433 int sw_if_index_set;
17434 u32 ip4_table_index = ~0;
17435 u32 ip6_table_index = ~0;
17436 u32 l2_table_index = ~0;
17440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17442 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17443 sw_if_index_set = 1;
17444 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17445 sw_if_index_set = 1;
17446 else if (unformat (i, "del"))
17448 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17450 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17452 else if (unformat (i, "l2-table %d", &l2_table_index))
17456 clib_warning ("parse error '%U'", format_unformat_error, i);
17461 if (sw_if_index_set == 0)
17463 errmsg ("missing interface name or sw_if_index");
17467 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17469 mp->sw_if_index = ntohl (sw_if_index);
17470 mp->ip4_table_index = ntohl (ip4_table_index);
17471 mp->ip6_table_index = ntohl (ip6_table_index);
17472 mp->l2_table_index = ntohl (l2_table_index);
17473 mp->is_add = is_add;
17481 api_policer_classify_dump (vat_main_t * vam)
17483 unformat_input_t *i = vam->input;
17484 vl_api_policer_classify_dump_t *mp;
17485 vl_api_control_ping_t *mp_ping;
17486 u8 type = POLICER_CLASSIFY_N_TABLES;
17489 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17493 errmsg ("classify table type must be specified");
17497 if (!vam->json_output)
17499 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17502 M (POLICER_CLASSIFY_DUMP, mp);
17507 /* Use a control ping for synchronization */
17508 MPING (CONTROL_PING, mp_ping);
17511 /* Wait for a reply... */
17517 api_netmap_create (vat_main_t * vam)
17519 unformat_input_t *i = vam->input;
17520 vl_api_netmap_create_t *mp;
17523 u8 random_hw_addr = 1;
17528 clib_memset (hw_addr, 0, sizeof (hw_addr));
17530 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17532 if (unformat (i, "name %s", &if_name))
17533 vec_add1 (if_name, 0);
17534 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17535 random_hw_addr = 0;
17536 else if (unformat (i, "pipe"))
17538 else if (unformat (i, "master"))
17540 else if (unformat (i, "slave"))
17546 if (!vec_len (if_name))
17548 errmsg ("interface name must be specified");
17552 if (vec_len (if_name) > 64)
17554 errmsg ("interface name too long");
17558 M (NETMAP_CREATE, mp);
17560 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17561 clib_memcpy (mp->hw_addr, hw_addr, 6);
17562 mp->use_random_hw_addr = random_hw_addr;
17563 mp->is_pipe = is_pipe;
17564 mp->is_master = is_master;
17565 vec_free (if_name);
17573 api_netmap_delete (vat_main_t * vam)
17575 unformat_input_t *i = vam->input;
17576 vl_api_netmap_delete_t *mp;
17580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17582 if (unformat (i, "name %s", &if_name))
17583 vec_add1 (if_name, 0);
17588 if (!vec_len (if_name))
17590 errmsg ("interface name must be specified");
17594 if (vec_len (if_name) > 64)
17596 errmsg ("interface name too long");
17600 M (NETMAP_DELETE, mp);
17602 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17603 vec_free (if_name);
17611 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17613 vl_api_fib_path_nh_proto_t proto =
17614 va_arg (*args, vl_api_fib_path_nh_proto_t);
17618 case FIB_API_PATH_NH_PROTO_IP4:
17619 s = format (s, "ip4");
17621 case FIB_API_PATH_NH_PROTO_IP6:
17622 s = format (s, "ip6");
17624 case FIB_API_PATH_NH_PROTO_MPLS:
17625 s = format (s, "mpls");
17627 case FIB_API_PATH_NH_PROTO_BIER:
17628 s = format (s, "bier");
17630 case FIB_API_PATH_NH_PROTO_ETHERNET:
17631 s = format (s, "ethernet");
17639 format_vl_api_ip_address_union (u8 * s, va_list * args)
17641 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
17642 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17647 s = format (s, "%U", format_ip4_address, u->ip4);
17650 s = format (s, "%U", format_ip6_address, u->ip6);
17657 format_vl_api_fib_path_type (u8 * s, va_list * args)
17659 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17663 case FIB_API_PATH_TYPE_NORMAL:
17664 s = format (s, "normal");
17666 case FIB_API_PATH_TYPE_LOCAL:
17667 s = format (s, "local");
17669 case FIB_API_PATH_TYPE_DROP:
17670 s = format (s, "drop");
17672 case FIB_API_PATH_TYPE_UDP_ENCAP:
17673 s = format (s, "udp-encap");
17675 case FIB_API_PATH_TYPE_BIER_IMP:
17676 s = format (s, "bier-imp");
17678 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17679 s = format (s, "unreach");
17681 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17682 s = format (s, "prohibit");
17684 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17685 s = format (s, "src-lookup");
17687 case FIB_API_PATH_TYPE_DVR:
17688 s = format (s, "dvr");
17690 case FIB_API_PATH_TYPE_INTERFACE_RX:
17691 s = format (s, "interface-rx");
17693 case FIB_API_PATH_TYPE_CLASSIFY:
17694 s = format (s, "classify");
17702 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17705 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17706 ntohl (fp->weight), ntohl (fp->sw_if_index),
17707 format_vl_api_fib_path_type, fp->type,
17708 format_fib_api_path_nh_proto, fp->proto,
17709 format_vl_api_ip_address_union, &fp->nh.address);
17713 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17714 vl_api_fib_path_t * fp)
17716 struct in_addr ip4;
17717 struct in6_addr ip6;
17719 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17720 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17721 vat_json_object_add_uint (node, "type", fp->type);
17722 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17723 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17725 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17726 vat_json_object_add_ip4 (node, "next_hop", ip4);
17728 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17730 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17731 vat_json_object_add_ip6 (node, "next_hop", ip6);
17736 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17738 vat_main_t *vam = &vat_main;
17739 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17740 vl_api_fib_path_t *fp;
17743 print (vam->ofp, "sw_if_index %d via:",
17744 ntohl (mp->mt_tunnel.mt_sw_if_index));
17745 fp = mp->mt_tunnel.mt_paths;
17746 for (i = 0; i < count; i++)
17748 vl_api_fib_path_print (vam, fp);
17752 print (vam->ofp, "");
17755 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17756 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17759 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17761 vat_main_t *vam = &vat_main;
17762 vat_json_node_t *node = NULL;
17763 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17764 vl_api_fib_path_t *fp;
17767 if (VAT_JSON_ARRAY != vam->json_tree.type)
17769 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17770 vat_json_init_array (&vam->json_tree);
17772 node = vat_json_array_add (&vam->json_tree);
17774 vat_json_init_object (node);
17775 vat_json_object_add_uint (node, "sw_if_index",
17776 ntohl (mp->mt_tunnel.mt_sw_if_index));
17778 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17780 fp = mp->mt_tunnel.mt_paths;
17781 for (i = 0; i < count; i++)
17783 vl_api_mpls_fib_path_json_print (node, fp);
17789 api_mpls_tunnel_dump (vat_main_t * vam)
17791 vl_api_mpls_tunnel_dump_t *mp;
17792 vl_api_control_ping_t *mp_ping;
17795 M (MPLS_TUNNEL_DUMP, mp);
17799 /* Use a control ping for synchronization */
17800 MPING (CONTROL_PING, mp_ping);
17807 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17808 #define vl_api_mpls_table_details_t_print vl_noop_handler
17812 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17814 vat_main_t *vam = &vat_main;
17816 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17819 static void vl_api_mpls_table_details_t_handler_json
17820 (vl_api_mpls_table_details_t * mp)
17822 vat_main_t *vam = &vat_main;
17823 vat_json_node_t *node = NULL;
17825 if (VAT_JSON_ARRAY != vam->json_tree.type)
17827 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17828 vat_json_init_array (&vam->json_tree);
17830 node = vat_json_array_add (&vam->json_tree);
17832 vat_json_init_object (node);
17833 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17837 api_mpls_table_dump (vat_main_t * vam)
17839 vl_api_mpls_table_dump_t *mp;
17840 vl_api_control_ping_t *mp_ping;
17843 M (MPLS_TABLE_DUMP, mp);
17846 /* Use a control ping for synchronization */
17847 MPING (CONTROL_PING, mp_ping);
17854 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17855 #define vl_api_mpls_route_details_t_print vl_noop_handler
17858 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17860 vat_main_t *vam = &vat_main;
17861 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17862 vl_api_fib_path_t *fp;
17866 "table-id %d, label %u, ess_bit %u",
17867 ntohl (mp->mr_route.mr_table_id),
17868 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17869 fp = mp->mr_route.mr_paths;
17870 for (i = 0; i < count; i++)
17872 vl_api_fib_path_print (vam, fp);
17877 static void vl_api_mpls_route_details_t_handler_json
17878 (vl_api_mpls_route_details_t * mp)
17880 vat_main_t *vam = &vat_main;
17881 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17882 vat_json_node_t *node = NULL;
17883 vl_api_fib_path_t *fp;
17886 if (VAT_JSON_ARRAY != vam->json_tree.type)
17888 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17889 vat_json_init_array (&vam->json_tree);
17891 node = vat_json_array_add (&vam->json_tree);
17893 vat_json_init_object (node);
17894 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17895 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17896 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17897 vat_json_object_add_uint (node, "path_count", count);
17898 fp = mp->mr_route.mr_paths;
17899 for (i = 0; i < count; i++)
17901 vl_api_mpls_fib_path_json_print (node, fp);
17907 api_mpls_route_dump (vat_main_t * vam)
17909 unformat_input_t *input = vam->input;
17910 vl_api_mpls_route_dump_t *mp;
17911 vl_api_control_ping_t *mp_ping;
17915 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17917 if (unformat (input, "table_id %d", &table_id))
17922 if (table_id == ~0)
17924 errmsg ("missing table id");
17928 M (MPLS_ROUTE_DUMP, mp);
17930 mp->table.mt_table_id = ntohl (table_id);
17933 /* Use a control ping for synchronization */
17934 MPING (CONTROL_PING, mp_ping);
17941 #define vl_api_ip_table_details_t_endian vl_noop_handler
17942 #define vl_api_ip_table_details_t_print vl_noop_handler
17945 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17947 vat_main_t *vam = &vat_main;
17950 "%s; table-id %d, prefix %U/%d",
17951 mp->table.name, ntohl (mp->table.table_id));
17955 static void vl_api_ip_table_details_t_handler_json
17956 (vl_api_ip_table_details_t * mp)
17958 vat_main_t *vam = &vat_main;
17959 vat_json_node_t *node = NULL;
17961 if (VAT_JSON_ARRAY != vam->json_tree.type)
17963 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17964 vat_json_init_array (&vam->json_tree);
17966 node = vat_json_array_add (&vam->json_tree);
17968 vat_json_init_object (node);
17969 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17973 api_ip_table_dump (vat_main_t * vam)
17975 vl_api_ip_table_dump_t *mp;
17976 vl_api_control_ping_t *mp_ping;
17979 M (IP_TABLE_DUMP, mp);
17982 /* Use a control ping for synchronization */
17983 MPING (CONTROL_PING, mp_ping);
17991 api_ip_mtable_dump (vat_main_t * vam)
17993 vl_api_ip_mtable_dump_t *mp;
17994 vl_api_control_ping_t *mp_ping;
17997 M (IP_MTABLE_DUMP, mp);
18000 /* Use a control ping for synchronization */
18001 MPING (CONTROL_PING, mp_ping);
18009 api_ip_mroute_dump (vat_main_t * vam)
18011 unformat_input_t *input = vam->input;
18012 vl_api_control_ping_t *mp_ping;
18013 vl_api_ip_mroute_dump_t *mp;
18018 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18020 if (unformat (input, "table_id %d", &table_id))
18022 else if (unformat (input, "ip6"))
18024 else if (unformat (input, "ip4"))
18029 if (table_id == ~0)
18031 errmsg ("missing table id");
18035 M (IP_MROUTE_DUMP, mp);
18036 mp->table.table_id = table_id;
18037 mp->table.is_ip6 = is_ip6;
18040 /* Use a control ping for synchronization */
18041 MPING (CONTROL_PING, mp_ping);
18048 #define vl_api_ip_route_details_t_endian vl_noop_handler
18049 #define vl_api_ip_route_details_t_print vl_noop_handler
18052 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
18054 vat_main_t *vam = &vat_main;
18055 u8 count = mp->route.n_paths;
18056 vl_api_fib_path_t *fp;
18060 "table-id %d, prefix %U/%d",
18061 ntohl (mp->route.table_id),
18062 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
18063 for (i = 0; i < count; i++)
18065 fp = &mp->route.paths[i];
18067 vl_api_fib_path_print (vam, fp);
18072 static void vl_api_ip_route_details_t_handler_json
18073 (vl_api_ip_route_details_t * mp)
18075 vat_main_t *vam = &vat_main;
18076 u8 count = mp->route.n_paths;
18077 vat_json_node_t *node = NULL;
18078 struct in_addr ip4;
18079 struct in6_addr ip6;
18080 vl_api_fib_path_t *fp;
18083 if (VAT_JSON_ARRAY != vam->json_tree.type)
18085 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18086 vat_json_init_array (&vam->json_tree);
18088 node = vat_json_array_add (&vam->json_tree);
18090 vat_json_init_object (node);
18091 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18092 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18094 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18095 vat_json_object_add_ip6 (node, "prefix", ip6);
18099 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18100 vat_json_object_add_ip4 (node, "prefix", ip4);
18102 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18103 vat_json_object_add_uint (node, "path_count", count);
18104 for (i = 0; i < count; i++)
18106 fp = &mp->route.paths[i];
18107 vl_api_mpls_fib_path_json_print (node, fp);
18112 api_ip_route_dump (vat_main_t * vam)
18114 unformat_input_t *input = vam->input;
18115 vl_api_ip_route_dump_t *mp;
18116 vl_api_control_ping_t *mp_ping;
18122 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18124 if (unformat (input, "table_id %d", &table_id))
18126 else if (unformat (input, "ip6"))
18128 else if (unformat (input, "ip4"))
18133 if (table_id == ~0)
18135 errmsg ("missing table id");
18139 M (IP_ROUTE_DUMP, mp);
18141 mp->table.table_id = table_id;
18142 mp->table.is_ip6 = is_ip6;
18146 /* Use a control ping for synchronization */
18147 MPING (CONTROL_PING, mp_ping);
18155 api_classify_table_ids (vat_main_t * vam)
18157 vl_api_classify_table_ids_t *mp;
18160 /* Construct the API message */
18161 M (CLASSIFY_TABLE_IDS, mp);
18170 api_classify_table_by_interface (vat_main_t * vam)
18172 unformat_input_t *input = vam->input;
18173 vl_api_classify_table_by_interface_t *mp;
18175 u32 sw_if_index = ~0;
18177 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18179 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18181 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18186 if (sw_if_index == ~0)
18188 errmsg ("missing interface name or sw_if_index");
18192 /* Construct the API message */
18193 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18195 mp->sw_if_index = ntohl (sw_if_index);
18203 api_classify_table_info (vat_main_t * vam)
18205 unformat_input_t *input = vam->input;
18206 vl_api_classify_table_info_t *mp;
18210 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18212 if (unformat (input, "table_id %d", &table_id))
18217 if (table_id == ~0)
18219 errmsg ("missing table id");
18223 /* Construct the API message */
18224 M (CLASSIFY_TABLE_INFO, mp);
18226 mp->table_id = ntohl (table_id);
18234 api_classify_session_dump (vat_main_t * vam)
18236 unformat_input_t *input = vam->input;
18237 vl_api_classify_session_dump_t *mp;
18238 vl_api_control_ping_t *mp_ping;
18242 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18244 if (unformat (input, "table_id %d", &table_id))
18249 if (table_id == ~0)
18251 errmsg ("missing table id");
18255 /* Construct the API message */
18256 M (CLASSIFY_SESSION_DUMP, mp);
18258 mp->table_id = ntohl (table_id);
18261 /* Use a control ping for synchronization */
18262 MPING (CONTROL_PING, mp_ping);
18270 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18272 vat_main_t *vam = &vat_main;
18274 print (vam->ofp, "collector_address %U, collector_port %d, "
18275 "src_address %U, vrf_id %d, path_mtu %u, "
18276 "template_interval %u, udp_checksum %d",
18277 format_ip4_address, mp->collector_address,
18278 ntohs (mp->collector_port),
18279 format_ip4_address, mp->src_address,
18280 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18281 ntohl (mp->template_interval), mp->udp_checksum);
18284 vam->result_ready = 1;
18288 vl_api_ipfix_exporter_details_t_handler_json
18289 (vl_api_ipfix_exporter_details_t * mp)
18291 vat_main_t *vam = &vat_main;
18292 vat_json_node_t node;
18293 struct in_addr collector_address;
18294 struct in_addr src_address;
18296 vat_json_init_object (&node);
18297 clib_memcpy (&collector_address, &mp->collector_address,
18298 sizeof (collector_address));
18299 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18300 vat_json_object_add_uint (&node, "collector_port",
18301 ntohs (mp->collector_port));
18302 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18303 vat_json_object_add_ip4 (&node, "src_address", src_address);
18304 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18305 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18306 vat_json_object_add_uint (&node, "template_interval",
18307 ntohl (mp->template_interval));
18308 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18310 vat_json_print (vam->ofp, &node);
18311 vat_json_free (&node);
18313 vam->result_ready = 1;
18317 api_ipfix_exporter_dump (vat_main_t * vam)
18319 vl_api_ipfix_exporter_dump_t *mp;
18322 /* Construct the API message */
18323 M (IPFIX_EXPORTER_DUMP, mp);
18332 api_ipfix_classify_stream_dump (vat_main_t * vam)
18334 vl_api_ipfix_classify_stream_dump_t *mp;
18337 /* Construct the API message */
18338 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18349 vl_api_ipfix_classify_stream_details_t_handler
18350 (vl_api_ipfix_classify_stream_details_t * mp)
18352 vat_main_t *vam = &vat_main;
18353 print (vam->ofp, "domain_id %d, src_port %d",
18354 ntohl (mp->domain_id), ntohs (mp->src_port));
18356 vam->result_ready = 1;
18360 vl_api_ipfix_classify_stream_details_t_handler_json
18361 (vl_api_ipfix_classify_stream_details_t * mp)
18363 vat_main_t *vam = &vat_main;
18364 vat_json_node_t node;
18366 vat_json_init_object (&node);
18367 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18368 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18370 vat_json_print (vam->ofp, &node);
18371 vat_json_free (&node);
18373 vam->result_ready = 1;
18377 api_ipfix_classify_table_dump (vat_main_t * vam)
18379 vl_api_ipfix_classify_table_dump_t *mp;
18380 vl_api_control_ping_t *mp_ping;
18383 if (!vam->json_output)
18385 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18386 "transport_protocol");
18389 /* Construct the API message */
18390 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18395 /* Use a control ping for synchronization */
18396 MPING (CONTROL_PING, mp_ping);
18404 vl_api_ipfix_classify_table_details_t_handler
18405 (vl_api_ipfix_classify_table_details_t * mp)
18407 vat_main_t *vam = &vat_main;
18408 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18409 mp->transport_protocol);
18413 vl_api_ipfix_classify_table_details_t_handler_json
18414 (vl_api_ipfix_classify_table_details_t * mp)
18416 vat_json_node_t *node = NULL;
18417 vat_main_t *vam = &vat_main;
18419 if (VAT_JSON_ARRAY != vam->json_tree.type)
18421 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18422 vat_json_init_array (&vam->json_tree);
18425 node = vat_json_array_add (&vam->json_tree);
18426 vat_json_init_object (node);
18428 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18429 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18430 vat_json_object_add_uint (node, "transport_protocol",
18431 mp->transport_protocol);
18435 api_sw_interface_span_enable_disable (vat_main_t * vam)
18437 unformat_input_t *i = vam->input;
18438 vl_api_sw_interface_span_enable_disable_t *mp;
18439 u32 src_sw_if_index = ~0;
18440 u32 dst_sw_if_index = ~0;
18445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18448 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18450 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18454 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18456 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18458 else if (unformat (i, "disable"))
18460 else if (unformat (i, "rx"))
18462 else if (unformat (i, "tx"))
18464 else if (unformat (i, "both"))
18466 else if (unformat (i, "l2"))
18472 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18474 mp->sw_if_index_from = htonl (src_sw_if_index);
18475 mp->sw_if_index_to = htonl (dst_sw_if_index);
18485 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18488 vat_main_t *vam = &vat_main;
18489 u8 *sw_if_from_name = 0;
18490 u8 *sw_if_to_name = 0;
18491 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18492 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18493 char *states[] = { "none", "rx", "tx", "both" };
18497 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18499 if ((u32) p->value[0] == sw_if_index_from)
18501 sw_if_from_name = (u8 *)(p->key);
18505 if ((u32) p->value[0] == sw_if_index_to)
18507 sw_if_to_name = (u8 *)(p->key);
18508 if (sw_if_from_name)
18513 print (vam->ofp, "%20s => %20s (%s) %s",
18514 sw_if_from_name, sw_if_to_name, states[mp->state],
18515 mp->is_l2 ? "l2" : "device");
18519 vl_api_sw_interface_span_details_t_handler_json
18520 (vl_api_sw_interface_span_details_t * mp)
18522 vat_main_t *vam = &vat_main;
18523 vat_json_node_t *node = NULL;
18524 u8 *sw_if_from_name = 0;
18525 u8 *sw_if_to_name = 0;
18526 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18527 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18531 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18533 if ((u32) p->value[0] == sw_if_index_from)
18535 sw_if_from_name = (u8 *)(p->key);
18539 if ((u32) p->value[0] == sw_if_index_to)
18541 sw_if_to_name = (u8 *)(p->key);
18542 if (sw_if_from_name)
18548 if (VAT_JSON_ARRAY != vam->json_tree.type)
18550 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18551 vat_json_init_array (&vam->json_tree);
18553 node = vat_json_array_add (&vam->json_tree);
18555 vat_json_init_object (node);
18556 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18557 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18558 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18559 if (0 != sw_if_to_name)
18561 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18563 vat_json_object_add_uint (node, "state", mp->state);
18564 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18568 api_sw_interface_span_dump (vat_main_t * vam)
18570 unformat_input_t *input = vam->input;
18571 vl_api_sw_interface_span_dump_t *mp;
18572 vl_api_control_ping_t *mp_ping;
18576 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18578 if (unformat (input, "l2"))
18584 M (SW_INTERFACE_SPAN_DUMP, mp);
18588 /* Use a control ping for synchronization */
18589 MPING (CONTROL_PING, mp_ping);
18597 api_pg_create_interface (vat_main_t * vam)
18599 unformat_input_t *input = vam->input;
18600 vl_api_pg_create_interface_t *mp;
18602 u32 if_id = ~0, gso_size = 0;
18603 u8 gso_enabled = 0;
18605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18607 if (unformat (input, "if_id %d", &if_id))
18609 else if (unformat (input, "gso-enabled"))
18612 if (unformat (input, "gso-size %u", &gso_size))
18616 errmsg ("missing gso-size");
18625 errmsg ("missing pg interface index");
18629 /* Construct the API message */
18630 M (PG_CREATE_INTERFACE, mp);
18632 mp->interface_id = ntohl (if_id);
18633 mp->gso_enabled = gso_enabled;
18641 api_pg_capture (vat_main_t * vam)
18643 unformat_input_t *input = vam->input;
18644 vl_api_pg_capture_t *mp;
18649 u8 pcap_file_set = 0;
18652 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18654 if (unformat (input, "if_id %d", &if_id))
18656 else if (unformat (input, "pcap %s", &pcap_file))
18658 else if (unformat (input, "count %d", &count))
18660 else if (unformat (input, "disable"))
18667 errmsg ("missing pg interface index");
18670 if (pcap_file_set > 0)
18672 if (vec_len (pcap_file) > 255)
18674 errmsg ("pcap file name is too long");
18679 u32 name_len = vec_len (pcap_file);
18680 /* Construct the API message */
18681 M (PG_CAPTURE, mp);
18683 mp->interface_id = ntohl (if_id);
18684 mp->is_enabled = enable;
18685 mp->count = ntohl (count);
18686 mp->pcap_name_length = ntohl (name_len);
18687 if (pcap_file_set != 0)
18689 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18691 vec_free (pcap_file);
18699 api_pg_enable_disable (vat_main_t * vam)
18701 unformat_input_t *input = vam->input;
18702 vl_api_pg_enable_disable_t *mp;
18705 u8 stream_name_set = 0;
18706 u8 *stream_name = 0;
18708 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18710 if (unformat (input, "stream %s", &stream_name))
18711 stream_name_set = 1;
18712 else if (unformat (input, "disable"))
18718 if (stream_name_set > 0)
18720 if (vec_len (stream_name) > 255)
18722 errmsg ("stream name too long");
18727 u32 name_len = vec_len (stream_name);
18728 /* Construct the API message */
18729 M (PG_ENABLE_DISABLE, mp);
18731 mp->is_enabled = enable;
18732 if (stream_name_set != 0)
18734 mp->stream_name_length = ntohl (name_len);
18735 clib_memcpy (mp->stream_name, stream_name, name_len);
18737 vec_free (stream_name);
18745 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18747 unformat_input_t *input = vam->input;
18748 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18750 u16 *low_ports = 0;
18751 u16 *high_ports = 0;
18754 vl_api_prefix_t prefix;
18761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18763 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18765 else if (unformat (input, "vrf %d", &vrf_id))
18767 else if (unformat (input, "del"))
18769 else if (unformat (input, "port %d", &tmp))
18771 if (tmp == 0 || tmp > 65535)
18773 errmsg ("port %d out of range", tmp);
18777 this_hi = this_low + 1;
18778 vec_add1 (low_ports, this_low);
18779 vec_add1 (high_ports, this_hi);
18781 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18783 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18785 errmsg ("incorrect range parameters");
18789 /* Note: in debug CLI +1 is added to high before
18790 passing to real fn that does "the work"
18791 (ip_source_and_port_range_check_add_del).
18792 This fn is a wrapper around the binary API fn a
18793 control plane will call, which expects this increment
18794 to have occurred. Hence letting the binary API control
18795 plane fn do the increment for consistency between VAT
18796 and other control planes.
18799 vec_add1 (low_ports, this_low);
18800 vec_add1 (high_ports, this_hi);
18806 if (prefix_set == 0)
18808 errmsg ("<address>/<mask> not specified");
18814 errmsg ("VRF ID required, not specified");
18821 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18825 if (vec_len (low_ports) == 0)
18827 errmsg ("At least one port or port range required");
18831 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18833 mp->is_add = is_add;
18835 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18837 mp->number_of_ranges = vec_len (low_ports);
18839 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18840 vec_free (low_ports);
18842 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18843 vec_free (high_ports);
18845 mp->vrf_id = ntohl (vrf_id);
18853 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18855 unformat_input_t *input = vam->input;
18856 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18857 u32 sw_if_index = ~0;
18859 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18860 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18864 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18866 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18868 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18870 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18872 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18874 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18876 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18878 else if (unformat (input, "del"))
18884 if (sw_if_index == ~0)
18886 errmsg ("Interface required but not specified");
18892 errmsg ("VRF ID required but not specified");
18896 if (tcp_out_vrf_id == 0
18897 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18900 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18904 /* Construct the API message */
18905 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18907 mp->sw_if_index = ntohl (sw_if_index);
18908 mp->is_add = is_add;
18909 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18910 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18911 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18912 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18917 /* Wait for a reply... */
18923 api_set_punt (vat_main_t * vam)
18925 unformat_input_t *i = vam->input;
18926 vl_api_address_family_t af;
18927 vl_api_set_punt_t *mp;
18933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18935 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18937 else if (unformat (i, "protocol %d", &protocol))
18939 else if (unformat (i, "port %d", &port))
18941 else if (unformat (i, "del"))
18945 clib_warning ("parse error '%U'", format_unformat_error, i);
18952 mp->is_add = (u8) is_add;
18953 mp->punt.type = PUNT_API_TYPE_L4;
18954 mp->punt.punt.l4.af = af;
18955 mp->punt.punt.l4.protocol = (u8) protocol;
18956 mp->punt.punt.l4.port = htons ((u16) port);
18964 api_delete_subif (vat_main_t * vam)
18966 unformat_input_t *i = vam->input;
18967 vl_api_delete_subif_t *mp;
18968 u32 sw_if_index = ~0;
18971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18973 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18975 if (unformat (i, "sw_if_index %d", &sw_if_index))
18981 if (sw_if_index == ~0)
18983 errmsg ("missing sw_if_index");
18987 /* Construct the API message */
18988 M (DELETE_SUBIF, mp);
18989 mp->sw_if_index = ntohl (sw_if_index);
18996 #define foreach_pbb_vtr_op \
18997 _("disable", L2_VTR_DISABLED) \
18998 _("pop", L2_VTR_POP_2) \
18999 _("push", L2_VTR_PUSH_2)
19002 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
19004 unformat_input_t *i = vam->input;
19005 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
19006 u32 sw_if_index = ~0, vtr_op = ~0;
19007 u16 outer_tag = ~0;
19008 u8 dmac[6], smac[6];
19009 u8 dmac_set = 0, smac_set = 0;
19015 /* Shut up coverity */
19016 clib_memset (dmac, 0, sizeof (dmac));
19017 clib_memset (smac, 0, sizeof (smac));
19019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19021 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19023 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19025 else if (unformat (i, "vtr_op %d", &vtr_op))
19027 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
19030 else if (unformat (i, "translate_pbb_stag"))
19032 if (unformat (i, "%d", &tmp))
19034 vtr_op = L2_VTR_TRANSLATE_2_1;
19040 ("translate_pbb_stag operation requires outer tag definition");
19044 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
19046 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
19048 else if (unformat (i, "sid %d", &sid))
19050 else if (unformat (i, "vlanid %d", &tmp))
19054 clib_warning ("parse error '%U'", format_unformat_error, i);
19059 if ((sw_if_index == ~0) || (vtr_op == ~0))
19061 errmsg ("missing sw_if_index or vtr operation");
19064 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19065 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19068 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19072 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19073 mp->sw_if_index = ntohl (sw_if_index);
19074 mp->vtr_op = ntohl (vtr_op);
19075 mp->outer_tag = ntohs (outer_tag);
19076 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19077 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19078 mp->b_vlanid = ntohs (vlanid);
19079 mp->i_sid = ntohl (sid);
19087 api_flow_classify_set_interface (vat_main_t * vam)
19089 unformat_input_t *i = vam->input;
19090 vl_api_flow_classify_set_interface_t *mp;
19092 int sw_if_index_set;
19093 u32 ip4_table_index = ~0;
19094 u32 ip6_table_index = ~0;
19098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19100 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19101 sw_if_index_set = 1;
19102 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19103 sw_if_index_set = 1;
19104 else if (unformat (i, "del"))
19106 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19108 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19112 clib_warning ("parse error '%U'", format_unformat_error, i);
19117 if (sw_if_index_set == 0)
19119 errmsg ("missing interface name or sw_if_index");
19123 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19125 mp->sw_if_index = ntohl (sw_if_index);
19126 mp->ip4_table_index = ntohl (ip4_table_index);
19127 mp->ip6_table_index = ntohl (ip6_table_index);
19128 mp->is_add = is_add;
19136 api_flow_classify_dump (vat_main_t * vam)
19138 unformat_input_t *i = vam->input;
19139 vl_api_flow_classify_dump_t *mp;
19140 vl_api_control_ping_t *mp_ping;
19141 u8 type = FLOW_CLASSIFY_N_TABLES;
19144 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19148 errmsg ("classify table type must be specified");
19152 if (!vam->json_output)
19154 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19157 M (FLOW_CLASSIFY_DUMP, mp);
19162 /* Use a control ping for synchronization */
19163 MPING (CONTROL_PING, mp_ping);
19166 /* Wait for a reply... */
19172 api_feature_enable_disable (vat_main_t * vam)
19174 unformat_input_t *i = vam->input;
19175 vl_api_feature_enable_disable_t *mp;
19177 u8 *feature_name = 0;
19178 u32 sw_if_index = ~0;
19182 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19184 if (unformat (i, "arc_name %s", &arc_name))
19186 else if (unformat (i, "feature_name %s", &feature_name))
19189 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19191 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19193 else if (unformat (i, "disable"))
19201 errmsg ("missing arc name");
19204 if (vec_len (arc_name) > 63)
19206 errmsg ("arc name too long");
19209 if (feature_name == 0)
19211 errmsg ("missing feature name");
19214 if (vec_len (feature_name) > 63)
19216 errmsg ("feature name too long");
19219 if (sw_if_index == ~0)
19221 errmsg ("missing interface name or sw_if_index");
19225 /* Construct the API message */
19226 M (FEATURE_ENABLE_DISABLE, mp);
19227 mp->sw_if_index = ntohl (sw_if_index);
19228 mp->enable = enable;
19229 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19230 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19231 vec_free (arc_name);
19232 vec_free (feature_name);
19240 api_feature_gso_enable_disable (vat_main_t * vam)
19242 unformat_input_t *i = vam->input;
19243 vl_api_feature_gso_enable_disable_t *mp;
19244 u32 sw_if_index = ~0;
19248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19250 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19252 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19254 else if (unformat (i, "enable"))
19256 else if (unformat (i, "disable"))
19262 if (sw_if_index == ~0)
19264 errmsg ("missing interface name or sw_if_index");
19268 /* Construct the API message */
19269 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19270 mp->sw_if_index = ntohl (sw_if_index);
19271 mp->enable_disable = enable;
19279 api_sw_interface_tag_add_del (vat_main_t * vam)
19281 unformat_input_t *i = vam->input;
19282 vl_api_sw_interface_tag_add_del_t *mp;
19283 u32 sw_if_index = ~0;
19288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19290 if (unformat (i, "tag %s", &tag))
19292 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19294 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19296 else if (unformat (i, "del"))
19302 if (sw_if_index == ~0)
19304 errmsg ("missing interface name or sw_if_index");
19308 if (enable && (tag == 0))
19310 errmsg ("no tag specified");
19314 /* Construct the API message */
19315 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19316 mp->sw_if_index = ntohl (sw_if_index);
19317 mp->is_add = enable;
19319 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19328 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19330 unformat_input_t *i = vam->input;
19331 vl_api_mac_address_t mac = { 0 };
19332 vl_api_sw_interface_add_del_mac_address_t *mp;
19333 u32 sw_if_index = ~0;
19338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19340 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19342 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19344 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19346 else if (unformat (i, "del"))
19352 if (sw_if_index == ~0)
19354 errmsg ("missing interface name or sw_if_index");
19360 errmsg ("missing MAC address");
19364 /* Construct the API message */
19365 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19366 mp->sw_if_index = ntohl (sw_if_index);
19367 mp->is_add = is_add;
19368 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19375 static void vl_api_l2_xconnect_details_t_handler
19376 (vl_api_l2_xconnect_details_t * mp)
19378 vat_main_t *vam = &vat_main;
19380 print (vam->ofp, "%15d%15d",
19381 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19384 static void vl_api_l2_xconnect_details_t_handler_json
19385 (vl_api_l2_xconnect_details_t * mp)
19387 vat_main_t *vam = &vat_main;
19388 vat_json_node_t *node = NULL;
19390 if (VAT_JSON_ARRAY != vam->json_tree.type)
19392 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19393 vat_json_init_array (&vam->json_tree);
19395 node = vat_json_array_add (&vam->json_tree);
19397 vat_json_init_object (node);
19398 vat_json_object_add_uint (node, "rx_sw_if_index",
19399 ntohl (mp->rx_sw_if_index));
19400 vat_json_object_add_uint (node, "tx_sw_if_index",
19401 ntohl (mp->tx_sw_if_index));
19405 api_l2_xconnect_dump (vat_main_t * vam)
19407 vl_api_l2_xconnect_dump_t *mp;
19408 vl_api_control_ping_t *mp_ping;
19411 if (!vam->json_output)
19413 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19416 M (L2_XCONNECT_DUMP, mp);
19420 /* Use a control ping for synchronization */
19421 MPING (CONTROL_PING, mp_ping);
19429 api_hw_interface_set_mtu (vat_main_t * vam)
19431 unformat_input_t *i = vam->input;
19432 vl_api_hw_interface_set_mtu_t *mp;
19433 u32 sw_if_index = ~0;
19437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19439 if (unformat (i, "mtu %d", &mtu))
19441 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19443 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19449 if (sw_if_index == ~0)
19451 errmsg ("missing interface name or sw_if_index");
19457 errmsg ("no mtu specified");
19461 /* Construct the API message */
19462 M (HW_INTERFACE_SET_MTU, mp);
19463 mp->sw_if_index = ntohl (sw_if_index);
19464 mp->mtu = ntohs ((u16) mtu);
19472 api_p2p_ethernet_add (vat_main_t * vam)
19474 unformat_input_t *i = vam->input;
19475 vl_api_p2p_ethernet_add_t *mp;
19476 u32 parent_if_index = ~0;
19482 clib_memset (remote_mac, 0, sizeof (remote_mac));
19483 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19485 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19487 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19491 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19493 else if (unformat (i, "sub_id %d", &sub_id))
19497 clib_warning ("parse error '%U'", format_unformat_error, i);
19502 if (parent_if_index == ~0)
19504 errmsg ("missing interface name or sw_if_index");
19509 errmsg ("missing remote mac address");
19514 errmsg ("missing sub-interface id");
19518 M (P2P_ETHERNET_ADD, mp);
19519 mp->parent_if_index = ntohl (parent_if_index);
19520 mp->subif_id = ntohl (sub_id);
19521 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19529 api_p2p_ethernet_del (vat_main_t * vam)
19531 unformat_input_t *i = vam->input;
19532 vl_api_p2p_ethernet_del_t *mp;
19533 u32 parent_if_index = ~0;
19538 clib_memset (remote_mac, 0, sizeof (remote_mac));
19539 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19541 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19543 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19547 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19551 clib_warning ("parse error '%U'", format_unformat_error, i);
19556 if (parent_if_index == ~0)
19558 errmsg ("missing interface name or sw_if_index");
19563 errmsg ("missing remote mac address");
19567 M (P2P_ETHERNET_DEL, mp);
19568 mp->parent_if_index = ntohl (parent_if_index);
19569 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19577 api_lldp_config (vat_main_t * vam)
19579 unformat_input_t *i = vam->input;
19580 vl_api_lldp_config_t *mp;
19582 int tx_interval = 0;
19583 u8 *sys_name = NULL;
19586 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19588 if (unformat (i, "system-name %s", &sys_name))
19590 else if (unformat (i, "tx-hold %d", &tx_hold))
19592 else if (unformat (i, "tx-interval %d", &tx_interval))
19596 clib_warning ("parse error '%U'", format_unformat_error, i);
19601 vec_add1 (sys_name, 0);
19603 M (LLDP_CONFIG, mp);
19604 mp->tx_hold = htonl (tx_hold);
19605 mp->tx_interval = htonl (tx_interval);
19606 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19607 vec_free (sys_name);
19615 api_sw_interface_set_lldp (vat_main_t * vam)
19617 unformat_input_t *i = vam->input;
19618 vl_api_sw_interface_set_lldp_t *mp;
19619 u32 sw_if_index = ~0;
19621 u8 *port_desc = NULL, *mgmt_oid = NULL;
19622 ip4_address_t ip4_addr;
19623 ip6_address_t ip6_addr;
19626 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19627 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19631 if (unformat (i, "disable"))
19634 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19636 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19638 else if (unformat (i, "port-desc %s", &port_desc))
19640 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19642 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19644 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19650 if (sw_if_index == ~0)
19652 errmsg ("missing interface name or sw_if_index");
19656 /* Construct the API message */
19657 vec_add1 (port_desc, 0);
19658 vec_add1 (mgmt_oid, 0);
19659 M (SW_INTERFACE_SET_LLDP, mp);
19660 mp->sw_if_index = ntohl (sw_if_index);
19661 mp->enable = enable;
19662 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19663 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19664 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19665 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19666 vec_free (port_desc);
19667 vec_free (mgmt_oid);
19675 api_tcp_configure_src_addresses (vat_main_t * vam)
19677 vl_api_tcp_configure_src_addresses_t *mp;
19678 unformat_input_t *i = vam->input;
19679 vl_api_address_t first, last;
19684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19686 if (unformat (i, "%U - %U",
19687 unformat_vl_api_address, &first,
19688 unformat_vl_api_address, &last))
19692 errmsg ("one range per message (range already set)");
19697 else if (unformat (i, "vrf %d", &vrf_id))
19703 if (range_set == 0)
19705 errmsg ("address range not set");
19709 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19711 mp->vrf_id = ntohl (vrf_id);
19712 clib_memcpy (&mp->first_address, &first, sizeof (first));
19713 clib_memcpy (&mp->last_address, &last, sizeof (last));
19720 static void vl_api_app_namespace_add_del_reply_t_handler
19721 (vl_api_app_namespace_add_del_reply_t * mp)
19723 vat_main_t *vam = &vat_main;
19724 i32 retval = ntohl (mp->retval);
19725 if (vam->async_mode)
19727 vam->async_errors += (retval < 0);
19731 vam->retval = retval;
19733 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19734 vam->result_ready = 1;
19738 static void vl_api_app_namespace_add_del_reply_t_handler_json
19739 (vl_api_app_namespace_add_del_reply_t * mp)
19741 vat_main_t *vam = &vat_main;
19742 vat_json_node_t node;
19744 vat_json_init_object (&node);
19745 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19746 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19748 vat_json_print (vam->ofp, &node);
19749 vat_json_free (&node);
19751 vam->retval = ntohl (mp->retval);
19752 vam->result_ready = 1;
19756 api_app_namespace_add_del (vat_main_t * vam)
19758 vl_api_app_namespace_add_del_t *mp;
19759 unformat_input_t *i = vam->input;
19760 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19761 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19767 if (unformat (i, "id %_%v%_", &ns_id))
19769 else if (unformat (i, "secret %lu", &secret))
19771 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19772 sw_if_index_set = 1;
19773 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19775 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19780 if (!ns_id || !secret_set || !sw_if_index_set)
19782 errmsg ("namespace id, secret and sw_if_index must be set");
19785 if (vec_len (ns_id) > 64)
19787 errmsg ("namespace id too long");
19790 M (APP_NAMESPACE_ADD_DEL, mp);
19792 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
19793 mp->namespace_id_len = vec_len (ns_id);
19794 mp->secret = clib_host_to_net_u64 (secret);
19795 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19796 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19797 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19805 api_sock_init_shm (vat_main_t * vam)
19807 #if VPP_API_TEST_BUILTIN == 0
19808 unformat_input_t *i = vam->input;
19809 vl_api_shm_elem_config_t *config = 0;
19810 u64 size = 64 << 20;
19813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19815 if (unformat (i, "size %U", unformat_memory_size, &size))
19822 * Canned custom ring allocator config.
19823 * Should probably parse all of this
19825 vec_validate (config, 6);
19826 config[0].type = VL_API_VLIB_RING;
19827 config[0].size = 256;
19828 config[0].count = 32;
19830 config[1].type = VL_API_VLIB_RING;
19831 config[1].size = 1024;
19832 config[1].count = 16;
19834 config[2].type = VL_API_VLIB_RING;
19835 config[2].size = 4096;
19836 config[2].count = 2;
19838 config[3].type = VL_API_CLIENT_RING;
19839 config[3].size = 256;
19840 config[3].count = 32;
19842 config[4].type = VL_API_CLIENT_RING;
19843 config[4].size = 1024;
19844 config[4].count = 16;
19846 config[5].type = VL_API_CLIENT_RING;
19847 config[5].size = 4096;
19848 config[5].count = 2;
19850 config[6].type = VL_API_QUEUE;
19851 config[6].count = 128;
19852 config[6].size = sizeof (uword);
19854 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19856 vam->client_index_invalid = 1;
19864 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19866 vat_main_t *vam = &vat_main;
19871 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19872 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19873 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
19874 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19875 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19876 clib_net_to_host_u32 (mp->action_index), mp->tag);
19881 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19882 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19883 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
19884 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19885 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19886 clib_net_to_host_u32 (mp->action_index), mp->tag);
19891 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19894 vat_main_t *vam = &vat_main;
19895 vat_json_node_t *node = NULL;
19896 struct in6_addr ip6;
19897 struct in_addr ip4;
19899 if (VAT_JSON_ARRAY != vam->json_tree.type)
19901 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19902 vat_json_init_array (&vam->json_tree);
19904 node = vat_json_array_add (&vam->json_tree);
19905 vat_json_init_object (node);
19907 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
19908 vat_json_object_add_uint (node, "appns_index",
19909 clib_net_to_host_u32 (mp->appns_index));
19910 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19911 vat_json_object_add_uint (node, "scope", mp->scope);
19912 vat_json_object_add_uint (node, "action_index",
19913 clib_net_to_host_u32 (mp->action_index));
19914 vat_json_object_add_uint (node, "lcl_port",
19915 clib_net_to_host_u16 (mp->lcl_port));
19916 vat_json_object_add_uint (node, "rmt_port",
19917 clib_net_to_host_u16 (mp->rmt_port));
19918 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
19919 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
19920 vat_json_object_add_string_copy (node, "tag", mp->tag);
19923 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
19924 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19925 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
19926 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19930 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
19931 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19932 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
19933 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19938 api_session_rule_add_del (vat_main_t * vam)
19940 vl_api_session_rule_add_del_t *mp;
19941 unformat_input_t *i = vam->input;
19942 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19943 u32 appns_index = 0, scope = 0;
19944 ip4_address_t lcl_ip4, rmt_ip4;
19945 ip6_address_t lcl_ip6, rmt_ip6;
19946 u8 is_ip4 = 1, conn_set = 0;
19947 u8 is_add = 1, *tag = 0;
19950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19952 if (unformat (i, "del"))
19954 else if (unformat (i, "add"))
19956 else if (unformat (i, "proto tcp"))
19958 else if (unformat (i, "proto udp"))
19960 else if (unformat (i, "appns %d", &appns_index))
19962 else if (unformat (i, "scope %d", &scope))
19964 else if (unformat (i, "tag %_%v%_", &tag))
19968 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19969 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19977 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19978 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19984 else if (unformat (i, "action %d", &action))
19989 if (proto == ~0 || !conn_set || action == ~0)
19991 errmsg ("transport proto, connection and action must be set");
19997 errmsg ("scope should be 0-3");
20001 M (SESSION_RULE_ADD_DEL, mp);
20003 mp->is_ip4 = is_ip4;
20004 mp->transport_proto = proto;
20005 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
20006 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
20007 mp->lcl_plen = lcl_plen;
20008 mp->rmt_plen = rmt_plen;
20009 mp->action_index = clib_host_to_net_u32 (action);
20010 mp->appns_index = clib_host_to_net_u32 (appns_index);
20012 mp->is_add = is_add;
20015 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
20016 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
20020 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
20021 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
20025 clib_memcpy (mp->tag, tag, vec_len (tag));
20035 api_session_rules_dump (vat_main_t * vam)
20037 vl_api_session_rules_dump_t *mp;
20038 vl_api_control_ping_t *mp_ping;
20041 if (!vam->json_output)
20043 print (vam->ofp, "%=20s", "Session Rules");
20046 M (SESSION_RULES_DUMP, mp);
20050 /* Use a control ping for synchronization */
20051 MPING (CONTROL_PING, mp_ping);
20054 /* Wait for a reply... */
20060 api_ip_container_proxy_add_del (vat_main_t * vam)
20062 vl_api_ip_container_proxy_add_del_t *mp;
20063 unformat_input_t *i = vam->input;
20064 u32 sw_if_index = ~0;
20065 vl_api_prefix_t pfx = { };
20069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20071 if (unformat (i, "del"))
20073 else if (unformat (i, "add"))
20075 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20077 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20082 if (sw_if_index == ~0 || pfx.len == 0)
20084 errmsg ("address and sw_if_index must be set");
20088 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20090 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20091 mp->is_add = is_add;
20092 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20100 api_qos_record_enable_disable (vat_main_t * vam)
20102 unformat_input_t *i = vam->input;
20103 vl_api_qos_record_enable_disable_t *mp;
20104 u32 sw_if_index, qs = 0xff;
20105 u8 sw_if_index_set = 0;
20109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20111 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20112 sw_if_index_set = 1;
20113 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20114 sw_if_index_set = 1;
20115 else if (unformat (i, "%U", unformat_qos_source, &qs))
20117 else if (unformat (i, "disable"))
20121 clib_warning ("parse error '%U'", format_unformat_error, i);
20126 if (sw_if_index_set == 0)
20128 errmsg ("missing interface name or sw_if_index");
20133 errmsg ("input location must be specified");
20137 M (QOS_RECORD_ENABLE_DISABLE, mp);
20139 mp->record.sw_if_index = ntohl (sw_if_index);
20140 mp->record.input_source = qs;
20141 mp->enable = enable;
20150 q_or_quit (vat_main_t * vam)
20152 #if VPP_API_TEST_BUILTIN == 0
20153 longjmp (vam->jump_buf, 1);
20155 return 0; /* not so much */
20159 q (vat_main_t * vam)
20161 return q_or_quit (vam);
20165 quit (vat_main_t * vam)
20167 return q_or_quit (vam);
20171 comment (vat_main_t * vam)
20177 elog_save (vat_main_t * vam)
20179 #if VPP_API_TEST_BUILTIN == 0
20180 elog_main_t *em = &vam->elog_main;
20181 unformat_input_t *i = vam->input;
20182 char *file, *chroot_file;
20183 clib_error_t *error;
20185 if (!unformat (i, "%s", &file))
20187 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20191 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20192 if (strstr (file, "..") || index (file, '/'))
20194 errmsg ("illegal characters in filename '%s'", file);
20198 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20202 errmsg ("Saving %wd of %wd events to %s",
20203 elog_n_events_in_buffer (em),
20204 elog_buffer_capacity (em), chroot_file);
20206 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20207 vec_free (chroot_file);
20210 clib_error_report (error);
20212 errmsg ("Use the vpp event loger...");
20219 elog_setup (vat_main_t * vam)
20221 #if VPP_API_TEST_BUILTIN == 0
20222 elog_main_t *em = &vam->elog_main;
20223 unformat_input_t *i = vam->input;
20224 u32 nevents = 128 << 10;
20226 (void) unformat (i, "nevents %d", &nevents);
20228 elog_init (em, nevents);
20229 vl_api_set_elog_main (em);
20230 vl_api_set_elog_trace_api_messages (1);
20231 errmsg ("Event logger initialized with %u events", nevents);
20233 errmsg ("Use the vpp event loger...");
20239 elog_enable (vat_main_t * vam)
20241 #if VPP_API_TEST_BUILTIN == 0
20242 elog_main_t *em = &vam->elog_main;
20244 elog_enable_disable (em, 1 /* enable */ );
20245 vl_api_set_elog_trace_api_messages (1);
20246 errmsg ("Event logger enabled...");
20248 errmsg ("Use the vpp event loger...");
20254 elog_disable (vat_main_t * vam)
20256 #if VPP_API_TEST_BUILTIN == 0
20257 elog_main_t *em = &vam->elog_main;
20259 elog_enable_disable (em, 0 /* enable */ );
20260 vl_api_set_elog_trace_api_messages (1);
20261 errmsg ("Event logger disabled...");
20263 errmsg ("Use the vpp event loger...");
20269 statseg (vat_main_t * vam)
20271 ssvm_private_t *ssvmp = &vam->stat_segment;
20272 ssvm_shared_header_t *shared_header = ssvmp->sh;
20273 vlib_counter_t **counters;
20274 u64 thread0_index1_packets;
20275 u64 thread0_index1_bytes;
20276 f64 vector_rate, input_rate;
20279 uword *counter_vector_by_name;
20280 if (vam->stat_segment_lockp == 0)
20282 errmsg ("Stat segment not mapped...");
20286 /* look up "/if/rx for sw_if_index 1 as a test */
20288 clib_spinlock_lock (vam->stat_segment_lockp);
20290 counter_vector_by_name = (uword *) shared_header->opaque[1];
20292 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20295 clib_spinlock_unlock (vam->stat_segment_lockp);
20296 errmsg ("/if/tx not found?");
20300 /* Fish per-thread vector of combined counters from shared memory */
20301 counters = (vlib_counter_t **) p[0];
20303 if (vec_len (counters[0]) < 2)
20305 clib_spinlock_unlock (vam->stat_segment_lockp);
20306 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20310 /* Read thread 0 sw_if_index 1 counter */
20311 thread0_index1_packets = counters[0][1].packets;
20312 thread0_index1_bytes = counters[0][1].bytes;
20314 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20317 clib_spinlock_unlock (vam->stat_segment_lockp);
20318 errmsg ("vector_rate not found?");
20322 vector_rate = *(f64 *) (p[0]);
20323 p = hash_get_mem (counter_vector_by_name, "input_rate");
20326 clib_spinlock_unlock (vam->stat_segment_lockp);
20327 errmsg ("input_rate not found?");
20330 input_rate = *(f64 *) (p[0]);
20332 clib_spinlock_unlock (vam->stat_segment_lockp);
20334 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20335 vector_rate, input_rate);
20336 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20337 thread0_index1_packets, thread0_index1_bytes);
20343 cmd_cmp (void *a1, void *a2)
20348 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20352 help (vat_main_t * vam)
20357 unformat_input_t *i = vam->input;
20360 if (unformat (i, "%s", &name))
20364 vec_add1 (name, 0);
20366 hs = hash_get_mem (vam->help_by_name, name);
20368 print (vam->ofp, "usage: %s %s", name, hs[0]);
20370 print (vam->ofp, "No such msg / command '%s'", name);
20375 print (vam->ofp, "Help is available for the following:");
20378 hash_foreach_pair (p, vam->function_by_name,
20380 vec_add1 (cmds, (u8 *)(p->key));
20384 vec_sort_with_function (cmds, cmd_cmp);
20386 for (j = 0; j < vec_len (cmds); j++)
20387 print (vam->ofp, "%s", cmds[j]);
20394 set (vat_main_t * vam)
20396 u8 *name = 0, *value = 0;
20397 unformat_input_t *i = vam->input;
20399 if (unformat (i, "%s", &name))
20401 /* The input buffer is a vector, not a string. */
20402 value = vec_dup (i->buffer);
20403 vec_delete (value, i->index, 0);
20404 /* Almost certainly has a trailing newline */
20405 if (value[vec_len (value) - 1] == '\n')
20406 value[vec_len (value) - 1] = 0;
20407 /* Make sure it's a proper string, one way or the other */
20408 vec_add1 (value, 0);
20409 (void) clib_macro_set_value (&vam->macro_main,
20410 (char *) name, (char *) value);
20413 errmsg ("usage: set <name> <value>");
20421 unset (vat_main_t * vam)
20425 if (unformat (vam->input, "%s", &name))
20426 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20427 errmsg ("unset: %s wasn't set", name);
20440 macro_sort_cmp (void *a1, void *a2)
20442 macro_sort_t *s1 = a1;
20443 macro_sort_t *s2 = a2;
20445 return strcmp ((char *) (s1->name), (char *) (s2->name));
20449 dump_macro_table (vat_main_t * vam)
20451 macro_sort_t *sort_me = 0, *sm;
20456 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20458 vec_add2 (sort_me, sm, 1);
20459 sm->name = (u8 *)(p->key);
20460 sm->value = (u8 *) (p->value[0]);
20464 vec_sort_with_function (sort_me, macro_sort_cmp);
20466 if (vec_len (sort_me))
20467 print (vam->ofp, "%-15s%s", "Name", "Value");
20469 print (vam->ofp, "The macro table is empty...");
20471 for (i = 0; i < vec_len (sort_me); i++)
20472 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20477 dump_node_table (vat_main_t * vam)
20480 vlib_node_t *node, *next_node;
20482 if (vec_len (vam->graph_nodes) == 0)
20484 print (vam->ofp, "Node table empty, issue get_node_graph...");
20488 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20490 node = vam->graph_nodes[0][i];
20491 print (vam->ofp, "[%d] %s", i, node->name);
20492 for (j = 0; j < vec_len (node->next_nodes); j++)
20494 if (node->next_nodes[j] != ~0)
20496 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20497 print (vam->ofp, " [%d] %s", j, next_node->name);
20505 value_sort_cmp (void *a1, void *a2)
20507 name_sort_t *n1 = a1;
20508 name_sort_t *n2 = a2;
20510 if (n1->value < n2->value)
20512 if (n1->value > n2->value)
20519 dump_msg_api_table (vat_main_t * vam)
20521 api_main_t *am = vlibapi_get_main ();
20522 name_sort_t *nses = 0, *ns;
20527 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20529 vec_add2 (nses, ns, 1);
20530 ns->name = (u8 *)(hp->key);
20531 ns->value = (u32) hp->value[0];
20535 vec_sort_with_function (nses, value_sort_cmp);
20537 for (i = 0; i < vec_len (nses); i++)
20538 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20544 get_msg_id (vat_main_t * vam)
20549 if (unformat (vam->input, "%s", &name_and_crc))
20551 message_index = vl_msg_api_get_msg_index (name_and_crc);
20552 if (message_index == ~0)
20554 print (vam->ofp, " '%s' not found", name_and_crc);
20557 print (vam->ofp, " '%s' has message index %d",
20558 name_and_crc, message_index);
20561 errmsg ("name_and_crc required...");
20566 search_node_table (vat_main_t * vam)
20568 unformat_input_t *line_input = vam->input;
20571 vlib_node_t *node, *next_node;
20574 if (vam->graph_node_index_by_name == 0)
20576 print (vam->ofp, "Node table empty, issue get_node_graph...");
20580 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20582 if (unformat (line_input, "%s", &node_to_find))
20584 vec_add1 (node_to_find, 0);
20585 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20588 print (vam->ofp, "%s not found...", node_to_find);
20591 node = vam->graph_nodes[0][p[0]];
20592 print (vam->ofp, "[%d] %s", p[0], node->name);
20593 for (j = 0; j < vec_len (node->next_nodes); j++)
20595 if (node->next_nodes[j] != ~0)
20597 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20598 print (vam->ofp, " [%d] %s", j, next_node->name);
20605 clib_warning ("parse error '%U'", format_unformat_error,
20611 vec_free (node_to_find);
20620 script (vat_main_t * vam)
20622 #if (VPP_API_TEST_BUILTIN==0)
20624 char *save_current_file;
20625 unformat_input_t save_input;
20626 jmp_buf save_jump_buf;
20627 u32 save_line_number;
20629 FILE *new_fp, *save_ifp;
20631 if (unformat (vam->input, "%s", &s))
20633 new_fp = fopen ((char *) s, "r");
20636 errmsg ("Couldn't open script file %s", s);
20643 errmsg ("Missing script name");
20647 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20648 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20649 save_ifp = vam->ifp;
20650 save_line_number = vam->input_line_number;
20651 save_current_file = (char *) vam->current_file;
20653 vam->input_line_number = 0;
20655 vam->current_file = s;
20658 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20659 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20660 vam->ifp = save_ifp;
20661 vam->input_line_number = save_line_number;
20662 vam->current_file = (u8 *) save_current_file;
20667 clib_warning ("use the exec command...");
20673 echo (vat_main_t * vam)
20675 print (vam->ofp, "%v", vam->input->buffer);
20679 /* List of API message constructors, CLI names map to api_xxx */
20680 #define foreach_vpe_api_msg \
20681 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20682 _(sw_interface_dump,"") \
20683 _(sw_interface_set_flags, \
20684 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20685 _(sw_interface_add_del_address, \
20686 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20687 _(sw_interface_set_rx_mode, \
20688 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20689 _(sw_interface_set_rx_placement, \
20690 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20691 _(sw_interface_rx_placement_dump, \
20692 "[<intfc> | sw_if_index <id>]") \
20693 _(sw_interface_set_table, \
20694 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20695 _(sw_interface_set_mpls_enable, \
20696 "<intfc> | sw_if_index [disable | dis]") \
20697 _(sw_interface_set_vpath, \
20698 "<intfc> | sw_if_index <id> enable | disable") \
20699 _(sw_interface_set_vxlan_bypass, \
20700 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20701 _(sw_interface_set_geneve_bypass, \
20702 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20703 _(sw_interface_set_l2_xconnect, \
20704 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20705 "enable | disable") \
20706 _(sw_interface_set_l2_bridge, \
20707 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20708 "[shg <split-horizon-group>] [bvi]\n" \
20709 "enable | disable") \
20710 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20711 _(bridge_domain_add_del, \
20712 "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") \
20713 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20715 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20716 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20717 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20719 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20721 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20723 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
20725 "<vpp-if-name> | sw_if_index <id>") \
20726 _(sw_interface_tap_v2_dump, "") \
20727 _(virtio_pci_create, \
20728 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20729 _(virtio_pci_delete, \
20730 "<vpp-if-name> | sw_if_index <id>") \
20731 _(sw_interface_virtio_pci_dump, "") \
20733 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20734 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20737 "<vpp-if-name> | sw_if_index <id>") \
20739 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20740 _(bond_detach_slave, \
20741 "sw_if_index <n>") \
20742 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20743 _(sw_interface_bond_dump, "") \
20744 _(sw_interface_slave_dump, \
20745 "<vpp-if-name> | sw_if_index <id>") \
20746 _(ip_table_add_del, \
20747 "table <n> [ipv6] [add | del]\n") \
20748 _(ip_route_add_del, \
20749 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20750 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20751 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20752 "[multipath] [count <n>] [del]") \
20753 _(ip_mroute_add_del, \
20754 "<src> <grp>/<mask> [table-id <n>]\n" \
20755 "[<intfc> | sw_if_index <id>] [local] [del]") \
20756 _(mpls_table_add_del, \
20757 "table <n> [add | del]\n") \
20758 _(mpls_route_add_del, \
20759 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20760 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20761 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20762 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20763 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20764 "[count <n>] [del]") \
20765 _(mpls_ip_bind_unbind, \
20766 "<label> <addr/len>") \
20767 _(mpls_tunnel_add_del, \
20768 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20769 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20770 "[l2-only] [out-label <n>]") \
20771 _(sr_mpls_policy_add, \
20772 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20773 _(sr_mpls_policy_del, \
20775 _(bier_table_add_del, \
20776 "<label> <sub-domain> <set> <bsl> [del]") \
20777 _(bier_route_add_del, \
20778 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20779 "[<intfc> | sw_if_index <id>]" \
20780 "[weight <n>] [del] [multipath]") \
20781 _(sw_interface_set_unnumbered, \
20782 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20783 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20784 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20785 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20786 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20787 "[outer_vlan_id_any][inner_vlan_id_any]") \
20788 _(ip_table_replace_begin, "table <n> [ipv6]") \
20789 _(ip_table_flush, "table <n> [ipv6]") \
20790 _(ip_table_replace_end, "table <n> [ipv6]") \
20791 _(set_ip_flow_hash, \
20792 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20793 _(sw_interface_ip6_enable_disable, \
20794 "<intfc> | sw_if_index <id> enable | disable") \
20795 _(l2_patch_add_del, \
20796 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20797 "enable | disable") \
20798 _(sr_localsid_add_del, \
20799 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20800 "fib-table <num> (end.psp) sw_if_index <num>") \
20801 _(classify_add_del_table, \
20802 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20803 " [del] [del-chain] mask <mask-value>\n" \
20804 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20805 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20806 _(classify_add_del_session, \
20807 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20808 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20809 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20810 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20811 _(classify_set_interface_ip_table, \
20812 "<intfc> | sw_if_index <nn> table <nn>") \
20813 _(classify_set_interface_l2_tables, \
20814 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20815 " [other-table <nn>]") \
20816 _(get_node_index, "node <node-name") \
20817 _(add_node_next, "node <node-name> next <next-node-name>") \
20818 _(l2tpv3_create_tunnel, \
20819 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20820 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20821 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20822 _(l2tpv3_set_tunnel_cookies, \
20823 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20824 "[new_remote_cookie <nn>]\n") \
20825 _(l2tpv3_interface_enable_disable, \
20826 "<intfc> | sw_if_index <nn> enable | disable") \
20827 _(l2tpv3_set_lookup_key, \
20828 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20829 _(sw_if_l2tpv3_tunnel_dump, "") \
20830 _(vxlan_offload_rx, \
20831 "hw { <interface name> | hw_if_index <nn>} " \
20832 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20833 _(vxlan_add_del_tunnel, \
20834 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20835 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20836 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20837 _(geneve_add_del_tunnel, \
20838 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20839 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20840 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20841 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20842 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20843 _(gre_tunnel_add_del, \
20844 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20845 "[teb | erspan <session-id>] [del]") \
20846 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20847 _(l2_fib_clear_table, "") \
20848 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20849 _(l2_interface_vlan_tag_rewrite, \
20850 "<intfc> | sw_if_index <nn> \n" \
20851 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20852 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20853 _(create_vhost_user_if, \
20854 "socket <filename> [server] [renumber <dev_instance>] " \
20855 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20856 "[mac <mac_address>]") \
20857 _(modify_vhost_user_if, \
20858 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20859 "[server] [renumber <dev_instance>] [gso]") \
20860 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20861 _(sw_interface_vhost_user_dump, "") \
20862 _(show_version, "") \
20863 _(show_threads, "") \
20864 _(vxlan_gpe_add_del_tunnel, \
20865 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20866 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20867 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20868 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20869 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20870 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20871 _(interface_name_renumber, \
20872 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20873 _(input_acl_set_interface, \
20874 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20875 " [l2-table <nn>] [del]") \
20876 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20877 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20878 _(ip_dump, "ipv4 | ipv6") \
20879 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20880 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20882 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20883 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20884 " integ_alg <alg> integ_key <hex>") \
20885 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20886 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20887 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20888 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20889 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20890 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20891 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20892 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20893 " [instance <n>]") \
20894 _(ipsec_sa_dump, "[sa_id <n>]") \
20895 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20896 _(delete_loopback,"sw_if_index <nn>") \
20897 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20898 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20899 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20900 _(want_interface_events, "enable|disable") \
20901 _(get_first_msg_id, "client <name>") \
20902 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20903 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20904 "fib-id <nn> [ip4][ip6][default]") \
20905 _(get_node_graph, " ") \
20906 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20907 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20908 _(ioam_disable, "") \
20909 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20910 " sw_if_index <sw_if_index> p <priority> " \
20911 "w <weight>] [del]") \
20912 _(one_add_del_locator, "locator-set <locator_name> " \
20913 "iface <intf> | sw_if_index <sw_if_index> " \
20914 "p <priority> w <weight> [del]") \
20915 _(one_add_del_local_eid,"vni <vni> eid " \
20916 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20917 "locator-set <locator_name> [del]" \
20918 "[key-id sha1|sha256 secret-key <secret-key>]")\
20919 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20920 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20921 _(one_enable_disable, "enable|disable") \
20922 _(one_map_register_enable_disable, "enable|disable") \
20923 _(one_map_register_fallback_threshold, "<value>") \
20924 _(one_rloc_probe_enable_disable, "enable|disable") \
20925 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20927 "rloc <locator> p <prio> " \
20928 "w <weight> [rloc <loc> ... ] " \
20929 "action <action> [del-all]") \
20930 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20932 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20933 _(one_use_petr, "ip-address> | disable") \
20934 _(one_map_request_mode, "src-dst|dst-only") \
20935 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20936 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20937 _(one_locator_set_dump, "[local | remote]") \
20938 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20939 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20940 "[local] | [remote]") \
20941 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20942 _(one_ndp_bd_get, "") \
20943 _(one_ndp_entries_get, "bd <bridge-domain>") \
20944 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20945 _(one_l2_arp_bd_get, "") \
20946 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20947 _(one_stats_enable_disable, "enable|disable") \
20948 _(show_one_stats_enable_disable, "") \
20949 _(one_eid_table_vni_dump, "") \
20950 _(one_eid_table_map_dump, "l2|l3") \
20951 _(one_map_resolver_dump, "") \
20952 _(one_map_server_dump, "") \
20953 _(one_adjacencies_get, "vni <vni>") \
20954 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20955 _(show_one_rloc_probe_state, "") \
20956 _(show_one_map_register_state, "") \
20957 _(show_one_status, "") \
20958 _(one_stats_dump, "") \
20959 _(one_stats_flush, "") \
20960 _(one_get_map_request_itr_rlocs, "") \
20961 _(one_map_register_set_ttl, "<ttl>") \
20962 _(one_set_transport_protocol, "udp|api") \
20963 _(one_get_transport_protocol, "") \
20964 _(one_enable_disable_xtr_mode, "enable|disable") \
20965 _(one_show_xtr_mode, "") \
20966 _(one_enable_disable_pitr_mode, "enable|disable") \
20967 _(one_show_pitr_mode, "") \
20968 _(one_enable_disable_petr_mode, "enable|disable") \
20969 _(one_show_petr_mode, "") \
20970 _(show_one_nsh_mapping, "") \
20971 _(show_one_pitr, "") \
20972 _(show_one_use_petr, "") \
20973 _(show_one_map_request_mode, "") \
20974 _(show_one_map_register_ttl, "") \
20975 _(show_one_map_register_fallback_threshold, "") \
20976 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20977 " sw_if_index <sw_if_index> p <priority> " \
20978 "w <weight>] [del]") \
20979 _(lisp_add_del_locator, "locator-set <locator_name> " \
20980 "iface <intf> | sw_if_index <sw_if_index> " \
20981 "p <priority> w <weight> [del]") \
20982 _(lisp_add_del_local_eid,"vni <vni> eid " \
20983 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20984 "locator-set <locator_name> [del]" \
20985 "[key-id sha1|sha256 secret-key <secret-key>]") \
20986 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20987 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20988 _(lisp_enable_disable, "enable|disable") \
20989 _(lisp_map_register_enable_disable, "enable|disable") \
20990 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20991 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20993 "rloc <locator> p <prio> " \
20994 "w <weight> [rloc <loc> ... ] " \
20995 "action <action> [del-all]") \
20996 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20998 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20999 _(lisp_use_petr, "<ip-address> | disable") \
21000 _(lisp_map_request_mode, "src-dst|dst-only") \
21001 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21002 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21003 _(lisp_locator_set_dump, "[local | remote]") \
21004 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
21005 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21006 "[local] | [remote]") \
21007 _(lisp_eid_table_vni_dump, "") \
21008 _(lisp_eid_table_map_dump, "l2|l3") \
21009 _(lisp_map_resolver_dump, "") \
21010 _(lisp_map_server_dump, "") \
21011 _(lisp_adjacencies_get, "vni <vni>") \
21012 _(gpe_fwd_entry_vnis_get, "") \
21013 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
21014 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
21015 "[table <table-id>]") \
21016 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
21017 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
21018 _(gpe_set_encap_mode, "lisp|vxlan") \
21019 _(gpe_get_encap_mode, "") \
21020 _(lisp_gpe_add_del_iface, "up|down") \
21021 _(lisp_gpe_enable_disable, "enable|disable") \
21022 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
21023 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
21024 _(show_lisp_rloc_probe_state, "") \
21025 _(show_lisp_map_register_state, "") \
21026 _(show_lisp_status, "") \
21027 _(lisp_get_map_request_itr_rlocs, "") \
21028 _(show_lisp_pitr, "") \
21029 _(show_lisp_use_petr, "") \
21030 _(show_lisp_map_request_mode, "") \
21031 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
21032 _(af_packet_delete, "name <host interface name>") \
21033 _(af_packet_dump, "") \
21034 _(policer_add_del, "name <policer name> <params> [del]") \
21035 _(policer_dump, "[name <policer name>]") \
21036 _(policer_classify_set_interface, \
21037 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21038 " [l2-table <nn>] [del]") \
21039 _(policer_classify_dump, "type [ip4|ip6|l2]") \
21040 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
21041 "[master|slave]") \
21042 _(netmap_delete, "name <interface name>") \
21043 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
21044 _(mpls_table_dump, "") \
21045 _(mpls_route_dump, "table-id <ID>") \
21046 _(classify_table_ids, "") \
21047 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
21048 _(classify_table_info, "table_id <nn>") \
21049 _(classify_session_dump, "table_id <nn>") \
21050 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
21051 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
21052 "[template_interval <nn>] [udp_checksum]") \
21053 _(ipfix_exporter_dump, "") \
21054 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
21055 _(ipfix_classify_stream_dump, "") \
21056 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
21057 _(ipfix_classify_table_dump, "") \
21058 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
21059 _(sw_interface_span_dump, "[l2]") \
21060 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
21061 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
21062 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
21063 _(pg_enable_disable, "[stream <id>] disable") \
21064 _(ip_source_and_port_range_check_add_del, \
21065 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21066 _(ip_source_and_port_range_check_interface_add_del, \
21067 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21068 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21069 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21070 _(l2_interface_pbb_tag_rewrite, \
21071 "<intfc> | sw_if_index <nn> \n" \
21072 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21073 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21074 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21075 _(flow_classify_set_interface, \
21076 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21077 _(flow_classify_dump, "type [ip4|ip6]") \
21078 _(ip_table_dump, "") \
21079 _(ip_route_dump, "table-id [ip4|ip6]") \
21080 _(ip_mtable_dump, "") \
21081 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21082 _(feature_enable_disable, "arc_name <arc_name> " \
21083 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21084 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21085 "[enable | disable] ") \
21086 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21088 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21089 "mac <mac-address> [del]") \
21090 _(l2_xconnect_dump, "") \
21091 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21092 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21093 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21094 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21095 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21096 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21097 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21098 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21099 _(sock_init_shm, "size <nnn>") \
21100 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21101 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21102 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21103 _(session_rules_dump, "") \
21104 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21105 _(output_acl_set_interface, \
21106 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21107 " [l2-table <nn>] [del]") \
21108 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21110 /* List of command functions, CLI names map directly to functions */
21111 #define foreach_cli_function \
21112 _(comment, "usage: comment <ignore-rest-of-line>") \
21113 _(dump_interface_table, "usage: dump_interface_table") \
21114 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21115 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21116 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21117 _(dump_macro_table, "usage: dump_macro_table ") \
21118 _(dump_node_table, "usage: dump_node_table") \
21119 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21120 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21121 _(elog_disable, "usage: elog_disable") \
21122 _(elog_enable, "usage: elog_enable") \
21123 _(elog_save, "usage: elog_save <filename>") \
21124 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21125 _(echo, "usage: echo <message>") \
21126 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21127 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21128 _(help, "usage: help") \
21129 _(q, "usage: quit") \
21130 _(quit, "usage: quit") \
21131 _(search_node_table, "usage: search_node_table <name>...") \
21132 _(set, "usage: set <variable-name> <value>") \
21133 _(script, "usage: script <file-name>") \
21134 _(statseg, "usage: statseg") \
21135 _(unset, "usage: unset <variable-name>")
21138 static void vl_api_##n##_t_handler_uni \
21139 (vl_api_##n##_t * mp) \
21141 vat_main_t * vam = &vat_main; \
21142 if (vam->json_output) { \
21143 vl_api_##n##_t_handler_json(mp); \
21145 vl_api_##n##_t_handler(mp); \
21148 foreach_vpe_api_reply_msg;
21149 #if VPP_API_TEST_BUILTIN == 0
21150 foreach_standalone_reply_msg;
21155 vat_api_hookup (vat_main_t * vam)
21158 vl_msg_api_set_handlers(VL_API_##N, #n, \
21159 vl_api_##n##_t_handler_uni, \
21161 vl_api_##n##_t_endian, \
21162 vl_api_##n##_t_print, \
21163 sizeof(vl_api_##n##_t), 1);
21164 foreach_vpe_api_reply_msg;
21165 #if VPP_API_TEST_BUILTIN == 0
21166 foreach_standalone_reply_msg;
21170 #if (VPP_API_TEST_BUILTIN==0)
21171 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21173 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21175 vam->function_by_name = hash_create_string (0, sizeof (uword));
21177 vam->help_by_name = hash_create_string (0, sizeof (uword));
21180 /* API messages we can send */
21181 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21182 foreach_vpe_api_msg;
21186 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21187 foreach_vpe_api_msg;
21190 /* CLI functions */
21191 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21192 foreach_cli_function;
21196 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21197 foreach_cli_function;
21201 #if VPP_API_TEST_BUILTIN
21202 static clib_error_t *
21203 vat_api_hookup_shim (vlib_main_t * vm)
21205 vat_api_hookup (&vat_main);
21209 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21213 * fd.io coding-style-patch-verification: ON
21216 * eval: (c-set-style "gnu")