2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/l2tp/l2tp.h>
31 #include <vnet/vxlan/vxlan.h>
32 #include <vnet/geneve/geneve.h>
33 #include <vnet/gre/gre.h>
34 #include <vnet/vxlan-gpe/vxlan_gpe.h>
35 #include <vnet/lisp-gpe/lisp_gpe.h>
37 #include <vpp/api/vpe_msg_enum.h>
38 #include <vnet/l2/l2_classify.h>
39 #include <vnet/l2/l2_vtr.h>
40 #include <vnet/classify/in_out_acl.h>
41 #include <vnet/classify/policer_classify.h>
42 #include <vnet/classify/flow_classify.h>
43 #include <vnet/mpls/mpls.h>
44 #include <vnet/ipsec/ipsec.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/span/span.h>
51 #include <vnet/policer/policer.h>
52 #include <vnet/policer/police.h>
53 #include <vnet/mfib/mfib_types.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
57 #include <vnet/ip/ip_types_api.h>
58 #include "vat/json_format.h"
59 #include <vnet/ip/ip_types_api.h>
60 #include <vnet/ethernet/ethernet_types_api.h>
65 #define vl_typedefs /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* declare message handlers for each api */
71 #define vl_endianfun /* define message structures */
72 #include <vpp/api/vpe_all_api_h.h>
75 /* instantiate all the print functions we know about */
76 #if VPP_API_TEST_BUILTIN == 0
77 #define vl_print(handle, ...)
79 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
82 #include <vpp/api/vpe_all_api_h.h>
85 #define __plugin_msg_base 0
86 #include <vlibapi/vat_helper_macros.h>
88 #include <vnet/format_fns.h>
90 void vl_api_set_elog_main (elog_main_t * m);
91 int vl_api_set_elog_trace_api_messages (int enable);
93 #if VPP_API_TEST_BUILTIN == 0
103 vat_socket_connect (vat_main_t * vam)
106 vam->socket_client_main = &socket_client_main;
107 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
109 0 /* default socket rx, tx buffer */ )))
111 /* vpp expects the client index in network order */
112 vam->my_client_index = htonl (socket_client_main.client_index);
115 #else /* vpp built-in case, we don't do sockets... */
117 vat_socket_connect (vat_main_t * vam)
123 vl_socket_client_read (int wait)
129 vl_socket_client_write ()
135 vl_socket_client_msg_alloc (int nbytes)
143 vat_time_now (vat_main_t * vam)
145 #if VPP_API_TEST_BUILTIN
146 return vlib_time_now (vam->vlib_main);
148 return clib_time_now (&vam->clib_time);
153 errmsg (char *fmt, ...)
155 vat_main_t *vam = &vat_main;
160 s = va_format (0, fmt, &va);
165 #if VPP_API_TEST_BUILTIN
166 vlib_cli_output (vam->vlib_main, (char *) s);
169 if (vam->ifp != stdin)
170 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
171 vam->input_line_number);
173 fformat (vam->ofp, "%s\n", (char *) s);
181 #if VPP_API_TEST_BUILTIN == 0
183 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
185 vat_main_t *vam = va_arg (*args, vat_main_t *);
186 u32 *result = va_arg (*args, u32 *);
190 if (!unformat (input, "%s", &if_name))
193 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
201 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
206 /* Parse an IP4 address %d.%d.%d.%d. */
208 unformat_ip4_address (unformat_input_t * input, va_list * args)
210 u8 *result = va_arg (*args, u8 *);
213 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
216 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
228 unformat_ethernet_address (unformat_input_t * input, va_list * args)
230 u8 *result = va_arg (*args, u8 *);
233 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
234 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
238 for (i = 0; i < 6; i++)
239 if (a[i] >= (1 << 8))
242 for (i = 0; i < 6; i++)
248 /* Returns ethernet type as an int in host byte order. */
250 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
253 u16 *result = va_arg (*args, u16 *);
257 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
259 if (type >= (1 << 16))
267 /* Parse an IP6 address. */
269 unformat_ip6_address (unformat_input_t * input, va_list * args)
271 ip6_address_t *result = va_arg (*args, ip6_address_t *);
273 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
274 uword c, n_colon, double_colon_index;
276 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
277 double_colon_index = ARRAY_LEN (hex_quads);
278 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
281 if (c >= '0' && c <= '9')
283 else if (c >= 'a' && c <= 'f')
284 hex_digit = c + 10 - 'a';
285 else if (c >= 'A' && c <= 'F')
286 hex_digit = c + 10 - 'A';
287 else if (c == ':' && n_colon < 2)
291 unformat_put_input (input);
295 /* Too many hex quads. */
296 if (n_hex_quads >= ARRAY_LEN (hex_quads))
301 hex_quad = (hex_quad << 4) | hex_digit;
303 /* Hex quad must fit in 16 bits. */
304 if (n_hex_digits >= 4)
311 /* Save position of :: */
314 /* More than one :: ? */
315 if (double_colon_index < ARRAY_LEN (hex_quads))
317 double_colon_index = n_hex_quads;
320 if (n_colon > 0 && n_hex_digits > 0)
322 hex_quads[n_hex_quads++] = hex_quad;
328 if (n_hex_digits > 0)
329 hex_quads[n_hex_quads++] = hex_quad;
334 /* Expand :: to appropriate number of zero hex quads. */
335 if (double_colon_index < ARRAY_LEN (hex_quads))
337 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
339 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
340 hex_quads[n_zero + i] = hex_quads[i];
342 for (i = 0; i < n_zero; i++)
343 hex_quads[double_colon_index + i] = 0;
345 n_hex_quads = ARRAY_LEN (hex_quads);
348 /* Too few hex quads given. */
349 if (n_hex_quads < ARRAY_LEN (hex_quads))
352 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
353 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
360 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
362 u32 *r = va_arg (*args, u32 *);
365 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
366 foreach_ipsec_policy_action
374 format_ipsec_crypto_alg (u8 * s, va_list * args)
376 u32 i = va_arg (*args, u32);
381 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
382 foreach_ipsec_crypto_alg
385 return format (s, "unknown");
387 return format (s, "%s", t);
391 format_ipsec_integ_alg (u8 * s, va_list * args)
393 u32 i = va_arg (*args, u32);
398 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
399 foreach_ipsec_integ_alg
402 return format (s, "unknown");
404 return format (s, "%s", t);
407 #else /* VPP_API_TEST_BUILTIN == 1 */
409 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
411 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
412 vnet_main_t *vnm = vnet_get_main ();
413 u32 *result = va_arg (*args, u32 *);
415 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
419 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
421 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
422 vnet_main_t *vnm = vnet_get_main ();
423 u32 *result = va_arg (*args, u32 *);
425 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
428 #endif /* VPP_API_TEST_BUILTIN */
431 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
433 u32 *r = va_arg (*args, u32 *);
436 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
437 foreach_ipsec_crypto_alg
445 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
447 u32 *r = va_arg (*args, u32 *);
450 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
451 foreach_ipsec_integ_alg
459 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
461 u8 *r = va_arg (*args, u8 *);
463 if (unformat (input, "kbps"))
464 *r = SSE2_QOS_RATE_KBPS;
465 else if (unformat (input, "pps"))
466 *r = SSE2_QOS_RATE_PPS;
473 unformat_policer_round_type (unformat_input_t * input, va_list * args)
475 u8 *r = va_arg (*args, u8 *);
477 if (unformat (input, "closest"))
478 *r = SSE2_QOS_ROUND_TO_CLOSEST;
479 else if (unformat (input, "up"))
480 *r = SSE2_QOS_ROUND_TO_UP;
481 else if (unformat (input, "down"))
482 *r = SSE2_QOS_ROUND_TO_DOWN;
489 unformat_policer_type (unformat_input_t * input, va_list * args)
491 u8 *r = va_arg (*args, u8 *);
493 if (unformat (input, "1r2c"))
494 *r = SSE2_QOS_POLICER_TYPE_1R2C;
495 else if (unformat (input, "1r3c"))
496 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
497 else if (unformat (input, "2r3c-2698"))
498 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
499 else if (unformat (input, "2r3c-4115"))
500 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
501 else if (unformat (input, "2r3c-mef5cf1"))
502 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
509 unformat_dscp (unformat_input_t * input, va_list * va)
511 u8 *r = va_arg (*va, u8 *);
514 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
523 unformat_policer_action_type (unformat_input_t * input, va_list * va)
525 sse2_qos_pol_action_params_st *a
526 = va_arg (*va, sse2_qos_pol_action_params_st *);
528 if (unformat (input, "drop"))
529 a->action_type = SSE2_QOS_ACTION_DROP;
530 else if (unformat (input, "transmit"))
531 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
532 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
533 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
540 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
542 u32 *r = va_arg (*va, u32 *);
545 if (unformat (input, "ip4"))
546 tid = POLICER_CLASSIFY_TABLE_IP4;
547 else if (unformat (input, "ip6"))
548 tid = POLICER_CLASSIFY_TABLE_IP6;
549 else if (unformat (input, "l2"))
550 tid = POLICER_CLASSIFY_TABLE_L2;
559 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
561 u32 *r = va_arg (*va, u32 *);
564 if (unformat (input, "ip4"))
565 tid = FLOW_CLASSIFY_TABLE_IP4;
566 else if (unformat (input, "ip6"))
567 tid = FLOW_CLASSIFY_TABLE_IP6;
575 #if (VPP_API_TEST_BUILTIN==0)
577 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
578 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
579 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
580 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
583 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
585 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
586 mfib_itf_attribute_t attr;
589 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
591 if (unformat (input, mfib_itf_flag_long_names[attr]))
592 *iflags |= (1 << attr);
594 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
596 if (unformat (input, mfib_itf_flag_names[attr]))
597 *iflags |= (1 << attr);
600 return (old == *iflags ? 0 : 1);
604 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
606 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
607 mfib_entry_attribute_t attr;
610 FOR_EACH_MFIB_ATTRIBUTE (attr)
612 if (unformat (input, mfib_flag_long_names[attr]))
613 *eflags |= (1 << attr);
615 FOR_EACH_MFIB_ATTRIBUTE (attr)
617 if (unformat (input, mfib_flag_names[attr]))
618 *eflags |= (1 << attr);
621 return (old == *eflags ? 0 : 1);
625 format_ip4_address (u8 * s, va_list * args)
627 u8 *a = va_arg (*args, u8 *);
628 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
632 format_ip6_address (u8 * s, va_list * args)
634 ip6_address_t *a = va_arg (*args, ip6_address_t *);
635 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
637 i_max_n_zero = ARRAY_LEN (a->as_u16);
639 i_first_zero = i_max_n_zero;
641 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
643 u32 is_zero = a->as_u16[i] == 0;
644 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
650 if ((!is_zero && n_zeros > max_n_zeros)
651 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
653 i_max_n_zero = i_first_zero;
654 max_n_zeros = n_zeros;
655 i_first_zero = ARRAY_LEN (a->as_u16);
660 last_double_colon = 0;
661 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
663 if (i == i_max_n_zero && max_n_zeros > 1)
665 s = format (s, "::");
666 i += max_n_zeros - 1;
667 last_double_colon = 1;
671 s = format (s, "%s%x",
672 (last_double_colon || i == 0) ? "" : ":",
673 clib_net_to_host_u16 (a->as_u16[i]));
674 last_double_colon = 0;
681 /* Format an IP46 address. */
683 format_ip46_address (u8 * s, va_list * args)
685 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
686 ip46_type_t type = va_arg (*args, ip46_type_t);
692 is_ip4 = ip46_address_is_ip4 (ip46);
703 format (s, "%U", format_ip4_address, &ip46->ip4) :
704 format (s, "%U", format_ip6_address, &ip46->ip6);
708 format_ethernet_address (u8 * s, va_list * args)
710 u8 *a = va_arg (*args, u8 *);
712 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
713 a[0], a[1], a[2], a[3], a[4], a[5]);
718 increment_v4_address (vl_api_ip4_address_t * i)
720 ip4_address_t *a = (ip4_address_t *) i;
723 v = ntohl (a->as_u32) + 1;
724 a->as_u32 = ntohl (v);
728 increment_v6_address (vl_api_ip6_address_t * i)
730 ip6_address_t *a = (ip6_address_t *) i;
733 v0 = clib_net_to_host_u64 (a->as_u64[0]);
734 v1 = clib_net_to_host_u64 (a->as_u64[1]);
739 a->as_u64[0] = clib_net_to_host_u64 (v0);
740 a->as_u64[1] = clib_net_to_host_u64 (v1);
744 increment_address (vl_api_address_t * a)
746 if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
747 increment_v4_address (&a->un.ip4);
748 else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
749 increment_v6_address (&a->un.ip6);
753 set_ip4_address (vl_api_address_t * a, u32 v)
755 if (a->af == ADDRESS_IP4)
757 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
763 increment_mac_address (u8 * mac)
765 u64 tmp = *((u64 *) mac);
766 tmp = clib_net_to_host_u64 (tmp);
767 tmp += 1 << 16; /* skip unused (least significant) octets */
768 tmp = clib_host_to_net_u64 (tmp);
770 clib_memcpy (mac, &tmp, 6);
774 vat_json_object_add_address (vat_json_node_t * node,
775 const char *str, const vl_api_address_t * addr)
777 if (ADDRESS_IP6 == addr->af)
781 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
782 vat_json_object_add_ip6 (node, str, ip6);
788 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
789 vat_json_object_add_ip4 (node, str, ip4);
794 vat_json_object_add_prefix (vat_json_node_t * node,
795 const vl_api_prefix_t * prefix)
797 vat_json_object_add_uint (node, "len", prefix->len);
798 vat_json_object_add_address (node, "address", &prefix->address);
801 static void vl_api_create_loopback_reply_t_handler
802 (vl_api_create_loopback_reply_t * mp)
804 vat_main_t *vam = &vat_main;
805 i32 retval = ntohl (mp->retval);
807 vam->retval = retval;
808 vam->regenerate_interface_table = 1;
809 vam->sw_if_index = ntohl (mp->sw_if_index);
810 vam->result_ready = 1;
813 static void vl_api_create_loopback_reply_t_handler_json
814 (vl_api_create_loopback_reply_t * mp)
816 vat_main_t *vam = &vat_main;
817 vat_json_node_t node;
819 vat_json_init_object (&node);
820 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
821 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
823 vat_json_print (vam->ofp, &node);
824 vat_json_free (&node);
825 vam->retval = ntohl (mp->retval);
826 vam->result_ready = 1;
829 static void vl_api_create_loopback_instance_reply_t_handler
830 (vl_api_create_loopback_instance_reply_t * mp)
832 vat_main_t *vam = &vat_main;
833 i32 retval = ntohl (mp->retval);
835 vam->retval = retval;
836 vam->regenerate_interface_table = 1;
837 vam->sw_if_index = ntohl (mp->sw_if_index);
838 vam->result_ready = 1;
841 static void vl_api_create_loopback_instance_reply_t_handler_json
842 (vl_api_create_loopback_instance_reply_t * mp)
844 vat_main_t *vam = &vat_main;
845 vat_json_node_t node;
847 vat_json_init_object (&node);
848 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
849 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
851 vat_json_print (vam->ofp, &node);
852 vat_json_free (&node);
853 vam->retval = ntohl (mp->retval);
854 vam->result_ready = 1;
857 static void vl_api_af_packet_create_reply_t_handler
858 (vl_api_af_packet_create_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 i32 retval = ntohl (mp->retval);
863 vam->retval = retval;
864 vam->regenerate_interface_table = 1;
865 vam->sw_if_index = ntohl (mp->sw_if_index);
866 vam->result_ready = 1;
869 static void vl_api_af_packet_create_reply_t_handler_json
870 (vl_api_af_packet_create_reply_t * mp)
872 vat_main_t *vam = &vat_main;
873 vat_json_node_t node;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
879 vat_json_print (vam->ofp, &node);
880 vat_json_free (&node);
882 vam->retval = ntohl (mp->retval);
883 vam->result_ready = 1;
886 static void vl_api_create_vlan_subif_reply_t_handler
887 (vl_api_create_vlan_subif_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 i32 retval = ntohl (mp->retval);
892 vam->retval = retval;
893 vam->regenerate_interface_table = 1;
894 vam->sw_if_index = ntohl (mp->sw_if_index);
895 vam->result_ready = 1;
898 static void vl_api_create_vlan_subif_reply_t_handler_json
899 (vl_api_create_vlan_subif_reply_t * mp)
901 vat_main_t *vam = &vat_main;
902 vat_json_node_t node;
904 vat_json_init_object (&node);
905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
906 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
908 vat_json_print (vam->ofp, &node);
909 vat_json_free (&node);
911 vam->retval = ntohl (mp->retval);
912 vam->result_ready = 1;
915 static void vl_api_create_subif_reply_t_handler
916 (vl_api_create_subif_reply_t * mp)
918 vat_main_t *vam = &vat_main;
919 i32 retval = ntohl (mp->retval);
921 vam->retval = retval;
922 vam->regenerate_interface_table = 1;
923 vam->sw_if_index = ntohl (mp->sw_if_index);
924 vam->result_ready = 1;
927 static void vl_api_create_subif_reply_t_handler_json
928 (vl_api_create_subif_reply_t * mp)
930 vat_main_t *vam = &vat_main;
931 vat_json_node_t node;
933 vat_json_init_object (&node);
934 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
935 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
937 vat_json_print (vam->ofp, &node);
938 vat_json_free (&node);
940 vam->retval = ntohl (mp->retval);
941 vam->result_ready = 1;
944 static void vl_api_interface_name_renumber_reply_t_handler
945 (vl_api_interface_name_renumber_reply_t * mp)
947 vat_main_t *vam = &vat_main;
948 i32 retval = ntohl (mp->retval);
950 vam->retval = retval;
951 vam->regenerate_interface_table = 1;
952 vam->result_ready = 1;
955 static void vl_api_interface_name_renumber_reply_t_handler_json
956 (vl_api_interface_name_renumber_reply_t * mp)
958 vat_main_t *vam = &vat_main;
959 vat_json_node_t node;
961 vat_json_init_object (&node);
962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
964 vat_json_print (vam->ofp, &node);
965 vat_json_free (&node);
967 vam->retval = ntohl (mp->retval);
968 vam->result_ready = 1;
972 * Special-case: build the interface table, maintain
973 * the next loopback sw_if_index vbl.
975 static void vl_api_sw_interface_details_t_handler
976 (vl_api_sw_interface_details_t * mp)
978 vat_main_t *vam = &vat_main;
979 u8 *s = format (0, "%s%c", mp->interface_name, 0);
981 hash_set_mem (vam->sw_if_index_by_interface_name, s,
982 ntohl (mp->sw_if_index));
984 /* In sub interface case, fill the sub interface table entry */
985 if (mp->sw_if_index != mp->sup_sw_if_index)
987 sw_interface_subif_t *sub = NULL;
989 vec_add2 (vam->sw_if_subif_table, sub, 1);
991 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
992 strncpy ((char *) sub->interface_name, (char *) s,
993 vec_len (sub->interface_name));
994 sub->sw_if_index = ntohl (mp->sw_if_index);
995 sub->sub_id = ntohl (mp->sub_id);
997 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
999 sub->sub_number_of_tags = mp->sub_number_of_tags;
1000 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1001 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1003 /* vlan tag rewrite */
1004 sub->vtr_op = ntohl (mp->vtr_op);
1005 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1006 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1007 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1011 static void vl_api_sw_interface_details_t_handler_json
1012 (vl_api_sw_interface_details_t * mp)
1014 vat_main_t *vam = &vat_main;
1015 vat_json_node_t *node = NULL;
1017 if (VAT_JSON_ARRAY != vam->json_tree.type)
1019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1020 vat_json_init_array (&vam->json_tree);
1022 node = vat_json_array_add (&vam->json_tree);
1024 vat_json_init_object (node);
1025 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1026 vat_json_object_add_uint (node, "sup_sw_if_index",
1027 ntohl (mp->sup_sw_if_index));
1028 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1029 sizeof (mp->l2_address));
1030 vat_json_object_add_string_copy (node, "interface_name",
1031 mp->interface_name);
1032 vat_json_object_add_string_copy (node, "interface_dev_type",
1033 mp->interface_dev_type);
1034 vat_json_object_add_uint (node, "flags", mp->flags);
1035 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1036 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1037 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1038 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1039 vat_json_object_add_uint (node, "sub_number_of_tags",
1040 mp->sub_number_of_tags);
1041 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1042 ntohs (mp->sub_outer_vlan_id));
1043 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1044 ntohs (mp->sub_inner_vlan_id));
1045 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1046 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1047 vat_json_object_add_uint (node, "vtr_push_dot1q",
1048 ntohl (mp->vtr_push_dot1q));
1049 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1050 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1051 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1053 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1055 format_ethernet_address,
1057 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1059 format_ethernet_address,
1061 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1062 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1066 #if VPP_API_TEST_BUILTIN == 0
1067 static void vl_api_sw_interface_event_t_handler
1068 (vl_api_sw_interface_event_t * mp)
1070 vat_main_t *vam = &vat_main;
1071 if (vam->interface_event_display)
1072 errmsg ("interface flags: sw_if_index %d %s %s",
1073 ntohl (mp->sw_if_index),
1074 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1075 "admin-up" : "admin-down",
1076 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1077 "link-up" : "link-down");
1081 __clib_unused static void
1082 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1084 /* JSON output not supported */
1088 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1090 vat_main_t *vam = &vat_main;
1091 i32 retval = ntohl (mp->retval);
1093 vam->retval = retval;
1094 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1095 vam->result_ready = 1;
1099 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1101 vat_main_t *vam = &vat_main;
1102 vat_json_node_t node;
1106 vat_json_init_object (&node);
1107 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1108 vat_json_object_add_uint (&node, "reply_in_shmem",
1109 ntohl (mp->reply_in_shmem));
1110 /* Toss the shared-memory original... */
1111 oldheap = vl_msg_push_heap ();
1113 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1116 vl_msg_pop_heap (oldheap);
1118 vat_json_print (vam->ofp, &node);
1119 vat_json_free (&node);
1121 vam->retval = ntohl (mp->retval);
1122 vam->result_ready = 1;
1126 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1128 vat_main_t *vam = &vat_main;
1129 i32 retval = ntohl (mp->retval);
1130 u32 length = vl_api_string_len (&mp->reply);
1132 vec_reset_length (vam->cmd_reply);
1134 vam->retval = retval;
1137 vec_validate (vam->cmd_reply, length);
1138 clib_memcpy ((char *) (vam->cmd_reply),
1139 vl_api_from_api_string (&mp->reply), length);
1140 vam->cmd_reply[length] = 0;
1142 vam->result_ready = 1;
1146 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1148 vat_main_t *vam = &vat_main;
1149 vat_json_node_t node;
1151 vec_reset_length (vam->cmd_reply);
1153 vat_json_init_object (&node);
1154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1155 vat_json_object_add_string_copy (&node, "reply",
1156 vl_api_from_api_string (&mp->reply));
1158 vat_json_print (vam->ofp, &node);
1159 vat_json_free (&node);
1161 vam->retval = ntohl (mp->retval);
1162 vam->result_ready = 1;
1165 static void vl_api_classify_add_del_table_reply_t_handler
1166 (vl_api_classify_add_del_table_reply_t * mp)
1168 vat_main_t *vam = &vat_main;
1169 i32 retval = ntohl (mp->retval);
1170 if (vam->async_mode)
1172 vam->async_errors += (retval < 0);
1176 vam->retval = retval;
1178 ((mp->new_table_index != 0xFFFFFFFF) ||
1179 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1180 (mp->match_n_vectors != 0xFFFFFFFF)))
1182 * Note: this is just barely thread-safe, depends on
1183 * the main thread spinning waiting for an answer...
1185 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1186 ntohl (mp->new_table_index),
1187 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1188 vam->result_ready = 1;
1192 static void vl_api_classify_add_del_table_reply_t_handler_json
1193 (vl_api_classify_add_del_table_reply_t * mp)
1195 vat_main_t *vam = &vat_main;
1196 vat_json_node_t node;
1198 vat_json_init_object (&node);
1199 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1200 vat_json_object_add_uint (&node, "new_table_index",
1201 ntohl (mp->new_table_index));
1202 vat_json_object_add_uint (&node, "skip_n_vectors",
1203 ntohl (mp->skip_n_vectors));
1204 vat_json_object_add_uint (&node, "match_n_vectors",
1205 ntohl (mp->match_n_vectors));
1207 vat_json_print (vam->ofp, &node);
1208 vat_json_free (&node);
1210 vam->retval = ntohl (mp->retval);
1211 vam->result_ready = 1;
1214 static void vl_api_get_node_index_reply_t_handler
1215 (vl_api_get_node_index_reply_t * mp)
1217 vat_main_t *vam = &vat_main;
1218 i32 retval = ntohl (mp->retval);
1219 if (vam->async_mode)
1221 vam->async_errors += (retval < 0);
1225 vam->retval = retval;
1227 errmsg ("node index %d", ntohl (mp->node_index));
1228 vam->result_ready = 1;
1232 static void vl_api_get_node_index_reply_t_handler_json
1233 (vl_api_get_node_index_reply_t * mp)
1235 vat_main_t *vam = &vat_main;
1236 vat_json_node_t node;
1238 vat_json_init_object (&node);
1239 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1240 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1242 vat_json_print (vam->ofp, &node);
1243 vat_json_free (&node);
1245 vam->retval = ntohl (mp->retval);
1246 vam->result_ready = 1;
1249 static void vl_api_get_next_index_reply_t_handler
1250 (vl_api_get_next_index_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1254 if (vam->async_mode)
1256 vam->async_errors += (retval < 0);
1260 vam->retval = retval;
1262 errmsg ("next node index %d", ntohl (mp->next_index));
1263 vam->result_ready = 1;
1267 static void vl_api_get_next_index_reply_t_handler_json
1268 (vl_api_get_next_index_reply_t * mp)
1270 vat_main_t *vam = &vat_main;
1271 vat_json_node_t node;
1273 vat_json_init_object (&node);
1274 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1275 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1277 vat_json_print (vam->ofp, &node);
1278 vat_json_free (&node);
1280 vam->retval = ntohl (mp->retval);
1281 vam->result_ready = 1;
1284 static void vl_api_add_node_next_reply_t_handler
1285 (vl_api_add_node_next_reply_t * mp)
1287 vat_main_t *vam = &vat_main;
1288 i32 retval = ntohl (mp->retval);
1289 if (vam->async_mode)
1291 vam->async_errors += (retval < 0);
1295 vam->retval = retval;
1297 errmsg ("next index %d", ntohl (mp->next_index));
1298 vam->result_ready = 1;
1302 static void vl_api_add_node_next_reply_t_handler_json
1303 (vl_api_add_node_next_reply_t * mp)
1305 vat_main_t *vam = &vat_main;
1306 vat_json_node_t node;
1308 vat_json_init_object (&node);
1309 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1310 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1312 vat_json_print (vam->ofp, &node);
1313 vat_json_free (&node);
1315 vam->retval = ntohl (mp->retval);
1316 vam->result_ready = 1;
1319 static void vl_api_show_version_reply_t_handler
1320 (vl_api_show_version_reply_t * mp)
1322 vat_main_t *vam = &vat_main;
1323 i32 retval = ntohl (mp->retval);
1327 errmsg (" program: %s", mp->program);
1328 errmsg (" version: %s", mp->version);
1329 errmsg (" build date: %s", mp->build_date);
1330 errmsg ("build directory: %s", mp->build_directory);
1332 vam->retval = retval;
1333 vam->result_ready = 1;
1336 static void vl_api_show_version_reply_t_handler_json
1337 (vl_api_show_version_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 vat_json_node_t node;
1342 vat_json_init_object (&node);
1343 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1344 vat_json_object_add_string_copy (&node, "program", mp->program);
1345 vat_json_object_add_string_copy (&node, "version", mp->version);
1346 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1347 vat_json_object_add_string_copy (&node, "build_directory",
1348 mp->build_directory);
1350 vat_json_print (vam->ofp, &node);
1351 vat_json_free (&node);
1353 vam->retval = ntohl (mp->retval);
1354 vam->result_ready = 1;
1357 static void vl_api_show_threads_reply_t_handler
1358 (vl_api_show_threads_reply_t * mp)
1360 vat_main_t *vam = &vat_main;
1361 i32 retval = ntohl (mp->retval);
1365 count = ntohl (mp->count);
1367 for (i = 0; i < count; i++)
1369 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1370 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1371 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1372 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1373 ntohl (mp->thread_data[i].cpu_socket));
1375 vam->retval = retval;
1376 vam->result_ready = 1;
1379 static void vl_api_show_threads_reply_t_handler_json
1380 (vl_api_show_threads_reply_t * mp)
1382 vat_main_t *vam = &vat_main;
1383 vat_json_node_t node;
1384 vl_api_thread_data_t *td;
1385 i32 retval = ntohl (mp->retval);
1389 count = ntohl (mp->count);
1391 vat_json_init_object (&node);
1392 vat_json_object_add_int (&node, "retval", retval);
1393 vat_json_object_add_uint (&node, "count", count);
1395 for (i = 0; i < count; i++)
1397 td = &mp->thread_data[i];
1398 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1399 vat_json_object_add_string_copy (&node, "name", td->name);
1400 vat_json_object_add_string_copy (&node, "type", td->type);
1401 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1402 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1403 vat_json_object_add_int (&node, "core", ntohl (td->id));
1404 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1407 vat_json_print (vam->ofp, &node);
1408 vat_json_free (&node);
1410 vam->retval = retval;
1411 vam->result_ready = 1;
1415 api_show_threads (vat_main_t * vam)
1417 vl_api_show_threads_t *mp;
1421 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1422 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1424 M (SHOW_THREADS, mp);
1432 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1434 u32 n_macs = ntohl (mp->n_macs);
1435 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1436 ntohl (mp->pid), mp->client_index, n_macs);
1438 for (i = 0; i < n_macs; i++)
1440 vl_api_mac_entry_t *mac = &mp->mac[i];
1441 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1442 i + 1, ntohl (mac->sw_if_index),
1443 format_ethernet_address, mac->mac_addr, mac->action);
1450 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1452 /* JSON output not supported */
1455 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1456 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1459 * Special-case: build the bridge domain table, maintain
1460 * the next bd id vbl.
1462 static void vl_api_bridge_domain_details_t_handler
1463 (vl_api_bridge_domain_details_t * mp)
1465 vat_main_t *vam = &vat_main;
1466 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1469 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1470 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1472 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1473 ntohl (mp->bd_id), mp->learn, mp->forward,
1474 mp->flood, ntohl (mp->bvi_sw_if_index),
1475 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1479 vl_api_bridge_domain_sw_if_t *sw_ifs;
1480 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1483 sw_ifs = mp->sw_if_details;
1484 for (i = 0; i < n_sw_ifs; i++)
1490 sw_if_index = ntohl (sw_ifs->sw_if_index);
1493 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1495 if ((u32) p->value[0] == sw_if_index)
1497 sw_if_name = (u8 *)(p->key);
1502 print (vam->ofp, "%7d %3d %s", sw_if_index,
1503 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1504 "sw_if_index not found!");
1511 static void vl_api_bridge_domain_details_t_handler_json
1512 (vl_api_bridge_domain_details_t * mp)
1514 vat_main_t *vam = &vat_main;
1515 vat_json_node_t *node, *array = NULL;
1516 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1518 if (VAT_JSON_ARRAY != vam->json_tree.type)
1520 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1521 vat_json_init_array (&vam->json_tree);
1523 node = vat_json_array_add (&vam->json_tree);
1525 vat_json_init_object (node);
1526 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1527 vat_json_object_add_uint (node, "flood", mp->flood);
1528 vat_json_object_add_uint (node, "forward", mp->forward);
1529 vat_json_object_add_uint (node, "learn", mp->learn);
1530 vat_json_object_add_uint (node, "bvi_sw_if_index",
1531 ntohl (mp->bvi_sw_if_index));
1532 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1533 array = vat_json_object_add (node, "sw_if");
1534 vat_json_init_array (array);
1540 vl_api_bridge_domain_sw_if_t *sw_ifs;
1543 sw_ifs = mp->sw_if_details;
1544 for (i = 0; i < n_sw_ifs; i++)
1546 node = vat_json_array_add (array);
1547 vat_json_init_object (node);
1548 vat_json_object_add_uint (node, "sw_if_index",
1549 ntohl (sw_ifs->sw_if_index));
1550 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1556 static void vl_api_control_ping_reply_t_handler
1557 (vl_api_control_ping_reply_t * mp)
1559 vat_main_t *vam = &vat_main;
1560 i32 retval = ntohl (mp->retval);
1561 if (vam->async_mode)
1563 vam->async_errors += (retval < 0);
1567 vam->retval = retval;
1568 vam->result_ready = 1;
1570 if (vam->socket_client_main)
1571 vam->socket_client_main->control_pings_outstanding--;
1574 static void vl_api_control_ping_reply_t_handler_json
1575 (vl_api_control_ping_reply_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 i32 retval = ntohl (mp->retval);
1580 if (VAT_JSON_NONE != vam->json_tree.type)
1582 vat_json_print (vam->ofp, &vam->json_tree);
1583 vat_json_free (&vam->json_tree);
1584 vam->json_tree.type = VAT_JSON_NONE;
1589 vat_json_init_array (&vam->json_tree);
1590 vat_json_print (vam->ofp, &vam->json_tree);
1591 vam->json_tree.type = VAT_JSON_NONE;
1594 vam->retval = retval;
1595 vam->result_ready = 1;
1599 vl_api_bridge_domain_set_mac_age_reply_t_handler
1600 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1602 vat_main_t *vam = &vat_main;
1603 i32 retval = ntohl (mp->retval);
1604 if (vam->async_mode)
1606 vam->async_errors += (retval < 0);
1610 vam->retval = retval;
1611 vam->result_ready = 1;
1615 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1616 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1618 vat_main_t *vam = &vat_main;
1619 vat_json_node_t node;
1621 vat_json_init_object (&node);
1622 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1624 vat_json_print (vam->ofp, &node);
1625 vat_json_free (&node);
1627 vam->retval = ntohl (mp->retval);
1628 vam->result_ready = 1;
1632 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1634 vat_main_t *vam = &vat_main;
1635 i32 retval = ntohl (mp->retval);
1636 if (vam->async_mode)
1638 vam->async_errors += (retval < 0);
1642 vam->retval = retval;
1643 vam->result_ready = 1;
1647 static void vl_api_l2_flags_reply_t_handler_json
1648 (vl_api_l2_flags_reply_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 vat_json_node_t node;
1653 vat_json_init_object (&node);
1654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1656 ntohl (mp->resulting_feature_bitmap));
1658 vat_json_print (vam->ofp, &node);
1659 vat_json_free (&node);
1661 vam->retval = ntohl (mp->retval);
1662 vam->result_ready = 1;
1665 static void vl_api_bridge_flags_reply_t_handler
1666 (vl_api_bridge_flags_reply_t * mp)
1668 vat_main_t *vam = &vat_main;
1669 i32 retval = ntohl (mp->retval);
1670 if (vam->async_mode)
1672 vam->async_errors += (retval < 0);
1676 vam->retval = retval;
1677 vam->result_ready = 1;
1681 static void vl_api_bridge_flags_reply_t_handler_json
1682 (vl_api_bridge_flags_reply_t * mp)
1684 vat_main_t *vam = &vat_main;
1685 vat_json_node_t node;
1687 vat_json_init_object (&node);
1688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1689 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1690 ntohl (mp->resulting_feature_bitmap));
1692 vat_json_print (vam->ofp, &node);
1693 vat_json_free (&node);
1695 vam->retval = ntohl (mp->retval);
1696 vam->result_ready = 1;
1700 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1702 vat_main_t *vam = &vat_main;
1703 i32 retval = ntohl (mp->retval);
1704 if (vam->async_mode)
1706 vam->async_errors += (retval < 0);
1710 vam->retval = retval;
1711 vam->sw_if_index = ntohl (mp->sw_if_index);
1712 vam->result_ready = 1;
1717 static void vl_api_tap_create_v2_reply_t_handler_json
1718 (vl_api_tap_create_v2_reply_t * mp)
1720 vat_main_t *vam = &vat_main;
1721 vat_json_node_t node;
1723 vat_json_init_object (&node);
1724 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1725 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1727 vat_json_print (vam->ofp, &node);
1728 vat_json_free (&node);
1730 vam->retval = ntohl (mp->retval);
1731 vam->result_ready = 1;
1736 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1738 vat_main_t *vam = &vat_main;
1739 i32 retval = ntohl (mp->retval);
1740 if (vam->async_mode)
1742 vam->async_errors += (retval < 0);
1746 vam->retval = retval;
1747 vam->result_ready = 1;
1751 static void vl_api_tap_delete_v2_reply_t_handler_json
1752 (vl_api_tap_delete_v2_reply_t * mp)
1754 vat_main_t *vam = &vat_main;
1755 vat_json_node_t node;
1757 vat_json_init_object (&node);
1758 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1760 vat_json_print (vam->ofp, &node);
1761 vat_json_free (&node);
1763 vam->retval = ntohl (mp->retval);
1764 vam->result_ready = 1;
1768 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1771 vat_main_t *vam = &vat_main;
1772 i32 retval = ntohl (mp->retval);
1773 if (vam->async_mode)
1775 vam->async_errors += (retval < 0);
1779 vam->retval = retval;
1780 vam->sw_if_index = ntohl (mp->sw_if_index);
1781 vam->result_ready = 1;
1785 static void vl_api_virtio_pci_create_reply_t_handler_json
1786 (vl_api_virtio_pci_create_reply_t * mp)
1788 vat_main_t *vam = &vat_main;
1789 vat_json_node_t node;
1791 vat_json_init_object (&node);
1792 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1793 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1795 vat_json_print (vam->ofp, &node);
1796 vat_json_free (&node);
1798 vam->retval = ntohl (mp->retval);
1799 vam->result_ready = 1;
1804 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1807 vat_main_t *vam = &vat_main;
1808 i32 retval = ntohl (mp->retval);
1809 if (vam->async_mode)
1811 vam->async_errors += (retval < 0);
1815 vam->retval = retval;
1816 vam->result_ready = 1;
1820 static void vl_api_virtio_pci_delete_reply_t_handler_json
1821 (vl_api_virtio_pci_delete_reply_t * mp)
1823 vat_main_t *vam = &vat_main;
1824 vat_json_node_t node;
1826 vat_json_init_object (&node);
1827 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1829 vat_json_print (vam->ofp, &node);
1830 vat_json_free (&node);
1832 vam->retval = ntohl (mp->retval);
1833 vam->result_ready = 1;
1837 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1839 vat_main_t *vam = &vat_main;
1840 i32 retval = ntohl (mp->retval);
1842 if (vam->async_mode)
1844 vam->async_errors += (retval < 0);
1848 vam->retval = retval;
1849 vam->sw_if_index = ntohl (mp->sw_if_index);
1850 vam->result_ready = 1;
1854 static void vl_api_bond_create_reply_t_handler_json
1855 (vl_api_bond_create_reply_t * mp)
1857 vat_main_t *vam = &vat_main;
1858 vat_json_node_t node;
1860 vat_json_init_object (&node);
1861 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1862 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1864 vat_json_print (vam->ofp, &node);
1865 vat_json_free (&node);
1867 vam->retval = ntohl (mp->retval);
1868 vam->result_ready = 1;
1872 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1874 vat_main_t *vam = &vat_main;
1875 i32 retval = ntohl (mp->retval);
1877 if (vam->async_mode)
1879 vam->async_errors += (retval < 0);
1883 vam->retval = retval;
1884 vam->result_ready = 1;
1888 static void vl_api_bond_delete_reply_t_handler_json
1889 (vl_api_bond_delete_reply_t * mp)
1891 vat_main_t *vam = &vat_main;
1892 vat_json_node_t node;
1894 vat_json_init_object (&node);
1895 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1897 vat_json_print (vam->ofp, &node);
1898 vat_json_free (&node);
1900 vam->retval = ntohl (mp->retval);
1901 vam->result_ready = 1;
1905 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1907 vat_main_t *vam = &vat_main;
1908 i32 retval = ntohl (mp->retval);
1910 if (vam->async_mode)
1912 vam->async_errors += (retval < 0);
1916 vam->retval = retval;
1917 vam->result_ready = 1;
1921 static void vl_api_bond_enslave_reply_t_handler_json
1922 (vl_api_bond_enslave_reply_t * mp)
1924 vat_main_t *vam = &vat_main;
1925 vat_json_node_t node;
1927 vat_json_init_object (&node);
1928 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1930 vat_json_print (vam->ofp, &node);
1931 vat_json_free (&node);
1933 vam->retval = ntohl (mp->retval);
1934 vam->result_ready = 1;
1938 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1941 vat_main_t *vam = &vat_main;
1942 i32 retval = ntohl (mp->retval);
1944 if (vam->async_mode)
1946 vam->async_errors += (retval < 0);
1950 vam->retval = retval;
1951 vam->result_ready = 1;
1955 static void vl_api_bond_detach_slave_reply_t_handler_json
1956 (vl_api_bond_detach_slave_reply_t * mp)
1958 vat_main_t *vam = &vat_main;
1959 vat_json_node_t node;
1961 vat_json_init_object (&node);
1962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1964 vat_json_print (vam->ofp, &node);
1965 vat_json_free (&node);
1967 vam->retval = ntohl (mp->retval);
1968 vam->result_ready = 1;
1972 api_sw_interface_set_bond_weight (vat_main_t * vam)
1974 unformat_input_t *i = vam->input;
1975 vl_api_sw_interface_set_bond_weight_t *mp;
1976 u32 sw_if_index = ~0;
1978 u8 weight_enter = 0;
1981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
1983 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
1985 else if (unformat (i, "sw_if_index %d", &sw_if_index))
1987 else if (unformat (i, "weight %u", &weight))
1993 if (sw_if_index == ~0)
1995 errmsg ("missing interface name or sw_if_index");
1998 if (weight_enter == 0)
2000 errmsg ("missing valid weight");
2004 /* Construct the API message */
2005 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2006 mp->sw_if_index = ntohl (sw_if_index);
2007 mp->weight = ntohl (weight);
2014 static void vl_api_sw_interface_bond_details_t_handler
2015 (vl_api_sw_interface_bond_details_t * mp)
2017 vat_main_t *vam = &vat_main;
2020 "%-16s %-12d %-12U %-13U %-14u %-14u",
2021 mp->interface_name, ntohl (mp->sw_if_index),
2022 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2023 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2026 static void vl_api_sw_interface_bond_details_t_handler_json
2027 (vl_api_sw_interface_bond_details_t * mp)
2029 vat_main_t *vam = &vat_main;
2030 vat_json_node_t *node = NULL;
2032 if (VAT_JSON_ARRAY != vam->json_tree.type)
2034 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2035 vat_json_init_array (&vam->json_tree);
2037 node = vat_json_array_add (&vam->json_tree);
2039 vat_json_init_object (node);
2040 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2041 vat_json_object_add_string_copy (node, "interface_name",
2042 mp->interface_name);
2043 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2044 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2045 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2046 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2050 api_sw_interface_bond_dump (vat_main_t * vam)
2052 vl_api_sw_interface_bond_dump_t *mp;
2053 vl_api_control_ping_t *mp_ping;
2057 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2058 "interface name", "sw_if_index", "mode", "load balance",
2059 "active slaves", "slaves");
2061 /* Get list of bond interfaces */
2062 M (SW_INTERFACE_BOND_DUMP, mp);
2065 /* Use a control ping for synchronization */
2066 MPING (CONTROL_PING, mp_ping);
2073 static void vl_api_sw_interface_slave_details_t_handler
2074 (vl_api_sw_interface_slave_details_t * mp)
2076 vat_main_t *vam = &vat_main;
2079 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2080 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2081 ntohl (mp->weight), mp->is_local_numa);
2084 static void vl_api_sw_interface_slave_details_t_handler_json
2085 (vl_api_sw_interface_slave_details_t * mp)
2087 vat_main_t *vam = &vat_main;
2088 vat_json_node_t *node = NULL;
2090 if (VAT_JSON_ARRAY != vam->json_tree.type)
2092 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2093 vat_json_init_array (&vam->json_tree);
2095 node = vat_json_array_add (&vam->json_tree);
2097 vat_json_init_object (node);
2098 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2099 vat_json_object_add_string_copy (node, "interface_name",
2100 mp->interface_name);
2101 vat_json_object_add_uint (node, "passive", mp->is_passive);
2102 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2103 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2104 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2108 api_sw_interface_slave_dump (vat_main_t * vam)
2110 unformat_input_t *i = vam->input;
2111 vl_api_sw_interface_slave_dump_t *mp;
2112 vl_api_control_ping_t *mp_ping;
2113 u32 sw_if_index = ~0;
2114 u8 sw_if_index_set = 0;
2117 /* Parse args required to build the message */
2118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2120 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2121 sw_if_index_set = 1;
2122 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2123 sw_if_index_set = 1;
2128 if (sw_if_index_set == 0)
2130 errmsg ("missing vpp interface name. ");
2135 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2136 "slave interface name", "sw_if_index", "passive", "long_timeout",
2137 "weight", "local numa");
2139 /* Get list of bond interfaces */
2140 M (SW_INTERFACE_SLAVE_DUMP, mp);
2141 mp->sw_if_index = ntohl (sw_if_index);
2144 /* Use a control ping for synchronization */
2145 MPING (CONTROL_PING, mp_ping);
2152 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2153 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2155 vat_main_t *vam = &vat_main;
2156 i32 retval = ntohl (mp->retval);
2157 if (vam->async_mode)
2159 vam->async_errors += (retval < 0);
2163 vam->retval = retval;
2164 vam->sw_if_index = ntohl (mp->sw_if_index);
2165 vam->result_ready = 1;
2167 vam->regenerate_interface_table = 1;
2170 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2171 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2173 vat_main_t *vam = &vat_main;
2174 vat_json_node_t node;
2176 vat_json_init_object (&node);
2177 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2178 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2179 ntohl (mp->sw_if_index));
2181 vat_json_print (vam->ofp, &node);
2182 vat_json_free (&node);
2184 vam->retval = ntohl (mp->retval);
2185 vam->result_ready = 1;
2188 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2189 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2191 vat_main_t *vam = &vat_main;
2192 i32 retval = ntohl (mp->retval);
2193 if (vam->async_mode)
2195 vam->async_errors += (retval < 0);
2199 vam->retval = retval;
2200 vam->sw_if_index = ntohl (mp->sw_if_index);
2201 vam->result_ready = 1;
2205 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2206 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2208 vat_main_t *vam = &vat_main;
2209 vat_json_node_t node;
2211 vat_json_init_object (&node);
2212 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2213 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2215 vat_json_print (vam->ofp, &node);
2216 vat_json_free (&node);
2218 vam->retval = ntohl (mp->retval);
2219 vam->result_ready = 1;
2222 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2223 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2225 vat_main_t *vam = &vat_main;
2226 i32 retval = ntohl (mp->retval);
2227 if (vam->async_mode)
2229 vam->async_errors += (retval < 0);
2233 vam->retval = retval;
2234 vam->result_ready = 1;
2238 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2239 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2241 vat_main_t *vam = &vat_main;
2242 vat_json_node_t node;
2244 vat_json_init_object (&node);
2245 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2246 vat_json_object_add_uint (&node, "fwd_entry_index",
2247 clib_net_to_host_u32 (mp->fwd_entry_index));
2249 vat_json_print (vam->ofp, &node);
2250 vat_json_free (&node);
2252 vam->retval = ntohl (mp->retval);
2253 vam->result_ready = 1;
2257 format_lisp_transport_protocol (u8 * s, va_list * args)
2259 u32 proto = va_arg (*args, u32);
2264 return format (s, "udp");
2266 return format (s, "api");
2273 static void vl_api_one_get_transport_protocol_reply_t_handler
2274 (vl_api_one_get_transport_protocol_reply_t * mp)
2276 vat_main_t *vam = &vat_main;
2277 i32 retval = ntohl (mp->retval);
2278 if (vam->async_mode)
2280 vam->async_errors += (retval < 0);
2284 u32 proto = mp->protocol;
2285 print (vam->ofp, "Transport protocol: %U",
2286 format_lisp_transport_protocol, proto);
2287 vam->retval = retval;
2288 vam->result_ready = 1;
2292 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2293 (vl_api_one_get_transport_protocol_reply_t * mp)
2295 vat_main_t *vam = &vat_main;
2296 vat_json_node_t node;
2299 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2302 vat_json_init_object (&node);
2303 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2304 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2307 vat_json_print (vam->ofp, &node);
2308 vat_json_free (&node);
2310 vam->retval = ntohl (mp->retval);
2311 vam->result_ready = 1;
2314 static void vl_api_one_add_del_locator_set_reply_t_handler
2315 (vl_api_one_add_del_locator_set_reply_t * mp)
2317 vat_main_t *vam = &vat_main;
2318 i32 retval = ntohl (mp->retval);
2319 if (vam->async_mode)
2321 vam->async_errors += (retval < 0);
2325 vam->retval = retval;
2326 vam->result_ready = 1;
2330 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2331 (vl_api_one_add_del_locator_set_reply_t * mp)
2333 vat_main_t *vam = &vat_main;
2334 vat_json_node_t node;
2336 vat_json_init_object (&node);
2337 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2338 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2340 vat_json_print (vam->ofp, &node);
2341 vat_json_free (&node);
2343 vam->retval = ntohl (mp->retval);
2344 vam->result_ready = 1;
2347 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2348 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2350 vat_main_t *vam = &vat_main;
2351 i32 retval = ntohl (mp->retval);
2352 if (vam->async_mode)
2354 vam->async_errors += (retval < 0);
2358 vam->retval = retval;
2359 vam->sw_if_index = ntohl (mp->sw_if_index);
2360 vam->result_ready = 1;
2362 vam->regenerate_interface_table = 1;
2365 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2366 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2368 vat_main_t *vam = &vat_main;
2369 vat_json_node_t node;
2371 vat_json_init_object (&node);
2372 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2373 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2375 vat_json_print (vam->ofp, &node);
2376 vat_json_free (&node);
2378 vam->retval = ntohl (mp->retval);
2379 vam->result_ready = 1;
2382 static void vl_api_vxlan_offload_rx_reply_t_handler
2383 (vl_api_vxlan_offload_rx_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 i32 retval = ntohl (mp->retval);
2387 if (vam->async_mode)
2389 vam->async_errors += (retval < 0);
2393 vam->retval = retval;
2394 vam->result_ready = 1;
2398 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2399 (vl_api_vxlan_offload_rx_reply_t * mp)
2401 vat_main_t *vam = &vat_main;
2402 vat_json_node_t node;
2404 vat_json_init_object (&node);
2405 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2407 vat_json_print (vam->ofp, &node);
2408 vat_json_free (&node);
2410 vam->retval = ntohl (mp->retval);
2411 vam->result_ready = 1;
2414 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2415 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2417 vat_main_t *vam = &vat_main;
2418 i32 retval = ntohl (mp->retval);
2419 if (vam->async_mode)
2421 vam->async_errors += (retval < 0);
2425 vam->retval = retval;
2426 vam->sw_if_index = ntohl (mp->sw_if_index);
2427 vam->result_ready = 1;
2431 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2432 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2434 vat_main_t *vam = &vat_main;
2435 vat_json_node_t node;
2437 vat_json_init_object (&node);
2438 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2439 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2441 vat_json_print (vam->ofp, &node);
2442 vat_json_free (&node);
2444 vam->retval = ntohl (mp->retval);
2445 vam->result_ready = 1;
2448 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2449 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2451 vat_main_t *vam = &vat_main;
2452 i32 retval = ntohl (mp->retval);
2453 if (vam->async_mode)
2455 vam->async_errors += (retval < 0);
2459 vam->retval = retval;
2460 vam->sw_if_index = ntohl (mp->sw_if_index);
2461 vam->result_ready = 1;
2463 vam->regenerate_interface_table = 1;
2466 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2467 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2469 vat_main_t *vam = &vat_main;
2470 vat_json_node_t node;
2472 vat_json_init_object (&node);
2473 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2474 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2476 vat_json_print (vam->ofp, &node);
2477 vat_json_free (&node);
2479 vam->retval = ntohl (mp->retval);
2480 vam->result_ready = 1;
2483 static void vl_api_gre_tunnel_add_del_reply_t_handler
2484 (vl_api_gre_tunnel_add_del_reply_t * mp)
2486 vat_main_t *vam = &vat_main;
2487 i32 retval = ntohl (mp->retval);
2488 if (vam->async_mode)
2490 vam->async_errors += (retval < 0);
2494 vam->retval = retval;
2495 vam->sw_if_index = ntohl (mp->sw_if_index);
2496 vam->result_ready = 1;
2500 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2501 (vl_api_gre_tunnel_add_del_reply_t * mp)
2503 vat_main_t *vam = &vat_main;
2504 vat_json_node_t node;
2506 vat_json_init_object (&node);
2507 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2508 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2510 vat_json_print (vam->ofp, &node);
2511 vat_json_free (&node);
2513 vam->retval = ntohl (mp->retval);
2514 vam->result_ready = 1;
2517 static void vl_api_create_vhost_user_if_reply_t_handler
2518 (vl_api_create_vhost_user_if_reply_t * mp)
2520 vat_main_t *vam = &vat_main;
2521 i32 retval = ntohl (mp->retval);
2522 if (vam->async_mode)
2524 vam->async_errors += (retval < 0);
2528 vam->retval = retval;
2529 vam->sw_if_index = ntohl (mp->sw_if_index);
2530 vam->result_ready = 1;
2532 vam->regenerate_interface_table = 1;
2535 static void vl_api_create_vhost_user_if_reply_t_handler_json
2536 (vl_api_create_vhost_user_if_reply_t * mp)
2538 vat_main_t *vam = &vat_main;
2539 vat_json_node_t node;
2541 vat_json_init_object (&node);
2542 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2543 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2545 vat_json_print (vam->ofp, &node);
2546 vat_json_free (&node);
2548 vam->retval = ntohl (mp->retval);
2549 vam->result_ready = 1;
2552 static void vl_api_ip_address_details_t_handler
2553 (vl_api_ip_address_details_t * mp)
2555 vat_main_t *vam = &vat_main;
2556 static ip_address_details_t empty_ip_address_details = { {0} };
2557 ip_address_details_t *address = NULL;
2558 ip_details_t *current_ip_details = NULL;
2559 ip_details_t *details = NULL;
2561 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2563 if (!details || vam->current_sw_if_index >= vec_len (details)
2564 || !details[vam->current_sw_if_index].present)
2566 errmsg ("ip address details arrived but not stored");
2567 errmsg ("ip_dump should be called first");
2571 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2573 #define addresses (current_ip_details->addr)
2575 vec_validate_init_empty (addresses, vec_len (addresses),
2576 empty_ip_address_details);
2578 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2580 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2581 address->prefix_length = mp->prefix.len;
2585 static void vl_api_ip_address_details_t_handler_json
2586 (vl_api_ip_address_details_t * mp)
2588 vat_main_t *vam = &vat_main;
2589 vat_json_node_t *node = NULL;
2591 if (VAT_JSON_ARRAY != vam->json_tree.type)
2593 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2594 vat_json_init_array (&vam->json_tree);
2596 node = vat_json_array_add (&vam->json_tree);
2598 vat_json_init_object (node);
2599 vat_json_object_add_prefix (node, &mp->prefix);
2603 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 static ip_details_t empty_ip_details = { 0 };
2607 ip_details_t *ip = NULL;
2608 u32 sw_if_index = ~0;
2610 sw_if_index = ntohl (mp->sw_if_index);
2612 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2613 sw_if_index, empty_ip_details);
2615 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2622 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2624 vat_main_t *vam = &vat_main;
2626 if (VAT_JSON_ARRAY != vam->json_tree.type)
2628 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2629 vat_json_init_array (&vam->json_tree);
2631 vat_json_array_add_uint (&vam->json_tree,
2632 clib_net_to_host_u32 (mp->sw_if_index));
2635 static void vl_api_get_first_msg_id_reply_t_handler
2636 (vl_api_get_first_msg_id_reply_t * mp)
2638 vat_main_t *vam = &vat_main;
2639 i32 retval = ntohl (mp->retval);
2641 if (vam->async_mode)
2643 vam->async_errors += (retval < 0);
2647 vam->retval = retval;
2648 vam->result_ready = 1;
2652 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2656 static void vl_api_get_first_msg_id_reply_t_handler_json
2657 (vl_api_get_first_msg_id_reply_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vat_json_node_t node;
2662 vat_json_init_object (&node);
2663 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2664 vat_json_object_add_uint (&node, "first_msg_id",
2665 (uint) ntohs (mp->first_msg_id));
2667 vat_json_print (vam->ofp, &node);
2668 vat_json_free (&node);
2670 vam->retval = ntohl (mp->retval);
2671 vam->result_ready = 1;
2674 static void vl_api_get_node_graph_reply_t_handler
2675 (vl_api_get_node_graph_reply_t * mp)
2677 vat_main_t *vam = &vat_main;
2678 i32 retval = ntohl (mp->retval);
2679 u8 *pvt_copy, *reply;
2684 if (vam->async_mode)
2686 vam->async_errors += (retval < 0);
2690 vam->retval = retval;
2691 vam->result_ready = 1;
2694 /* "Should never happen..." */
2698 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2699 pvt_copy = vec_dup (reply);
2701 /* Toss the shared-memory original... */
2702 oldheap = vl_msg_push_heap ();
2706 vl_msg_pop_heap (oldheap);
2708 if (vam->graph_nodes)
2710 hash_free (vam->graph_node_index_by_name);
2712 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2714 node = vam->graph_nodes[0][i];
2715 vec_free (node->name);
2716 vec_free (node->next_nodes);
2719 vec_free (vam->graph_nodes[0]);
2720 vec_free (vam->graph_nodes);
2723 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2724 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2725 vec_free (pvt_copy);
2727 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2729 node = vam->graph_nodes[0][i];
2730 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2734 static void vl_api_get_node_graph_reply_t_handler_json
2735 (vl_api_get_node_graph_reply_t * mp)
2737 vat_main_t *vam = &vat_main;
2739 vat_json_node_t node;
2742 /* $$$$ make this real? */
2743 vat_json_init_object (&node);
2744 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2745 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2747 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2749 /* Toss the shared-memory original... */
2750 oldheap = vl_msg_push_heap ();
2754 vl_msg_pop_heap (oldheap);
2756 vat_json_print (vam->ofp, &node);
2757 vat_json_free (&node);
2759 vam->retval = ntohl (mp->retval);
2760 vam->result_ready = 1;
2764 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2766 vat_main_t *vam = &vat_main;
2771 s = format (s, "%=16d%=16d%=16d",
2772 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2776 s = format (s, "%=16U%=16d%=16d",
2777 mp->is_ipv6 ? format_ip6_address :
2779 mp->ip_address, mp->priority, mp->weight);
2782 print (vam->ofp, "%v", s);
2787 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2789 vat_main_t *vam = &vat_main;
2790 vat_json_node_t *node = NULL;
2791 struct in6_addr ip6;
2794 if (VAT_JSON_ARRAY != vam->json_tree.type)
2796 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2797 vat_json_init_array (&vam->json_tree);
2799 node = vat_json_array_add (&vam->json_tree);
2800 vat_json_init_object (node);
2802 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2803 vat_json_object_add_uint (node, "priority", mp->priority);
2804 vat_json_object_add_uint (node, "weight", mp->weight);
2807 vat_json_object_add_uint (node, "sw_if_index",
2808 clib_net_to_host_u32 (mp->sw_if_index));
2813 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2814 vat_json_object_add_ip6 (node, "address", ip6);
2818 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2819 vat_json_object_add_ip4 (node, "address", ip4);
2825 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2828 vat_main_t *vam = &vat_main;
2831 ls_name = format (0, "%s", mp->ls_name);
2833 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2839 vl_api_one_locator_set_details_t_handler_json
2840 (vl_api_one_locator_set_details_t * mp)
2842 vat_main_t *vam = &vat_main;
2843 vat_json_node_t *node = 0;
2846 ls_name = format (0, "%s", mp->ls_name);
2847 vec_add1 (ls_name, 0);
2849 if (VAT_JSON_ARRAY != vam->json_tree.type)
2851 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2852 vat_json_init_array (&vam->json_tree);
2854 node = vat_json_array_add (&vam->json_tree);
2856 vat_json_init_object (node);
2857 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2858 vat_json_object_add_uint (node, "ls_index",
2859 clib_net_to_host_u32 (mp->ls_index));
2867 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2870 unformat_nsh_address (unformat_input_t * input, va_list * args)
2872 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2873 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2877 format_nsh_address_vat (u8 * s, va_list * args)
2879 nsh_t *a = va_arg (*args, nsh_t *);
2880 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2884 format_lisp_flat_eid (u8 * s, va_list * args)
2886 u32 type = va_arg (*args, u32);
2887 u8 *eid = va_arg (*args, u8 *);
2888 u32 eid_len = va_arg (*args, u32);
2893 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2895 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2897 return format (s, "%U", format_ethernet_address, eid);
2899 return format (s, "%U", format_nsh_address_vat, eid);
2905 format_lisp_eid_vat (u8 * s, va_list * args)
2907 u32 type = va_arg (*args, u32);
2908 u8 *eid = va_arg (*args, u8 *);
2909 u32 eid_len = va_arg (*args, u32);
2910 u8 *seid = va_arg (*args, u8 *);
2911 u32 seid_len = va_arg (*args, u32);
2912 u32 is_src_dst = va_arg (*args, u32);
2915 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2917 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2923 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2925 vat_main_t *vam = &vat_main;
2926 u8 *s = 0, *eid = 0;
2928 if (~0 == mp->locator_set_index)
2929 s = format (0, "action: %d", mp->action);
2931 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2933 eid = format (0, "%U", format_lisp_eid_vat,
2937 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2940 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2941 clib_net_to_host_u32 (mp->vni),
2943 mp->is_local ? "local" : "remote",
2944 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2945 clib_net_to_host_u16 (mp->key_id), mp->key);
2952 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2955 vat_main_t *vam = &vat_main;
2956 vat_json_node_t *node = 0;
2959 if (VAT_JSON_ARRAY != vam->json_tree.type)
2961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2962 vat_json_init_array (&vam->json_tree);
2964 node = vat_json_array_add (&vam->json_tree);
2966 vat_json_init_object (node);
2967 if (~0 == mp->locator_set_index)
2968 vat_json_object_add_uint (node, "action", mp->action);
2970 vat_json_object_add_uint (node, "locator_set_index",
2971 clib_net_to_host_u32 (mp->locator_set_index));
2973 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2974 if (mp->eid_type == 3)
2976 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
2977 vat_json_init_object (nsh_json);
2978 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
2979 vat_json_object_add_uint (nsh_json, "spi",
2980 clib_net_to_host_u32 (nsh->spi));
2981 vat_json_object_add_uint (nsh_json, "si", nsh->si);
2985 eid = format (0, "%U", format_lisp_eid_vat,
2989 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2991 vat_json_object_add_string_copy (node, "eid", eid);
2994 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2995 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2996 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3000 vat_json_object_add_uint (node, "key_id",
3001 clib_net_to_host_u16 (mp->key_id));
3002 vat_json_object_add_string_copy (node, "key", mp->key);
3007 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3009 vat_main_t *vam = &vat_main;
3010 u8 *seid = 0, *deid = 0;
3011 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3013 deid = format (0, "%U", format_lisp_eid_vat,
3014 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3016 seid = format (0, "%U", format_lisp_eid_vat,
3017 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3023 format_ip_address_fcn = format_ip4_address;
3025 format_ip_address_fcn = format_ip6_address;
3028 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3029 clib_net_to_host_u32 (mp->vni),
3031 format_ip_address_fcn, mp->lloc,
3032 format_ip_address_fcn, mp->rloc,
3033 clib_net_to_host_u32 (mp->pkt_count),
3034 clib_net_to_host_u32 (mp->bytes));
3041 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3043 struct in6_addr ip6;
3045 vat_main_t *vam = &vat_main;
3046 vat_json_node_t *node = 0;
3047 u8 *deid = 0, *seid = 0;
3049 if (VAT_JSON_ARRAY != vam->json_tree.type)
3051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3052 vat_json_init_array (&vam->json_tree);
3054 node = vat_json_array_add (&vam->json_tree);
3056 vat_json_init_object (node);
3057 deid = format (0, "%U", format_lisp_eid_vat,
3058 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3060 seid = format (0, "%U", format_lisp_eid_vat,
3061 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3066 vat_json_object_add_string_copy (node, "seid", seid);
3067 vat_json_object_add_string_copy (node, "deid", deid);
3068 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3072 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3073 vat_json_object_add_ip4 (node, "lloc", ip4);
3074 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3075 vat_json_object_add_ip4 (node, "rloc", ip4);
3079 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3080 vat_json_object_add_ip6 (node, "lloc", ip6);
3081 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3082 vat_json_object_add_ip6 (node, "rloc", ip6);
3084 vat_json_object_add_uint (node, "pkt_count",
3085 clib_net_to_host_u32 (mp->pkt_count));
3086 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3093 vl_api_one_eid_table_map_details_t_handler
3094 (vl_api_one_eid_table_map_details_t * mp)
3096 vat_main_t *vam = &vat_main;
3098 u8 *line = format (0, "%=10d%=10d",
3099 clib_net_to_host_u32 (mp->vni),
3100 clib_net_to_host_u32 (mp->dp_table));
3101 print (vam->ofp, "%v", line);
3106 vl_api_one_eid_table_map_details_t_handler_json
3107 (vl_api_one_eid_table_map_details_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t *node = NULL;
3112 if (VAT_JSON_ARRAY != vam->json_tree.type)
3114 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3115 vat_json_init_array (&vam->json_tree);
3117 node = vat_json_array_add (&vam->json_tree);
3118 vat_json_init_object (node);
3119 vat_json_object_add_uint (node, "dp_table",
3120 clib_net_to_host_u32 (mp->dp_table));
3121 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3125 vl_api_one_eid_table_vni_details_t_handler
3126 (vl_api_one_eid_table_vni_details_t * mp)
3128 vat_main_t *vam = &vat_main;
3130 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3131 print (vam->ofp, "%v", line);
3136 vl_api_one_eid_table_vni_details_t_handler_json
3137 (vl_api_one_eid_table_vni_details_t * mp)
3139 vat_main_t *vam = &vat_main;
3140 vat_json_node_t *node = NULL;
3142 if (VAT_JSON_ARRAY != vam->json_tree.type)
3144 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3145 vat_json_init_array (&vam->json_tree);
3147 node = vat_json_array_add (&vam->json_tree);
3148 vat_json_init_object (node);
3149 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3153 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3154 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3156 vat_main_t *vam = &vat_main;
3157 int retval = clib_net_to_host_u32 (mp->retval);
3159 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3160 print (vam->ofp, "fallback threshold value: %d", mp->value);
3162 vam->retval = retval;
3163 vam->result_ready = 1;
3167 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3168 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3170 vat_main_t *vam = &vat_main;
3171 vat_json_node_t _node, *node = &_node;
3172 int retval = clib_net_to_host_u32 (mp->retval);
3174 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3175 vat_json_init_object (node);
3176 vat_json_object_add_uint (node, "value", mp->value);
3178 vat_json_print (vam->ofp, node);
3179 vat_json_free (node);
3181 vam->retval = retval;
3182 vam->result_ready = 1;
3186 vl_api_show_one_map_register_state_reply_t_handler
3187 (vl_api_show_one_map_register_state_reply_t * mp)
3189 vat_main_t *vam = &vat_main;
3190 int retval = clib_net_to_host_u32 (mp->retval);
3192 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3194 vam->retval = retval;
3195 vam->result_ready = 1;
3199 vl_api_show_one_map_register_state_reply_t_handler_json
3200 (vl_api_show_one_map_register_state_reply_t * mp)
3202 vat_main_t *vam = &vat_main;
3203 vat_json_node_t _node, *node = &_node;
3204 int retval = clib_net_to_host_u32 (mp->retval);
3206 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3208 vat_json_init_object (node);
3209 vat_json_object_add_string_copy (node, "state", s);
3211 vat_json_print (vam->ofp, node);
3212 vat_json_free (node);
3214 vam->retval = retval;
3215 vam->result_ready = 1;
3220 vl_api_show_one_rloc_probe_state_reply_t_handler
3221 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3223 vat_main_t *vam = &vat_main;
3224 int retval = clib_net_to_host_u32 (mp->retval);
3229 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3231 vam->retval = retval;
3232 vam->result_ready = 1;
3236 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3237 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3239 vat_main_t *vam = &vat_main;
3240 vat_json_node_t _node, *node = &_node;
3241 int retval = clib_net_to_host_u32 (mp->retval);
3243 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3244 vat_json_init_object (node);
3245 vat_json_object_add_string_copy (node, "state", s);
3247 vat_json_print (vam->ofp, node);
3248 vat_json_free (node);
3250 vam->retval = retval;
3251 vam->result_ready = 1;
3256 vl_api_show_one_stats_enable_disable_reply_t_handler
3257 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3259 vat_main_t *vam = &vat_main;
3260 int retval = clib_net_to_host_u32 (mp->retval);
3265 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3267 vam->retval = retval;
3268 vam->result_ready = 1;
3272 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3273 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3275 vat_main_t *vam = &vat_main;
3276 vat_json_node_t _node, *node = &_node;
3277 int retval = clib_net_to_host_u32 (mp->retval);
3279 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3280 vat_json_init_object (node);
3281 vat_json_object_add_string_copy (node, "state", s);
3283 vat_json_print (vam->ofp, node);
3284 vat_json_free (node);
3286 vam->retval = retval;
3287 vam->result_ready = 1;
3292 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3294 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3295 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3296 e->vni = clib_net_to_host_u32 (e->vni);
3300 gpe_fwd_entries_get_reply_t_net_to_host
3301 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3305 mp->count = clib_net_to_host_u32 (mp->count);
3306 for (i = 0; i < mp->count; i++)
3308 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3313 format_gpe_encap_mode (u8 * s, va_list * args)
3315 u32 mode = va_arg (*args, u32);
3320 return format (s, "lisp");
3322 return format (s, "vxlan");
3328 vl_api_gpe_get_encap_mode_reply_t_handler
3329 (vl_api_gpe_get_encap_mode_reply_t * mp)
3331 vat_main_t *vam = &vat_main;
3333 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3334 vam->retval = ntohl (mp->retval);
3335 vam->result_ready = 1;
3339 vl_api_gpe_get_encap_mode_reply_t_handler_json
3340 (vl_api_gpe_get_encap_mode_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 vat_json_node_t node;
3345 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3346 vec_add1 (encap_mode, 0);
3348 vat_json_init_object (&node);
3349 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3351 vec_free (encap_mode);
3352 vat_json_print (vam->ofp, &node);
3353 vat_json_free (&node);
3355 vam->retval = ntohl (mp->retval);
3356 vam->result_ready = 1;
3360 vl_api_gpe_fwd_entry_path_details_t_handler
3361 (vl_api_gpe_fwd_entry_path_details_t * mp)
3363 vat_main_t *vam = &vat_main;
3364 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3366 if (mp->lcl_loc.is_ip4)
3367 format_ip_address_fcn = format_ip4_address;
3369 format_ip_address_fcn = format_ip6_address;
3371 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3372 format_ip_address_fcn, &mp->lcl_loc,
3373 format_ip_address_fcn, &mp->rmt_loc);
3377 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3379 struct in6_addr ip6;
3384 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3385 vat_json_object_add_ip4 (n, "address", ip4);
3389 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3390 vat_json_object_add_ip6 (n, "address", ip6);
3392 vat_json_object_add_uint (n, "weight", loc->weight);
3396 vl_api_gpe_fwd_entry_path_details_t_handler_json
3397 (vl_api_gpe_fwd_entry_path_details_t * mp)
3399 vat_main_t *vam = &vat_main;
3400 vat_json_node_t *node = NULL;
3401 vat_json_node_t *loc_node;
3403 if (VAT_JSON_ARRAY != vam->json_tree.type)
3405 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3406 vat_json_init_array (&vam->json_tree);
3408 node = vat_json_array_add (&vam->json_tree);
3409 vat_json_init_object (node);
3411 loc_node = vat_json_object_add (node, "local_locator");
3412 vat_json_init_object (loc_node);
3413 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3415 loc_node = vat_json_object_add (node, "remote_locator");
3416 vat_json_init_object (loc_node);
3417 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3421 vl_api_gpe_fwd_entries_get_reply_t_handler
3422 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3424 vat_main_t *vam = &vat_main;
3426 int retval = clib_net_to_host_u32 (mp->retval);
3427 vl_api_gpe_fwd_entry_t *e;
3432 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3434 for (i = 0; i < mp->count; i++)
3436 e = &mp->entries[i];
3437 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3438 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3439 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3443 vam->retval = retval;
3444 vam->result_ready = 1;
3448 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3449 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3452 vat_main_t *vam = &vat_main;
3453 vat_json_node_t *e = 0, root;
3455 int retval = clib_net_to_host_u32 (mp->retval);
3456 vl_api_gpe_fwd_entry_t *fwd;
3461 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3462 vat_json_init_array (&root);
3464 for (i = 0; i < mp->count; i++)
3466 e = vat_json_array_add (&root);
3467 fwd = &mp->entries[i];
3469 vat_json_init_object (e);
3470 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3471 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3472 vat_json_object_add_int (e, "vni", fwd->vni);
3473 vat_json_object_add_int (e, "action", fwd->action);
3475 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3476 fwd->leid_prefix_len);
3478 vat_json_object_add_string_copy (e, "leid", s);
3481 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3482 fwd->reid_prefix_len);
3484 vat_json_object_add_string_copy (e, "reid", s);
3488 vat_json_print (vam->ofp, &root);
3489 vat_json_free (&root);
3492 vam->retval = retval;
3493 vam->result_ready = 1;
3497 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3498 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3500 vat_main_t *vam = &vat_main;
3502 int retval = clib_net_to_host_u32 (mp->retval);
3503 vl_api_gpe_native_fwd_rpath_t *r;
3508 n = clib_net_to_host_u32 (mp->count);
3510 for (i = 0; i < n; i++)
3512 r = &mp->entries[i];
3513 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3514 clib_net_to_host_u32 (r->fib_index),
3515 clib_net_to_host_u32 (r->nh_sw_if_index),
3516 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3520 vam->retval = retval;
3521 vam->result_ready = 1;
3525 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3526 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3528 vat_main_t *vam = &vat_main;
3529 vat_json_node_t root, *e;
3531 int retval = clib_net_to_host_u32 (mp->retval);
3532 vl_api_gpe_native_fwd_rpath_t *r;
3538 n = clib_net_to_host_u32 (mp->count);
3539 vat_json_init_array (&root);
3541 for (i = 0; i < n; i++)
3543 e = vat_json_array_add (&root);
3544 vat_json_init_object (e);
3545 r = &mp->entries[i];
3547 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3550 vat_json_object_add_string_copy (e, "ip4", s);
3553 vat_json_object_add_uint (e, "fib_index",
3554 clib_net_to_host_u32 (r->fib_index));
3555 vat_json_object_add_uint (e, "nh_sw_if_index",
3556 clib_net_to_host_u32 (r->nh_sw_if_index));
3559 vat_json_print (vam->ofp, &root);
3560 vat_json_free (&root);
3563 vam->retval = retval;
3564 vam->result_ready = 1;
3568 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3569 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3571 vat_main_t *vam = &vat_main;
3573 int retval = clib_net_to_host_u32 (mp->retval);
3578 n = clib_net_to_host_u32 (mp->count);
3580 for (i = 0; i < n; i++)
3581 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3584 vam->retval = retval;
3585 vam->result_ready = 1;
3589 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3590 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3592 vat_main_t *vam = &vat_main;
3593 vat_json_node_t root;
3595 int retval = clib_net_to_host_u32 (mp->retval);
3600 n = clib_net_to_host_u32 (mp->count);
3601 vat_json_init_array (&root);
3603 for (i = 0; i < n; i++)
3604 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3606 vat_json_print (vam->ofp, &root);
3607 vat_json_free (&root);
3610 vam->retval = retval;
3611 vam->result_ready = 1;
3615 vl_api_one_ndp_entries_get_reply_t_handler
3616 (vl_api_one_ndp_entries_get_reply_t * mp)
3618 vat_main_t *vam = &vat_main;
3620 int retval = clib_net_to_host_u32 (mp->retval);
3625 n = clib_net_to_host_u32 (mp->count);
3627 for (i = 0; i < n; i++)
3628 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3629 format_ethernet_address, mp->entries[i].mac);
3632 vam->retval = retval;
3633 vam->result_ready = 1;
3637 vl_api_one_ndp_entries_get_reply_t_handler_json
3638 (vl_api_one_ndp_entries_get_reply_t * mp)
3641 vat_main_t *vam = &vat_main;
3642 vat_json_node_t *e = 0, root;
3644 int retval = clib_net_to_host_u32 (mp->retval);
3645 vl_api_one_ndp_entry_t *arp_entry;
3650 n = clib_net_to_host_u32 (mp->count);
3651 vat_json_init_array (&root);
3653 for (i = 0; i < n; i++)
3655 e = vat_json_array_add (&root);
3656 arp_entry = &mp->entries[i];
3658 vat_json_init_object (e);
3659 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3662 vat_json_object_add_string_copy (e, "mac", s);
3665 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3667 vat_json_object_add_string_copy (e, "ip6", s);
3671 vat_json_print (vam->ofp, &root);
3672 vat_json_free (&root);
3675 vam->retval = retval;
3676 vam->result_ready = 1;
3680 vl_api_one_l2_arp_entries_get_reply_t_handler
3681 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3683 vat_main_t *vam = &vat_main;
3685 int retval = clib_net_to_host_u32 (mp->retval);
3690 n = clib_net_to_host_u32 (mp->count);
3692 for (i = 0; i < n; i++)
3693 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3694 format_ethernet_address, mp->entries[i].mac);
3697 vam->retval = retval;
3698 vam->result_ready = 1;
3702 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3703 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 vat_json_node_t *e = 0, root;
3709 int retval = clib_net_to_host_u32 (mp->retval);
3710 vl_api_one_l2_arp_entry_t *arp_entry;
3715 n = clib_net_to_host_u32 (mp->count);
3716 vat_json_init_array (&root);
3718 for (i = 0; i < n; i++)
3720 e = vat_json_array_add (&root);
3721 arp_entry = &mp->entries[i];
3723 vat_json_init_object (e);
3724 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3727 vat_json_object_add_string_copy (e, "mac", s);
3730 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3732 vat_json_object_add_string_copy (e, "ip4", s);
3736 vat_json_print (vam->ofp, &root);
3737 vat_json_free (&root);
3740 vam->retval = retval;
3741 vam->result_ready = 1;
3745 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3747 vat_main_t *vam = &vat_main;
3749 int retval = clib_net_to_host_u32 (mp->retval);
3754 n = clib_net_to_host_u32 (mp->count);
3756 for (i = 0; i < n; i++)
3758 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3762 vam->retval = retval;
3763 vam->result_ready = 1;
3767 vl_api_one_ndp_bd_get_reply_t_handler_json
3768 (vl_api_one_ndp_bd_get_reply_t * mp)
3770 vat_main_t *vam = &vat_main;
3771 vat_json_node_t root;
3773 int retval = clib_net_to_host_u32 (mp->retval);
3778 n = clib_net_to_host_u32 (mp->count);
3779 vat_json_init_array (&root);
3781 for (i = 0; i < n; i++)
3783 vat_json_array_add_uint (&root,
3784 clib_net_to_host_u32 (mp->bridge_domains[i]));
3787 vat_json_print (vam->ofp, &root);
3788 vat_json_free (&root);
3791 vam->retval = retval;
3792 vam->result_ready = 1;
3796 vl_api_one_l2_arp_bd_get_reply_t_handler
3797 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3799 vat_main_t *vam = &vat_main;
3801 int retval = clib_net_to_host_u32 (mp->retval);
3806 n = clib_net_to_host_u32 (mp->count);
3808 for (i = 0; i < n; i++)
3810 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3814 vam->retval = retval;
3815 vam->result_ready = 1;
3819 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3820 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3822 vat_main_t *vam = &vat_main;
3823 vat_json_node_t root;
3825 int retval = clib_net_to_host_u32 (mp->retval);
3830 n = clib_net_to_host_u32 (mp->count);
3831 vat_json_init_array (&root);
3833 for (i = 0; i < n; i++)
3835 vat_json_array_add_uint (&root,
3836 clib_net_to_host_u32 (mp->bridge_domains[i]));
3839 vat_json_print (vam->ofp, &root);
3840 vat_json_free (&root);
3843 vam->retval = retval;
3844 vam->result_ready = 1;
3848 vl_api_one_adjacencies_get_reply_t_handler
3849 (vl_api_one_adjacencies_get_reply_t * mp)
3851 vat_main_t *vam = &vat_main;
3853 int retval = clib_net_to_host_u32 (mp->retval);
3854 vl_api_one_adjacency_t *a;
3859 n = clib_net_to_host_u32 (mp->count);
3861 for (i = 0; i < n; i++)
3863 a = &mp->adjacencies[i];
3864 print (vam->ofp, "%U %40U",
3865 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3866 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3870 vam->retval = retval;
3871 vam->result_ready = 1;
3875 vl_api_one_adjacencies_get_reply_t_handler_json
3876 (vl_api_one_adjacencies_get_reply_t * mp)
3879 vat_main_t *vam = &vat_main;
3880 vat_json_node_t *e = 0, root;
3882 int retval = clib_net_to_host_u32 (mp->retval);
3883 vl_api_one_adjacency_t *a;
3888 n = clib_net_to_host_u32 (mp->count);
3889 vat_json_init_array (&root);
3891 for (i = 0; i < n; i++)
3893 e = vat_json_array_add (&root);
3894 a = &mp->adjacencies[i];
3896 vat_json_init_object (e);
3897 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3898 a->leid_prefix_len);
3900 vat_json_object_add_string_copy (e, "leid", s);
3903 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3904 a->reid_prefix_len);
3906 vat_json_object_add_string_copy (e, "reid", s);
3910 vat_json_print (vam->ofp, &root);
3911 vat_json_free (&root);
3914 vam->retval = retval;
3915 vam->result_ready = 1;
3919 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3921 vat_main_t *vam = &vat_main;
3923 print (vam->ofp, "%=20U",
3924 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3929 vl_api_one_map_server_details_t_handler_json
3930 (vl_api_one_map_server_details_t * mp)
3932 vat_main_t *vam = &vat_main;
3933 vat_json_node_t *node = NULL;
3934 struct in6_addr ip6;
3937 if (VAT_JSON_ARRAY != vam->json_tree.type)
3939 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3940 vat_json_init_array (&vam->json_tree);
3942 node = vat_json_array_add (&vam->json_tree);
3944 vat_json_init_object (node);
3947 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3948 vat_json_object_add_ip6 (node, "map-server", ip6);
3952 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3953 vat_json_object_add_ip4 (node, "map-server", ip4);
3958 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3961 vat_main_t *vam = &vat_main;
3963 print (vam->ofp, "%=20U",
3964 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3969 vl_api_one_map_resolver_details_t_handler_json
3970 (vl_api_one_map_resolver_details_t * mp)
3972 vat_main_t *vam = &vat_main;
3973 vat_json_node_t *node = NULL;
3974 struct in6_addr ip6;
3977 if (VAT_JSON_ARRAY != vam->json_tree.type)
3979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3980 vat_json_init_array (&vam->json_tree);
3982 node = vat_json_array_add (&vam->json_tree);
3984 vat_json_init_object (node);
3987 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3988 vat_json_object_add_ip6 (node, "map resolver", ip6);
3992 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3993 vat_json_object_add_ip4 (node, "map resolver", ip4);
3998 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4000 vat_main_t *vam = &vat_main;
4001 i32 retval = ntohl (mp->retval);
4005 print (vam->ofp, "feature: %s\ngpe: %s",
4006 mp->feature_status ? "enabled" : "disabled",
4007 mp->gpe_status ? "enabled" : "disabled");
4010 vam->retval = retval;
4011 vam->result_ready = 1;
4015 vl_api_show_one_status_reply_t_handler_json
4016 (vl_api_show_one_status_reply_t * mp)
4018 vat_main_t *vam = &vat_main;
4019 vat_json_node_t node;
4020 u8 *gpe_status = NULL;
4021 u8 *feature_status = NULL;
4023 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4024 feature_status = format (0, "%s",
4025 mp->feature_status ? "enabled" : "disabled");
4026 vec_add1 (gpe_status, 0);
4027 vec_add1 (feature_status, 0);
4029 vat_json_init_object (&node);
4030 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4031 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4033 vec_free (gpe_status);
4034 vec_free (feature_status);
4036 vat_json_print (vam->ofp, &node);
4037 vat_json_free (&node);
4039 vam->retval = ntohl (mp->retval);
4040 vam->result_ready = 1;
4044 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4045 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4047 vat_main_t *vam = &vat_main;
4048 i32 retval = ntohl (mp->retval);
4052 print (vam->ofp, "%=20s", mp->locator_set_name);
4055 vam->retval = retval;
4056 vam->result_ready = 1;
4060 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4061 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4063 vat_main_t *vam = &vat_main;
4064 vat_json_node_t *node = NULL;
4066 if (VAT_JSON_ARRAY != vam->json_tree.type)
4068 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4069 vat_json_init_array (&vam->json_tree);
4071 node = vat_json_array_add (&vam->json_tree);
4073 vat_json_init_object (node);
4074 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4076 vat_json_print (vam->ofp, node);
4077 vat_json_free (node);
4079 vam->retval = ntohl (mp->retval);
4080 vam->result_ready = 1;
4084 format_lisp_map_request_mode (u8 * s, va_list * args)
4086 u32 mode = va_arg (*args, u32);
4091 return format (0, "dst-only");
4093 return format (0, "src-dst");
4099 vl_api_show_one_map_request_mode_reply_t_handler
4100 (vl_api_show_one_map_request_mode_reply_t * mp)
4102 vat_main_t *vam = &vat_main;
4103 i32 retval = ntohl (mp->retval);
4107 u32 mode = mp->mode;
4108 print (vam->ofp, "map_request_mode: %U",
4109 format_lisp_map_request_mode, mode);
4112 vam->retval = retval;
4113 vam->result_ready = 1;
4117 vl_api_show_one_map_request_mode_reply_t_handler_json
4118 (vl_api_show_one_map_request_mode_reply_t * mp)
4120 vat_main_t *vam = &vat_main;
4121 vat_json_node_t node;
4126 s = format (0, "%U", format_lisp_map_request_mode, mode);
4129 vat_json_init_object (&node);
4130 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4131 vat_json_print (vam->ofp, &node);
4132 vat_json_free (&node);
4135 vam->retval = ntohl (mp->retval);
4136 vam->result_ready = 1;
4140 vl_api_one_show_xtr_mode_reply_t_handler
4141 (vl_api_one_show_xtr_mode_reply_t * mp)
4143 vat_main_t *vam = &vat_main;
4144 i32 retval = ntohl (mp->retval);
4148 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4151 vam->retval = retval;
4152 vam->result_ready = 1;
4156 vl_api_one_show_xtr_mode_reply_t_handler_json
4157 (vl_api_one_show_xtr_mode_reply_t * mp)
4159 vat_main_t *vam = &vat_main;
4160 vat_json_node_t node;
4163 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4164 vec_add1 (status, 0);
4166 vat_json_init_object (&node);
4167 vat_json_object_add_string_copy (&node, "status", status);
4171 vat_json_print (vam->ofp, &node);
4172 vat_json_free (&node);
4174 vam->retval = ntohl (mp->retval);
4175 vam->result_ready = 1;
4179 vl_api_one_show_pitr_mode_reply_t_handler
4180 (vl_api_one_show_pitr_mode_reply_t * mp)
4182 vat_main_t *vam = &vat_main;
4183 i32 retval = ntohl (mp->retval);
4187 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4190 vam->retval = retval;
4191 vam->result_ready = 1;
4195 vl_api_one_show_pitr_mode_reply_t_handler_json
4196 (vl_api_one_show_pitr_mode_reply_t * mp)
4198 vat_main_t *vam = &vat_main;
4199 vat_json_node_t node;
4202 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4203 vec_add1 (status, 0);
4205 vat_json_init_object (&node);
4206 vat_json_object_add_string_copy (&node, "status", status);
4210 vat_json_print (vam->ofp, &node);
4211 vat_json_free (&node);
4213 vam->retval = ntohl (mp->retval);
4214 vam->result_ready = 1;
4218 vl_api_one_show_petr_mode_reply_t_handler
4219 (vl_api_one_show_petr_mode_reply_t * mp)
4221 vat_main_t *vam = &vat_main;
4222 i32 retval = ntohl (mp->retval);
4226 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4229 vam->retval = retval;
4230 vam->result_ready = 1;
4234 vl_api_one_show_petr_mode_reply_t_handler_json
4235 (vl_api_one_show_petr_mode_reply_t * mp)
4237 vat_main_t *vam = &vat_main;
4238 vat_json_node_t node;
4241 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4242 vec_add1 (status, 0);
4244 vat_json_init_object (&node);
4245 vat_json_object_add_string_copy (&node, "status", status);
4249 vat_json_print (vam->ofp, &node);
4250 vat_json_free (&node);
4252 vam->retval = ntohl (mp->retval);
4253 vam->result_ready = 1;
4257 vl_api_show_one_use_petr_reply_t_handler
4258 (vl_api_show_one_use_petr_reply_t * mp)
4260 vat_main_t *vam = &vat_main;
4261 i32 retval = ntohl (mp->retval);
4265 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4268 print (vam->ofp, "Proxy-ETR address; %U",
4269 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4274 vam->retval = retval;
4275 vam->result_ready = 1;
4279 vl_api_show_one_use_petr_reply_t_handler_json
4280 (vl_api_show_one_use_petr_reply_t * mp)
4282 vat_main_t *vam = &vat_main;
4283 vat_json_node_t node;
4286 struct in6_addr ip6;
4288 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4289 vec_add1 (status, 0);
4291 vat_json_init_object (&node);
4292 vat_json_object_add_string_copy (&node, "status", status);
4297 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4298 vat_json_object_add_ip6 (&node, "address", ip6);
4302 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4303 vat_json_object_add_ip4 (&node, "address", ip4);
4309 vat_json_print (vam->ofp, &node);
4310 vat_json_free (&node);
4312 vam->retval = ntohl (mp->retval);
4313 vam->result_ready = 1;
4317 vl_api_show_one_nsh_mapping_reply_t_handler
4318 (vl_api_show_one_nsh_mapping_reply_t * mp)
4320 vat_main_t *vam = &vat_main;
4321 i32 retval = ntohl (mp->retval);
4325 print (vam->ofp, "%-20s%-16s",
4326 mp->is_set ? "set" : "not-set",
4327 mp->is_set ? (char *) mp->locator_set_name : "");
4330 vam->retval = retval;
4331 vam->result_ready = 1;
4335 vl_api_show_one_nsh_mapping_reply_t_handler_json
4336 (vl_api_show_one_nsh_mapping_reply_t * mp)
4338 vat_main_t *vam = &vat_main;
4339 vat_json_node_t node;
4342 status = format (0, "%s", mp->is_set ? "yes" : "no");
4343 vec_add1 (status, 0);
4345 vat_json_init_object (&node);
4346 vat_json_object_add_string_copy (&node, "is_set", status);
4349 vat_json_object_add_string_copy (&node, "locator_set",
4350 mp->locator_set_name);
4355 vat_json_print (vam->ofp, &node);
4356 vat_json_free (&node);
4358 vam->retval = ntohl (mp->retval);
4359 vam->result_ready = 1;
4363 vl_api_show_one_map_register_ttl_reply_t_handler
4364 (vl_api_show_one_map_register_ttl_reply_t * mp)
4366 vat_main_t *vam = &vat_main;
4367 i32 retval = ntohl (mp->retval);
4369 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4373 print (vam->ofp, "ttl: %u", mp->ttl);
4376 vam->retval = retval;
4377 vam->result_ready = 1;
4381 vl_api_show_one_map_register_ttl_reply_t_handler_json
4382 (vl_api_show_one_map_register_ttl_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 vat_json_node_t node;
4387 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4388 vat_json_init_object (&node);
4389 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4391 vat_json_print (vam->ofp, &node);
4392 vat_json_free (&node);
4394 vam->retval = ntohl (mp->retval);
4395 vam->result_ready = 1;
4399 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4401 vat_main_t *vam = &vat_main;
4402 i32 retval = ntohl (mp->retval);
4406 print (vam->ofp, "%-20s%-16s",
4407 mp->status ? "enabled" : "disabled",
4408 mp->status ? (char *) mp->locator_set_name : "");
4411 vam->retval = retval;
4412 vam->result_ready = 1;
4416 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4418 vat_main_t *vam = &vat_main;
4419 vat_json_node_t node;
4422 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4423 vec_add1 (status, 0);
4425 vat_json_init_object (&node);
4426 vat_json_object_add_string_copy (&node, "status", status);
4429 vat_json_object_add_string_copy (&node, "locator_set",
4430 mp->locator_set_name);
4435 vat_json_print (vam->ofp, &node);
4436 vat_json_free (&node);
4438 vam->retval = ntohl (mp->retval);
4439 vam->result_ready = 1;
4443 format_policer_type (u8 * s, va_list * va)
4445 u32 i = va_arg (*va, u32);
4447 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4448 s = format (s, "1r2c");
4449 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4450 s = format (s, "1r3c");
4451 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4452 s = format (s, "2r3c-2698");
4453 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4454 s = format (s, "2r3c-4115");
4455 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4456 s = format (s, "2r3c-mef5cf1");
4458 s = format (s, "ILLEGAL");
4463 format_policer_rate_type (u8 * s, va_list * va)
4465 u32 i = va_arg (*va, u32);
4467 if (i == SSE2_QOS_RATE_KBPS)
4468 s = format (s, "kbps");
4469 else if (i == SSE2_QOS_RATE_PPS)
4470 s = format (s, "pps");
4472 s = format (s, "ILLEGAL");
4477 format_policer_round_type (u8 * s, va_list * va)
4479 u32 i = va_arg (*va, u32);
4481 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4482 s = format (s, "closest");
4483 else if (i == SSE2_QOS_ROUND_TO_UP)
4484 s = format (s, "up");
4485 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4486 s = format (s, "down");
4488 s = format (s, "ILLEGAL");
4493 format_policer_action_type (u8 * s, va_list * va)
4495 u32 i = va_arg (*va, u32);
4497 if (i == SSE2_QOS_ACTION_DROP)
4498 s = format (s, "drop");
4499 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4500 s = format (s, "transmit");
4501 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4502 s = format (s, "mark-and-transmit");
4504 s = format (s, "ILLEGAL");
4509 format_dscp (u8 * s, va_list * va)
4511 u32 i = va_arg (*va, u32);
4516 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4520 return format (s, "ILLEGAL");
4522 s = format (s, "%s", t);
4527 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4529 vat_main_t *vam = &vat_main;
4530 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4532 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4533 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4535 conform_dscp_str = format (0, "");
4537 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4538 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4540 exceed_dscp_str = format (0, "");
4542 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4543 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4545 violate_dscp_str = format (0, "");
4547 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4548 "rate type %U, round type %U, %s rate, %s color-aware, "
4549 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4550 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4551 "conform action %U%s, exceed action %U%s, violate action %U%s",
4553 format_policer_type, mp->type,
4556 clib_net_to_host_u64 (mp->cb),
4557 clib_net_to_host_u64 (mp->eb),
4558 format_policer_rate_type, mp->rate_type,
4559 format_policer_round_type, mp->round_type,
4560 mp->single_rate ? "single" : "dual",
4561 mp->color_aware ? "is" : "not",
4562 ntohl (mp->cir_tokens_per_period),
4563 ntohl (mp->pir_tokens_per_period),
4565 ntohl (mp->current_limit),
4566 ntohl (mp->current_bucket),
4567 ntohl (mp->extended_limit),
4568 ntohl (mp->extended_bucket),
4569 clib_net_to_host_u64 (mp->last_update_time),
4570 format_policer_action_type, mp->conform_action_type,
4572 format_policer_action_type, mp->exceed_action_type,
4574 format_policer_action_type, mp->violate_action_type,
4577 vec_free (conform_dscp_str);
4578 vec_free (exceed_dscp_str);
4579 vec_free (violate_dscp_str);
4582 static void vl_api_policer_details_t_handler_json
4583 (vl_api_policer_details_t * mp)
4585 vat_main_t *vam = &vat_main;
4586 vat_json_node_t *node;
4587 u8 *rate_type_str, *round_type_str, *type_str;
4588 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4590 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4592 format (0, "%U", format_policer_round_type, mp->round_type);
4593 type_str = format (0, "%U", format_policer_type, mp->type);
4594 conform_action_str = format (0, "%U", format_policer_action_type,
4595 mp->conform_action_type);
4596 exceed_action_str = format (0, "%U", format_policer_action_type,
4597 mp->exceed_action_type);
4598 violate_action_str = format (0, "%U", format_policer_action_type,
4599 mp->violate_action_type);
4601 if (VAT_JSON_ARRAY != vam->json_tree.type)
4603 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4604 vat_json_init_array (&vam->json_tree);
4606 node = vat_json_array_add (&vam->json_tree);
4608 vat_json_init_object (node);
4609 vat_json_object_add_string_copy (node, "name", mp->name);
4610 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4611 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4612 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4613 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4614 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4615 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4616 vat_json_object_add_string_copy (node, "type", type_str);
4617 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4618 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4619 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4620 vat_json_object_add_uint (node, "cir_tokens_per_period",
4621 ntohl (mp->cir_tokens_per_period));
4622 vat_json_object_add_uint (node, "eir_tokens_per_period",
4623 ntohl (mp->pir_tokens_per_period));
4624 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4625 vat_json_object_add_uint (node, "current_bucket",
4626 ntohl (mp->current_bucket));
4627 vat_json_object_add_uint (node, "extended_limit",
4628 ntohl (mp->extended_limit));
4629 vat_json_object_add_uint (node, "extended_bucket",
4630 ntohl (mp->extended_bucket));
4631 vat_json_object_add_uint (node, "last_update_time",
4632 ntohl (mp->last_update_time));
4633 vat_json_object_add_string_copy (node, "conform_action",
4634 conform_action_str);
4635 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4637 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4638 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4639 vec_free (dscp_str);
4641 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4642 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4644 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4645 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4646 vec_free (dscp_str);
4648 vat_json_object_add_string_copy (node, "violate_action",
4649 violate_action_str);
4650 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4652 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4653 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4654 vec_free (dscp_str);
4657 vec_free (rate_type_str);
4658 vec_free (round_type_str);
4659 vec_free (type_str);
4660 vec_free (conform_action_str);
4661 vec_free (exceed_action_str);
4662 vec_free (violate_action_str);
4666 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4669 vat_main_t *vam = &vat_main;
4670 int i, count = ntohl (mp->count);
4673 print (vam->ofp, "classify table ids (%d) : ", count);
4674 for (i = 0; i < count; i++)
4676 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4677 print (vam->ofp, (i < count - 1) ? "," : "");
4679 vam->retval = ntohl (mp->retval);
4680 vam->result_ready = 1;
4684 vl_api_classify_table_ids_reply_t_handler_json
4685 (vl_api_classify_table_ids_reply_t * mp)
4687 vat_main_t *vam = &vat_main;
4688 int i, count = ntohl (mp->count);
4692 vat_json_node_t node;
4694 vat_json_init_object (&node);
4695 for (i = 0; i < count; i++)
4697 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4699 vat_json_print (vam->ofp, &node);
4700 vat_json_free (&node);
4702 vam->retval = ntohl (mp->retval);
4703 vam->result_ready = 1;
4707 vl_api_classify_table_by_interface_reply_t_handler
4708 (vl_api_classify_table_by_interface_reply_t * mp)
4710 vat_main_t *vam = &vat_main;
4713 table_id = ntohl (mp->l2_table_id);
4715 print (vam->ofp, "l2 table id : %d", table_id);
4717 print (vam->ofp, "l2 table id : No input ACL tables configured");
4718 table_id = ntohl (mp->ip4_table_id);
4720 print (vam->ofp, "ip4 table id : %d", table_id);
4722 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4723 table_id = ntohl (mp->ip6_table_id);
4725 print (vam->ofp, "ip6 table id : %d", table_id);
4727 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4728 vam->retval = ntohl (mp->retval);
4729 vam->result_ready = 1;
4733 vl_api_classify_table_by_interface_reply_t_handler_json
4734 (vl_api_classify_table_by_interface_reply_t * mp)
4736 vat_main_t *vam = &vat_main;
4737 vat_json_node_t node;
4739 vat_json_init_object (&node);
4741 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4742 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4743 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4745 vat_json_print (vam->ofp, &node);
4746 vat_json_free (&node);
4748 vam->retval = ntohl (mp->retval);
4749 vam->result_ready = 1;
4752 static void vl_api_policer_add_del_reply_t_handler
4753 (vl_api_policer_add_del_reply_t * mp)
4755 vat_main_t *vam = &vat_main;
4756 i32 retval = ntohl (mp->retval);
4757 if (vam->async_mode)
4759 vam->async_errors += (retval < 0);
4763 vam->retval = retval;
4764 vam->result_ready = 1;
4765 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4767 * Note: this is just barely thread-safe, depends on
4768 * the main thread spinning waiting for an answer...
4770 errmsg ("policer index %d", ntohl (mp->policer_index));
4774 static void vl_api_policer_add_del_reply_t_handler_json
4775 (vl_api_policer_add_del_reply_t * mp)
4777 vat_main_t *vam = &vat_main;
4778 vat_json_node_t node;
4780 vat_json_init_object (&node);
4781 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4782 vat_json_object_add_uint (&node, "policer_index",
4783 ntohl (mp->policer_index));
4785 vat_json_print (vam->ofp, &node);
4786 vat_json_free (&node);
4788 vam->retval = ntohl (mp->retval);
4789 vam->result_ready = 1;
4792 /* Format hex dump. */
4794 format_hex_bytes (u8 * s, va_list * va)
4796 u8 *bytes = va_arg (*va, u8 *);
4797 int n_bytes = va_arg (*va, int);
4800 /* Print short or long form depending on byte count. */
4801 uword short_form = n_bytes <= 32;
4802 u32 indent = format_get_indent (s);
4807 for (i = 0; i < n_bytes; i++)
4809 if (!short_form && (i % 32) == 0)
4810 s = format (s, "%08x: ", i);
4811 s = format (s, "%02x", bytes[i]);
4812 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4813 s = format (s, "\n%U", format_white_space, indent);
4820 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4823 vat_main_t *vam = &vat_main;
4824 i32 retval = ntohl (mp->retval);
4827 print (vam->ofp, "classify table info :");
4828 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4829 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4830 ntohl (mp->miss_next_index));
4831 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4832 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4833 ntohl (mp->match_n_vectors));
4834 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4835 ntohl (mp->mask_length));
4837 vam->retval = retval;
4838 vam->result_ready = 1;
4842 vl_api_classify_table_info_reply_t_handler_json
4843 (vl_api_classify_table_info_reply_t * mp)
4845 vat_main_t *vam = &vat_main;
4846 vat_json_node_t node;
4848 i32 retval = ntohl (mp->retval);
4851 vat_json_init_object (&node);
4853 vat_json_object_add_int (&node, "sessions",
4854 ntohl (mp->active_sessions));
4855 vat_json_object_add_int (&node, "nexttbl",
4856 ntohl (mp->next_table_index));
4857 vat_json_object_add_int (&node, "nextnode",
4858 ntohl (mp->miss_next_index));
4859 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4860 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4861 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4862 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4863 ntohl (mp->mask_length), 0);
4864 vat_json_object_add_string_copy (&node, "mask", s);
4866 vat_json_print (vam->ofp, &node);
4867 vat_json_free (&node);
4869 vam->retval = ntohl (mp->retval);
4870 vam->result_ready = 1;
4874 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4877 vat_main_t *vam = &vat_main;
4879 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4880 ntohl (mp->hit_next_index), ntohl (mp->advance),
4881 ntohl (mp->opaque_index));
4882 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4883 ntohl (mp->match_length));
4887 vl_api_classify_session_details_t_handler_json
4888 (vl_api_classify_session_details_t * mp)
4890 vat_main_t *vam = &vat_main;
4891 vat_json_node_t *node = NULL;
4893 if (VAT_JSON_ARRAY != vam->json_tree.type)
4895 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4896 vat_json_init_array (&vam->json_tree);
4898 node = vat_json_array_add (&vam->json_tree);
4900 vat_json_init_object (node);
4901 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4902 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4903 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4905 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4907 vat_json_object_add_string_copy (node, "match", s);
4910 static void vl_api_pg_create_interface_reply_t_handler
4911 (vl_api_pg_create_interface_reply_t * mp)
4913 vat_main_t *vam = &vat_main;
4915 vam->retval = ntohl (mp->retval);
4916 vam->result_ready = 1;
4919 static void vl_api_pg_create_interface_reply_t_handler_json
4920 (vl_api_pg_create_interface_reply_t * mp)
4922 vat_main_t *vam = &vat_main;
4923 vat_json_node_t node;
4925 i32 retval = ntohl (mp->retval);
4928 vat_json_init_object (&node);
4930 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4932 vat_json_print (vam->ofp, &node);
4933 vat_json_free (&node);
4935 vam->retval = ntohl (mp->retval);
4936 vam->result_ready = 1;
4939 static void vl_api_policer_classify_details_t_handler
4940 (vl_api_policer_classify_details_t * mp)
4942 vat_main_t *vam = &vat_main;
4944 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4945 ntohl (mp->table_index));
4948 static void vl_api_policer_classify_details_t_handler_json
4949 (vl_api_policer_classify_details_t * mp)
4951 vat_main_t *vam = &vat_main;
4952 vat_json_node_t *node;
4954 if (VAT_JSON_ARRAY != vam->json_tree.type)
4956 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4957 vat_json_init_array (&vam->json_tree);
4959 node = vat_json_array_add (&vam->json_tree);
4961 vat_json_init_object (node);
4962 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4963 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4966 static void vl_api_flow_classify_details_t_handler
4967 (vl_api_flow_classify_details_t * mp)
4969 vat_main_t *vam = &vat_main;
4971 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4972 ntohl (mp->table_index));
4975 static void vl_api_flow_classify_details_t_handler_json
4976 (vl_api_flow_classify_details_t * mp)
4978 vat_main_t *vam = &vat_main;
4979 vat_json_node_t *node;
4981 if (VAT_JSON_ARRAY != vam->json_tree.type)
4983 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4984 vat_json_init_array (&vam->json_tree);
4986 node = vat_json_array_add (&vam->json_tree);
4988 vat_json_init_object (node);
4989 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4990 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4993 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
4994 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
4995 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
4996 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
4997 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
4998 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
4999 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5000 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5001 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5002 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5005 * Generate boilerplate reply handlers, which
5006 * dig the return value out of the xxx_reply_t API message,
5007 * stick it into vam->retval, and set vam->result_ready
5009 * Could also do this by pointing N message decode slots at
5010 * a single function, but that could break in subtle ways.
5013 #define foreach_standard_reply_retval_handler \
5014 _(sw_interface_set_flags_reply) \
5015 _(sw_interface_add_del_address_reply) \
5016 _(sw_interface_set_rx_mode_reply) \
5017 _(sw_interface_set_rx_placement_reply) \
5018 _(sw_interface_set_table_reply) \
5019 _(sw_interface_set_mpls_enable_reply) \
5020 _(sw_interface_set_vpath_reply) \
5021 _(sw_interface_set_vxlan_bypass_reply) \
5022 _(sw_interface_set_geneve_bypass_reply) \
5023 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5024 _(sw_interface_set_l2_bridge_reply) \
5025 _(sw_interface_set_bond_weight_reply) \
5026 _(bridge_domain_add_del_reply) \
5027 _(sw_interface_set_l2_xconnect_reply) \
5028 _(l2fib_add_del_reply) \
5029 _(l2fib_flush_int_reply) \
5030 _(l2fib_flush_bd_reply) \
5031 _(ip_route_add_del_reply) \
5032 _(ip_table_add_del_reply) \
5033 _(ip_table_replace_begin_reply) \
5034 _(ip_table_flush_reply) \
5035 _(ip_table_replace_end_reply) \
5036 _(ip_mroute_add_del_reply) \
5037 _(mpls_route_add_del_reply) \
5038 _(mpls_table_add_del_reply) \
5039 _(mpls_ip_bind_unbind_reply) \
5040 _(bier_route_add_del_reply) \
5041 _(bier_table_add_del_reply) \
5042 _(sw_interface_set_unnumbered_reply) \
5043 _(set_ip_flow_hash_reply) \
5044 _(sw_interface_ip6_enable_disable_reply) \
5045 _(l2_patch_add_del_reply) \
5046 _(sr_mpls_policy_add_reply) \
5047 _(sr_mpls_policy_mod_reply) \
5048 _(sr_mpls_policy_del_reply) \
5049 _(sr_policy_add_reply) \
5050 _(sr_policy_mod_reply) \
5051 _(sr_policy_del_reply) \
5052 _(sr_localsid_add_del_reply) \
5053 _(sr_steering_add_del_reply) \
5054 _(classify_add_del_session_reply) \
5055 _(classify_set_interface_ip_table_reply) \
5056 _(classify_set_interface_l2_tables_reply) \
5057 _(l2tpv3_set_tunnel_cookies_reply) \
5058 _(l2tpv3_interface_enable_disable_reply) \
5059 _(l2tpv3_set_lookup_key_reply) \
5060 _(l2_fib_clear_table_reply) \
5061 _(l2_interface_efp_filter_reply) \
5062 _(l2_interface_vlan_tag_rewrite_reply) \
5063 _(modify_vhost_user_if_reply) \
5064 _(delete_vhost_user_if_reply) \
5065 _(want_l2_macs_events_reply) \
5066 _(input_acl_set_interface_reply) \
5067 _(ipsec_spd_add_del_reply) \
5068 _(ipsec_interface_add_del_spd_reply) \
5069 _(ipsec_spd_entry_add_del_reply) \
5070 _(ipsec_sad_entry_add_del_reply) \
5071 _(ipsec_tunnel_if_add_del_reply) \
5072 _(ipsec_tunnel_if_set_sa_reply) \
5073 _(delete_loopback_reply) \
5074 _(bd_ip_mac_add_del_reply) \
5075 _(bd_ip_mac_flush_reply) \
5076 _(want_interface_events_reply) \
5077 _(cop_interface_enable_disable_reply) \
5078 _(cop_whitelist_enable_disable_reply) \
5079 _(sw_interface_clear_stats_reply) \
5080 _(ioam_enable_reply) \
5081 _(ioam_disable_reply) \
5082 _(one_add_del_locator_reply) \
5083 _(one_add_del_local_eid_reply) \
5084 _(one_add_del_remote_mapping_reply) \
5085 _(one_add_del_adjacency_reply) \
5086 _(one_add_del_map_resolver_reply) \
5087 _(one_add_del_map_server_reply) \
5088 _(one_enable_disable_reply) \
5089 _(one_rloc_probe_enable_disable_reply) \
5090 _(one_map_register_enable_disable_reply) \
5091 _(one_map_register_set_ttl_reply) \
5092 _(one_set_transport_protocol_reply) \
5093 _(one_map_register_fallback_threshold_reply) \
5094 _(one_pitr_set_locator_set_reply) \
5095 _(one_map_request_mode_reply) \
5096 _(one_add_del_map_request_itr_rlocs_reply) \
5097 _(one_eid_table_add_del_map_reply) \
5098 _(one_use_petr_reply) \
5099 _(one_stats_enable_disable_reply) \
5100 _(one_add_del_l2_arp_entry_reply) \
5101 _(one_add_del_ndp_entry_reply) \
5102 _(one_stats_flush_reply) \
5103 _(one_enable_disable_xtr_mode_reply) \
5104 _(one_enable_disable_pitr_mode_reply) \
5105 _(one_enable_disable_petr_mode_reply) \
5106 _(gpe_enable_disable_reply) \
5107 _(gpe_set_encap_mode_reply) \
5108 _(gpe_add_del_iface_reply) \
5109 _(gpe_add_del_native_fwd_rpath_reply) \
5110 _(af_packet_delete_reply) \
5111 _(policer_classify_set_interface_reply) \
5112 _(set_ipfix_exporter_reply) \
5113 _(set_ipfix_classify_stream_reply) \
5114 _(ipfix_classify_table_add_del_reply) \
5115 _(flow_classify_set_interface_reply) \
5116 _(sw_interface_span_enable_disable_reply) \
5117 _(pg_capture_reply) \
5118 _(pg_enable_disable_reply) \
5119 _(ip_source_and_port_range_check_add_del_reply) \
5120 _(ip_source_and_port_range_check_interface_add_del_reply)\
5121 _(delete_subif_reply) \
5122 _(l2_interface_pbb_tag_rewrite_reply) \
5124 _(feature_enable_disable_reply) \
5125 _(feature_gso_enable_disable_reply) \
5126 _(sw_interface_tag_add_del_reply) \
5127 _(sw_interface_add_del_mac_address_reply) \
5128 _(hw_interface_set_mtu_reply) \
5129 _(p2p_ethernet_add_reply) \
5130 _(p2p_ethernet_del_reply) \
5131 _(lldp_config_reply) \
5132 _(sw_interface_set_lldp_reply) \
5133 _(tcp_configure_src_addresses_reply) \
5134 _(session_rule_add_del_reply) \
5135 _(ip_container_proxy_add_del_reply) \
5136 _(output_acl_set_interface_reply) \
5137 _(qos_record_enable_disable_reply)
5140 static void vl_api_##n##_t_handler \
5141 (vl_api_##n##_t * mp) \
5143 vat_main_t * vam = &vat_main; \
5144 i32 retval = ntohl(mp->retval); \
5145 if (vam->async_mode) { \
5146 vam->async_errors += (retval < 0); \
5148 vam->retval = retval; \
5149 vam->result_ready = 1; \
5152 foreach_standard_reply_retval_handler;
5156 static void vl_api_##n##_t_handler_json \
5157 (vl_api_##n##_t * mp) \
5159 vat_main_t * vam = &vat_main; \
5160 vat_json_node_t node; \
5161 vat_json_init_object(&node); \
5162 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5163 vat_json_print(vam->ofp, &node); \
5164 vam->retval = ntohl(mp->retval); \
5165 vam->result_ready = 1; \
5167 foreach_standard_reply_retval_handler;
5171 * Table of message reply handlers, must include boilerplate handlers
5175 #define foreach_vpe_api_reply_msg \
5176 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5177 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5178 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5179 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5180 _(CONTROL_PING_REPLY, control_ping_reply) \
5181 _(CLI_REPLY, cli_reply) \
5182 _(CLI_INBAND_REPLY, cli_inband_reply) \
5183 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5184 sw_interface_add_del_address_reply) \
5185 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5186 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5187 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5188 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5189 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5190 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5191 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5192 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5193 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5194 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5195 sw_interface_set_l2_xconnect_reply) \
5196 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5197 sw_interface_set_l2_bridge_reply) \
5198 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5199 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5200 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5201 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5202 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5203 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5204 _(L2_FLAGS_REPLY, l2_flags_reply) \
5205 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5206 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5207 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5208 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5209 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5210 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5211 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5212 _(BOND_CREATE_REPLY, bond_create_reply) \
5213 _(BOND_DELETE_REPLY, bond_delete_reply) \
5214 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5215 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5216 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5217 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5218 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5219 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5220 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5221 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5222 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5223 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5224 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5225 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5226 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5227 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5228 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5229 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5230 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5231 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5232 sw_interface_set_unnumbered_reply) \
5233 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5234 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5235 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5236 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5237 sw_interface_ip6_enable_disable_reply) \
5238 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5239 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5240 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5241 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5242 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5243 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5244 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5245 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5246 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5247 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5248 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5249 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5250 classify_set_interface_ip_table_reply) \
5251 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5252 classify_set_interface_l2_tables_reply) \
5253 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5254 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5255 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5256 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5257 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5258 l2tpv3_interface_enable_disable_reply) \
5259 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5260 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5261 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5262 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5263 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5264 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5265 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5266 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5267 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5268 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5269 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5270 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5271 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5272 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5273 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5274 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5275 _(SHOW_VERSION_REPLY, show_version_reply) \
5276 _(SHOW_THREADS_REPLY, show_threads_reply) \
5277 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5278 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5279 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5280 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5281 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5282 _(L2_MACS_EVENT, l2_macs_event) \
5283 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5284 _(IP_ADDRESS_DETAILS, ip_address_details) \
5285 _(IP_DETAILS, ip_details) \
5286 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5287 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5288 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5289 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5290 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5291 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5292 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5293 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5294 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5295 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5296 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5297 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5298 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5299 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5300 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5301 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5302 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5303 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5304 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5305 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5306 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5307 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5308 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5309 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5310 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5311 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5312 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5313 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5314 one_map_register_enable_disable_reply) \
5315 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5316 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5317 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5318 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5319 one_map_register_fallback_threshold_reply) \
5320 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5321 one_rloc_probe_enable_disable_reply) \
5322 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5323 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5324 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5325 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5326 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5327 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5328 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5329 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5330 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5331 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5332 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5333 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5334 _(ONE_STATS_DETAILS, one_stats_details) \
5335 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5336 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5337 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5338 show_one_stats_enable_disable_reply) \
5339 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5340 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5341 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5342 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5343 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5344 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5345 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5346 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5347 one_enable_disable_pitr_mode_reply) \
5348 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5349 one_enable_disable_petr_mode_reply) \
5350 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5351 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5352 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5353 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5354 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5355 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5356 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5357 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5358 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5359 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5360 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5361 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5362 gpe_add_del_native_fwd_rpath_reply) \
5363 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5364 gpe_fwd_entry_path_details) \
5365 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5366 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5367 one_add_del_map_request_itr_rlocs_reply) \
5368 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5369 one_get_map_request_itr_rlocs_reply) \
5370 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5371 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5372 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5373 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5374 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5375 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5376 show_one_map_register_state_reply) \
5377 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5378 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5379 show_one_map_register_fallback_threshold_reply) \
5380 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5381 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5382 _(AF_PACKET_DETAILS, af_packet_details) \
5383 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5384 _(POLICER_DETAILS, policer_details) \
5385 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5386 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5387 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5388 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5389 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5390 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5391 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5392 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5393 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5394 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5395 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5396 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5397 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5398 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5399 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5400 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5401 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5402 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5403 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5404 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5405 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5406 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5407 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5408 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5409 ip_source_and_port_range_check_add_del_reply) \
5410 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5411 ip_source_and_port_range_check_interface_add_del_reply) \
5412 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5413 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5414 _(SET_PUNT_REPLY, set_punt_reply) \
5415 _(IP_TABLE_DETAILS, ip_table_details) \
5416 _(IP_ROUTE_DETAILS, ip_route_details) \
5417 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5418 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5419 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5420 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5421 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5422 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5423 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5424 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5425 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5426 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5427 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5428 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5429 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5430 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5431 _(SESSION_RULES_DETAILS, session_rules_details) \
5432 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5433 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5434 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5436 #define foreach_standalone_reply_msg \
5437 _(SW_INTERFACE_EVENT, sw_interface_event)
5445 #define STR_VTR_OP_CASE(op) \
5446 case L2_VTR_ ## op: \
5450 str_vtr_op (u32 vtr_op)
5454 STR_VTR_OP_CASE (DISABLED);
5455 STR_VTR_OP_CASE (PUSH_1);
5456 STR_VTR_OP_CASE (PUSH_2);
5457 STR_VTR_OP_CASE (POP_1);
5458 STR_VTR_OP_CASE (POP_2);
5459 STR_VTR_OP_CASE (TRANSLATE_1_1);
5460 STR_VTR_OP_CASE (TRANSLATE_1_2);
5461 STR_VTR_OP_CASE (TRANSLATE_2_1);
5462 STR_VTR_OP_CASE (TRANSLATE_2_2);
5469 dump_sub_interface_table (vat_main_t * vam)
5471 const sw_interface_subif_t *sub = NULL;
5473 if (vam->json_output)
5476 ("JSON output supported only for VPE API calls and dump_stats_table");
5481 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5482 "Interface", "sw_if_index",
5483 "sub id", "dot1ad", "tags", "outer id",
5484 "inner id", "exact", "default", "outer any", "inner any");
5486 vec_foreach (sub, vam->sw_if_subif_table)
5489 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5490 sub->interface_name,
5492 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5493 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5494 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5495 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5496 if (sub->vtr_op != L2_VTR_DISABLED)
5499 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5500 "tag1: %d tag2: %d ]",
5501 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5502 sub->vtr_tag1, sub->vtr_tag2);
5510 name_sort_cmp (void *a1, void *a2)
5512 name_sort_t *n1 = a1;
5513 name_sort_t *n2 = a2;
5515 return strcmp ((char *) n1->name, (char *) n2->name);
5519 dump_interface_table (vat_main_t * vam)
5522 name_sort_t *nses = 0, *ns;
5524 if (vam->json_output)
5527 ("JSON output supported only for VPE API calls and dump_stats_table");
5532 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5534 vec_add2 (nses, ns, 1);
5535 ns->name = (u8 *)(p->key);
5536 ns->value = (u32) p->value[0];
5540 vec_sort_with_function (nses, name_sort_cmp);
5542 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5543 vec_foreach (ns, nses)
5545 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5552 dump_ip_table (vat_main_t * vam, int is_ipv6)
5554 const ip_details_t *det = NULL;
5555 const ip_address_details_t *address = NULL;
5558 print (vam->ofp, "%-12s", "sw_if_index");
5560 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5567 print (vam->ofp, "%-12d", i);
5568 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5573 vec_foreach (address, det->addr)
5577 is_ipv6 ? format_ip6_address : format_ip4_address,
5578 address->ip, address->prefix_length);
5586 dump_ipv4_table (vat_main_t * vam)
5588 if (vam->json_output)
5591 ("JSON output supported only for VPE API calls and dump_stats_table");
5595 return dump_ip_table (vam, 0);
5599 dump_ipv6_table (vat_main_t * vam)
5601 if (vam->json_output)
5604 ("JSON output supported only for VPE API calls and dump_stats_table");
5608 return dump_ip_table (vam, 1);
5612 * Pass CLI buffers directly in the CLI_INBAND API message,
5613 * instead of an additional shared memory area.
5616 exec_inband (vat_main_t * vam)
5618 vl_api_cli_inband_t *mp;
5619 unformat_input_t *i = vam->input;
5622 if (vec_len (i->buffer) == 0)
5625 if (vam->exec_mode == 0 && unformat (i, "mode"))
5630 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5637 * In order for the CLI command to work, it
5638 * must be a vector ending in \n, not a C-string ending
5641 u32 len = vec_len (vam->input->buffer);
5642 M2 (CLI_INBAND, mp, len);
5643 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5647 /* json responses may or may not include a useful reply... */
5648 if (vec_len (vam->cmd_reply))
5649 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5654 exec (vat_main_t * vam)
5656 return exec_inband (vam);
5660 api_create_loopback (vat_main_t * vam)
5662 unformat_input_t *i = vam->input;
5663 vl_api_create_loopback_t *mp;
5664 vl_api_create_loopback_instance_t *mp_lbi;
5667 u8 is_specified = 0;
5668 u32 user_instance = 0;
5671 clib_memset (mac_address, 0, sizeof (mac_address));
5673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5675 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5677 if (unformat (i, "instance %d", &user_instance))
5685 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5686 mp_lbi->is_specified = is_specified;
5688 mp_lbi->user_instance = htonl (user_instance);
5690 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5695 /* Construct the API message */
5696 M (CREATE_LOOPBACK, mp);
5698 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5707 api_delete_loopback (vat_main_t * vam)
5709 unformat_input_t *i = vam->input;
5710 vl_api_delete_loopback_t *mp;
5711 u32 sw_if_index = ~0;
5714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5716 if (unformat (i, "sw_if_index %d", &sw_if_index))
5722 if (sw_if_index == ~0)
5724 errmsg ("missing sw_if_index");
5728 /* Construct the API message */
5729 M (DELETE_LOOPBACK, mp);
5730 mp->sw_if_index = ntohl (sw_if_index);
5738 api_want_interface_events (vat_main_t * vam)
5740 unformat_input_t *i = vam->input;
5741 vl_api_want_interface_events_t *mp;
5745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5747 if (unformat (i, "enable"))
5749 else if (unformat (i, "disable"))
5757 errmsg ("missing enable|disable");
5761 M (WANT_INTERFACE_EVENTS, mp);
5762 mp->enable_disable = enable;
5764 vam->interface_event_display = enable;
5772 /* Note: non-static, called once to set up the initial intfc table */
5774 api_sw_interface_dump (vat_main_t * vam)
5776 vl_api_sw_interface_dump_t *mp;
5777 vl_api_control_ping_t *mp_ping;
5779 name_sort_t *nses = 0, *ns;
5780 sw_interface_subif_t *sub = NULL;
5783 /* Toss the old name table */
5785 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5787 vec_add2 (nses, ns, 1);
5788 ns->name = (u8 *)(p->key);
5789 ns->value = (u32) p->value[0];
5793 hash_free (vam->sw_if_index_by_interface_name);
5795 vec_foreach (ns, nses) vec_free (ns->name);
5799 vec_foreach (sub, vam->sw_if_subif_table)
5801 vec_free (sub->interface_name);
5803 vec_free (vam->sw_if_subif_table);
5805 /* recreate the interface name hash table */
5806 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5809 * Ask for all interface names. Otherwise, the epic catalog of
5810 * name filters becomes ridiculously long, and vat ends up needing
5811 * to be taught about new interface types.
5813 M (SW_INTERFACE_DUMP, mp);
5816 /* Use a control ping for synchronization */
5817 MPING (CONTROL_PING, mp_ping);
5825 api_sw_interface_set_flags (vat_main_t * vam)
5827 unformat_input_t *i = vam->input;
5828 vl_api_sw_interface_set_flags_t *mp;
5830 u8 sw_if_index_set = 0;
5834 /* Parse args required to build the message */
5835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5837 if (unformat (i, "admin-up"))
5839 else if (unformat (i, "admin-down"))
5842 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5843 sw_if_index_set = 1;
5844 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5845 sw_if_index_set = 1;
5850 if (sw_if_index_set == 0)
5852 errmsg ("missing interface name or sw_if_index");
5856 /* Construct the API message */
5857 M (SW_INTERFACE_SET_FLAGS, mp);
5858 mp->sw_if_index = ntohl (sw_if_index);
5859 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5864 /* Wait for a reply, return the good/bad news... */
5870 api_sw_interface_set_rx_mode (vat_main_t * vam)
5872 unformat_input_t *i = vam->input;
5873 vl_api_sw_interface_set_rx_mode_t *mp;
5875 u8 sw_if_index_set = 0;
5877 u8 queue_id_valid = 0;
5879 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5881 /* Parse args required to build the message */
5882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5884 if (unformat (i, "queue %d", &queue_id))
5886 else if (unformat (i, "polling"))
5887 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5888 else if (unformat (i, "interrupt"))
5889 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5890 else if (unformat (i, "adaptive"))
5891 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5893 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5894 sw_if_index_set = 1;
5895 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5896 sw_if_index_set = 1;
5901 if (sw_if_index_set == 0)
5903 errmsg ("missing interface name or sw_if_index");
5906 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5908 errmsg ("missing rx-mode");
5912 /* Construct the API message */
5913 M (SW_INTERFACE_SET_RX_MODE, mp);
5914 mp->sw_if_index = ntohl (sw_if_index);
5915 mp->mode = (vl_api_rx_mode_t) mode;
5916 mp->queue_id_valid = queue_id_valid;
5917 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5922 /* Wait for a reply, return the good/bad news... */
5928 api_sw_interface_set_rx_placement (vat_main_t * vam)
5930 unformat_input_t *i = vam->input;
5931 vl_api_sw_interface_set_rx_placement_t *mp;
5933 u8 sw_if_index_set = 0;
5936 u32 queue_id, thread_index;
5938 /* Parse args required to build the message */
5939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5941 if (unformat (i, "queue %d", &queue_id))
5943 else if (unformat (i, "main"))
5945 else if (unformat (i, "worker %d", &thread_index))
5948 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5949 sw_if_index_set = 1;
5950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5951 sw_if_index_set = 1;
5956 if (sw_if_index_set == 0)
5958 errmsg ("missing interface name or sw_if_index");
5964 /* Construct the API message */
5965 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5966 mp->sw_if_index = ntohl (sw_if_index);
5967 mp->worker_id = ntohl (thread_index);
5968 mp->queue_id = ntohl (queue_id);
5969 mp->is_main = is_main;
5973 /* Wait for a reply, return the good/bad news... */
5978 static void vl_api_sw_interface_rx_placement_details_t_handler
5979 (vl_api_sw_interface_rx_placement_details_t * mp)
5981 vat_main_t *vam = &vat_main;
5982 u32 worker_id = ntohl (mp->worker_id);
5985 "\n%-11d %-11s %-6d %-5d %-9s",
5986 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
5987 worker_id, ntohl (mp->queue_id),
5989 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
5992 static void vl_api_sw_interface_rx_placement_details_t_handler_json
5993 (vl_api_sw_interface_rx_placement_details_t * mp)
5995 vat_main_t *vam = &vat_main;
5996 vat_json_node_t *node = NULL;
5998 if (VAT_JSON_ARRAY != vam->json_tree.type)
6000 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6001 vat_json_init_array (&vam->json_tree);
6003 node = vat_json_array_add (&vam->json_tree);
6005 vat_json_init_object (node);
6006 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6007 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6008 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6009 vat_json_object_add_uint (node, "mode", mp->mode);
6013 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6015 unformat_input_t *i = vam->input;
6016 vl_api_sw_interface_rx_placement_dump_t *mp;
6017 vl_api_control_ping_t *mp_ping;
6020 u8 sw_if_index_set = 0;
6022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6024 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6026 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6033 "\n%-11s %-11s %-6s %-5s %-4s",
6034 "sw_if_index", "main/worker", "thread", "queue", "mode");
6036 /* Dump Interface rx placement */
6037 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6039 if (sw_if_index_set)
6040 mp->sw_if_index = htonl (sw_if_index);
6042 mp->sw_if_index = ~0;
6046 /* Use a control ping for synchronization */
6047 MPING (CONTROL_PING, mp_ping);
6055 api_sw_interface_clear_stats (vat_main_t * vam)
6057 unformat_input_t *i = vam->input;
6058 vl_api_sw_interface_clear_stats_t *mp;
6060 u8 sw_if_index_set = 0;
6063 /* Parse args required to build the message */
6064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6066 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6067 sw_if_index_set = 1;
6068 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6069 sw_if_index_set = 1;
6074 /* Construct the API message */
6075 M (SW_INTERFACE_CLEAR_STATS, mp);
6077 if (sw_if_index_set == 1)
6078 mp->sw_if_index = ntohl (sw_if_index);
6080 mp->sw_if_index = ~0;
6085 /* Wait for a reply, return the good/bad news... */
6091 api_sw_interface_add_del_address (vat_main_t * vam)
6093 unformat_input_t *i = vam->input;
6094 vl_api_sw_interface_add_del_address_t *mp;
6096 u8 sw_if_index_set = 0;
6097 u8 is_add = 1, del_all = 0;
6098 u32 address_length = 0;
6099 u8 v4_address_set = 0;
6100 u8 v6_address_set = 0;
6101 ip4_address_t v4address;
6102 ip6_address_t v6address;
6105 /* Parse args required to build the message */
6106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6108 if (unformat (i, "del-all"))
6110 else if (unformat (i, "del"))
6113 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6114 sw_if_index_set = 1;
6115 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6116 sw_if_index_set = 1;
6117 else if (unformat (i, "%U/%d",
6118 unformat_ip4_address, &v4address, &address_length))
6120 else if (unformat (i, "%U/%d",
6121 unformat_ip6_address, &v6address, &address_length))
6127 if (sw_if_index_set == 0)
6129 errmsg ("missing interface name or sw_if_index");
6132 if (v4_address_set && v6_address_set)
6134 errmsg ("both v4 and v6 addresses set");
6137 if (!v4_address_set && !v6_address_set && !del_all)
6139 errmsg ("no addresses set");
6143 /* Construct the API message */
6144 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6146 mp->sw_if_index = ntohl (sw_if_index);
6147 mp->is_add = is_add;
6148 mp->del_all = del_all;
6151 mp->prefix.address.af = ADDRESS_IP6;
6152 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6156 mp->prefix.address.af = ADDRESS_IP4;
6157 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6159 mp->prefix.len = address_length;
6164 /* Wait for a reply, return good/bad news */
6170 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6172 unformat_input_t *i = vam->input;
6173 vl_api_sw_interface_set_mpls_enable_t *mp;
6175 u8 sw_if_index_set = 0;
6179 /* Parse args required to build the message */
6180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6182 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6183 sw_if_index_set = 1;
6184 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6185 sw_if_index_set = 1;
6186 else if (unformat (i, "disable"))
6188 else if (unformat (i, "dis"))
6194 if (sw_if_index_set == 0)
6196 errmsg ("missing interface name or sw_if_index");
6200 /* Construct the API message */
6201 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6203 mp->sw_if_index = ntohl (sw_if_index);
6204 mp->enable = enable;
6209 /* Wait for a reply... */
6215 api_sw_interface_set_table (vat_main_t * vam)
6217 unformat_input_t *i = vam->input;
6218 vl_api_sw_interface_set_table_t *mp;
6219 u32 sw_if_index, vrf_id = 0;
6220 u8 sw_if_index_set = 0;
6224 /* Parse args required to build the message */
6225 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6227 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6228 sw_if_index_set = 1;
6229 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6230 sw_if_index_set = 1;
6231 else if (unformat (i, "vrf %d", &vrf_id))
6233 else if (unformat (i, "ipv6"))
6239 if (sw_if_index_set == 0)
6241 errmsg ("missing interface name or sw_if_index");
6245 /* Construct the API message */
6246 M (SW_INTERFACE_SET_TABLE, mp);
6248 mp->sw_if_index = ntohl (sw_if_index);
6249 mp->is_ipv6 = is_ipv6;
6250 mp->vrf_id = ntohl (vrf_id);
6255 /* Wait for a reply... */
6260 static void vl_api_sw_interface_get_table_reply_t_handler
6261 (vl_api_sw_interface_get_table_reply_t * mp)
6263 vat_main_t *vam = &vat_main;
6265 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6267 vam->retval = ntohl (mp->retval);
6268 vam->result_ready = 1;
6272 static void vl_api_sw_interface_get_table_reply_t_handler_json
6273 (vl_api_sw_interface_get_table_reply_t * mp)
6275 vat_main_t *vam = &vat_main;
6276 vat_json_node_t node;
6278 vat_json_init_object (&node);
6279 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6280 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6282 vat_json_print (vam->ofp, &node);
6283 vat_json_free (&node);
6285 vam->retval = ntohl (mp->retval);
6286 vam->result_ready = 1;
6290 api_sw_interface_get_table (vat_main_t * vam)
6292 unformat_input_t *i = vam->input;
6293 vl_api_sw_interface_get_table_t *mp;
6295 u8 sw_if_index_set = 0;
6299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6301 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6302 sw_if_index_set = 1;
6303 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6304 sw_if_index_set = 1;
6305 else if (unformat (i, "ipv6"))
6311 if (sw_if_index_set == 0)
6313 errmsg ("missing interface name or sw_if_index");
6317 M (SW_INTERFACE_GET_TABLE, mp);
6318 mp->sw_if_index = htonl (sw_if_index);
6319 mp->is_ipv6 = is_ipv6;
6327 api_sw_interface_set_vpath (vat_main_t * vam)
6329 unformat_input_t *i = vam->input;
6330 vl_api_sw_interface_set_vpath_t *mp;
6331 u32 sw_if_index = 0;
6332 u8 sw_if_index_set = 0;
6336 /* Parse args required to build the message */
6337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6340 sw_if_index_set = 1;
6341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6342 sw_if_index_set = 1;
6343 else if (unformat (i, "enable"))
6345 else if (unformat (i, "disable"))
6351 if (sw_if_index_set == 0)
6353 errmsg ("missing interface name or sw_if_index");
6357 /* Construct the API message */
6358 M (SW_INTERFACE_SET_VPATH, mp);
6360 mp->sw_if_index = ntohl (sw_if_index);
6361 mp->enable = is_enable;
6366 /* Wait for a reply... */
6372 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6374 unformat_input_t *i = vam->input;
6375 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6376 u32 sw_if_index = 0;
6377 u8 sw_if_index_set = 0;
6382 /* Parse args required to build the message */
6383 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6385 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6386 sw_if_index_set = 1;
6387 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6388 sw_if_index_set = 1;
6389 else if (unformat (i, "enable"))
6391 else if (unformat (i, "disable"))
6393 else if (unformat (i, "ip4"))
6395 else if (unformat (i, "ip6"))
6401 if (sw_if_index_set == 0)
6403 errmsg ("missing interface name or sw_if_index");
6407 /* Construct the API message */
6408 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6410 mp->sw_if_index = ntohl (sw_if_index);
6411 mp->enable = is_enable;
6412 mp->is_ipv6 = is_ipv6;
6417 /* Wait for a reply... */
6423 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6425 unformat_input_t *i = vam->input;
6426 vl_api_sw_interface_set_geneve_bypass_t *mp;
6427 u32 sw_if_index = 0;
6428 u8 sw_if_index_set = 0;
6433 /* Parse args required to build the message */
6434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6436 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6437 sw_if_index_set = 1;
6438 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6439 sw_if_index_set = 1;
6440 else if (unformat (i, "enable"))
6442 else if (unformat (i, "disable"))
6444 else if (unformat (i, "ip4"))
6446 else if (unformat (i, "ip6"))
6452 if (sw_if_index_set == 0)
6454 errmsg ("missing interface name or sw_if_index");
6458 /* Construct the API message */
6459 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6461 mp->sw_if_index = ntohl (sw_if_index);
6462 mp->enable = is_enable;
6463 mp->is_ipv6 = is_ipv6;
6468 /* Wait for a reply... */
6474 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6476 unformat_input_t *i = vam->input;
6477 vl_api_sw_interface_set_l2_xconnect_t *mp;
6479 u8 rx_sw_if_index_set = 0;
6481 u8 tx_sw_if_index_set = 0;
6485 /* Parse args required to build the message */
6486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6488 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6489 rx_sw_if_index_set = 1;
6490 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6491 tx_sw_if_index_set = 1;
6492 else if (unformat (i, "rx"))
6494 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6496 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6498 rx_sw_if_index_set = 1;
6503 else if (unformat (i, "tx"))
6505 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6507 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6509 tx_sw_if_index_set = 1;
6514 else if (unformat (i, "enable"))
6516 else if (unformat (i, "disable"))
6522 if (rx_sw_if_index_set == 0)
6524 errmsg ("missing rx interface name or rx_sw_if_index");
6528 if (enable && (tx_sw_if_index_set == 0))
6530 errmsg ("missing tx interface name or tx_sw_if_index");
6534 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6536 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6537 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6538 mp->enable = enable;
6546 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6548 unformat_input_t *i = vam->input;
6549 vl_api_sw_interface_set_l2_bridge_t *mp;
6550 vl_api_l2_port_type_t port_type;
6552 u8 rx_sw_if_index_set = 0;
6559 port_type = L2_API_PORT_TYPE_NORMAL;
6561 /* Parse args required to build the message */
6562 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6564 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6565 rx_sw_if_index_set = 1;
6566 else if (unformat (i, "bd_id %d", &bd_id))
6570 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6571 rx_sw_if_index_set = 1;
6572 else if (unformat (i, "shg %d", &shg))
6574 else if (unformat (i, "bvi"))
6575 port_type = L2_API_PORT_TYPE_BVI;
6576 else if (unformat (i, "uu-fwd"))
6577 port_type = L2_API_PORT_TYPE_UU_FWD;
6578 else if (unformat (i, "enable"))
6580 else if (unformat (i, "disable"))
6586 if (rx_sw_if_index_set == 0)
6588 errmsg ("missing rx interface name or sw_if_index");
6592 if (enable && (bd_id_set == 0))
6594 errmsg ("missing bridge domain");
6598 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6600 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6601 mp->bd_id = ntohl (bd_id);
6603 mp->port_type = ntohl (port_type);
6604 mp->enable = enable;
6612 api_bridge_domain_dump (vat_main_t * vam)
6614 unformat_input_t *i = vam->input;
6615 vl_api_bridge_domain_dump_t *mp;
6616 vl_api_control_ping_t *mp_ping;
6620 /* Parse args required to build the message */
6621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6623 if (unformat (i, "bd_id %d", &bd_id))
6629 M (BRIDGE_DOMAIN_DUMP, mp);
6630 mp->bd_id = ntohl (bd_id);
6633 /* Use a control ping for synchronization */
6634 MPING (CONTROL_PING, mp_ping);
6642 api_bridge_domain_add_del (vat_main_t * vam)
6644 unformat_input_t *i = vam->input;
6645 vl_api_bridge_domain_add_del_t *mp;
6648 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6653 /* Parse args required to build the message */
6654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6656 if (unformat (i, "bd_id %d", &bd_id))
6658 else if (unformat (i, "flood %d", &flood))
6660 else if (unformat (i, "uu-flood %d", &uu_flood))
6662 else if (unformat (i, "forward %d", &forward))
6664 else if (unformat (i, "learn %d", &learn))
6666 else if (unformat (i, "arp-term %d", &arp_term))
6668 else if (unformat (i, "mac-age %d", &mac_age))
6670 else if (unformat (i, "bd-tag %s", &bd_tag))
6672 else if (unformat (i, "del"))
6675 flood = uu_flood = forward = learn = 0;
6683 errmsg ("missing bridge domain");
6690 errmsg ("mac age must be less than 256 ");
6695 if ((bd_tag) && (vec_len (bd_tag) > 63))
6697 errmsg ("bd-tag cannot be longer than 63");
6702 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6704 mp->bd_id = ntohl (bd_id);
6706 mp->uu_flood = uu_flood;
6707 mp->forward = forward;
6709 mp->arp_term = arp_term;
6710 mp->is_add = is_add;
6711 mp->mac_age = (u8) mac_age;
6714 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6715 mp->bd_tag[vec_len (bd_tag)] = 0;
6726 api_l2fib_flush_bd (vat_main_t * vam)
6728 unformat_input_t *i = vam->input;
6729 vl_api_l2fib_flush_bd_t *mp;
6733 /* Parse args required to build the message */
6734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6736 if (unformat (i, "bd_id %d", &bd_id));
6743 errmsg ("missing bridge domain");
6747 M (L2FIB_FLUSH_BD, mp);
6749 mp->bd_id = htonl (bd_id);
6757 api_l2fib_flush_int (vat_main_t * vam)
6759 unformat_input_t *i = vam->input;
6760 vl_api_l2fib_flush_int_t *mp;
6761 u32 sw_if_index = ~0;
6764 /* Parse args required to build the message */
6765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6767 if (unformat (i, "sw_if_index %d", &sw_if_index));
6769 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6774 if (sw_if_index == ~0)
6776 errmsg ("missing interface name or sw_if_index");
6780 M (L2FIB_FLUSH_INT, mp);
6782 mp->sw_if_index = ntohl (sw_if_index);
6790 api_l2fib_add_del (vat_main_t * vam)
6792 unformat_input_t *i = vam->input;
6793 vl_api_l2fib_add_del_t *mp;
6799 u32 sw_if_index = 0;
6800 u8 sw_if_index_set = 0;
6809 /* Parse args required to build the message */
6810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6812 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6814 else if (unformat (i, "bd_id %d", &bd_id))
6816 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6817 sw_if_index_set = 1;
6818 else if (unformat (i, "sw_if"))
6820 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6823 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6824 sw_if_index_set = 1;
6829 else if (unformat (i, "static"))
6831 else if (unformat (i, "filter"))
6836 else if (unformat (i, "bvi"))
6841 else if (unformat (i, "del"))
6843 else if (unformat (i, "count %d", &count))
6851 errmsg ("missing mac address");
6857 errmsg ("missing bridge domain");
6861 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6863 errmsg ("missing interface name or sw_if_index");
6869 /* Turn on async mode */
6870 vam->async_mode = 1;
6871 vam->async_errors = 0;
6872 before = vat_time_now (vam);
6875 for (j = 0; j < count; j++)
6877 M (L2FIB_ADD_DEL, mp);
6879 clib_memcpy (mp->mac, mac, 6);
6880 mp->bd_id = ntohl (bd_id);
6881 mp->is_add = is_add;
6882 mp->sw_if_index = ntohl (sw_if_index);
6886 mp->static_mac = static_mac;
6887 mp->filter_mac = filter_mac;
6888 mp->bvi_mac = bvi_mac;
6890 increment_mac_address (mac);
6897 vl_api_control_ping_t *mp_ping;
6900 /* Shut off async mode */
6901 vam->async_mode = 0;
6903 MPING (CONTROL_PING, mp_ping);
6906 timeout = vat_time_now (vam) + 1.0;
6907 while (vat_time_now (vam) < timeout)
6908 if (vam->result_ready == 1)
6913 if (vam->retval == -99)
6916 if (vam->async_errors > 0)
6918 errmsg ("%d asynchronous errors", vam->async_errors);
6921 vam->async_errors = 0;
6922 after = vat_time_now (vam);
6924 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6925 count, after - before, count / (after - before));
6931 /* Wait for a reply... */
6935 /* Return the good/bad news */
6936 return (vam->retval);
6940 api_bridge_domain_set_mac_age (vat_main_t * vam)
6942 unformat_input_t *i = vam->input;
6943 vl_api_bridge_domain_set_mac_age_t *mp;
6948 /* Parse args required to build the message */
6949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6951 if (unformat (i, "bd_id %d", &bd_id));
6952 else if (unformat (i, "mac-age %d", &mac_age));
6959 errmsg ("missing bridge domain");
6965 errmsg ("mac age must be less than 256 ");
6969 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6971 mp->bd_id = htonl (bd_id);
6972 mp->mac_age = (u8) mac_age;
6980 api_l2_flags (vat_main_t * vam)
6982 unformat_input_t *i = vam->input;
6983 vl_api_l2_flags_t *mp;
6986 u8 sw_if_index_set = 0;
6990 /* Parse args required to build the message */
6991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6993 if (unformat (i, "sw_if_index %d", &sw_if_index))
6994 sw_if_index_set = 1;
6995 else if (unformat (i, "sw_if"))
6997 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7000 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7001 sw_if_index_set = 1;
7006 else if (unformat (i, "learn"))
7008 else if (unformat (i, "forward"))
7010 else if (unformat (i, "flood"))
7012 else if (unformat (i, "uu-flood"))
7013 flags |= L2_UU_FLOOD;
7014 else if (unformat (i, "arp-term"))
7015 flags |= L2_ARP_TERM;
7016 else if (unformat (i, "off"))
7018 else if (unformat (i, "disable"))
7024 if (sw_if_index_set == 0)
7026 errmsg ("missing interface name or sw_if_index");
7032 mp->sw_if_index = ntohl (sw_if_index);
7033 mp->feature_bitmap = ntohl (flags);
7034 mp->is_set = is_set;
7042 api_bridge_flags (vat_main_t * vam)
7044 unformat_input_t *i = vam->input;
7045 vl_api_bridge_flags_t *mp;
7049 bd_flags_t flags = 0;
7052 /* Parse args required to build the message */
7053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7055 if (unformat (i, "bd_id %d", &bd_id))
7057 else if (unformat (i, "learn"))
7058 flags |= BRIDGE_API_FLAG_LEARN;
7059 else if (unformat (i, "forward"))
7060 flags |= BRIDGE_API_FLAG_FWD;
7061 else if (unformat (i, "flood"))
7062 flags |= BRIDGE_API_FLAG_FLOOD;
7063 else if (unformat (i, "uu-flood"))
7064 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7065 else if (unformat (i, "arp-term"))
7066 flags |= BRIDGE_API_FLAG_ARP_TERM;
7067 else if (unformat (i, "off"))
7069 else if (unformat (i, "disable"))
7077 errmsg ("missing bridge domain");
7081 M (BRIDGE_FLAGS, mp);
7083 mp->bd_id = ntohl (bd_id);
7084 mp->flags = ntohl (flags);
7085 mp->is_set = is_set;
7093 api_bd_ip_mac_add_del (vat_main_t * vam)
7095 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7096 vl_api_mac_address_t mac = { 0 };
7097 unformat_input_t *i = vam->input;
7098 vl_api_bd_ip_mac_add_del_t *mp;
7107 /* Parse args required to build the message */
7108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7110 if (unformat (i, "bd_id %d", &bd_id))
7114 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7118 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7122 else if (unformat (i, "del"))
7130 errmsg ("missing bridge domain");
7133 else if (ip_set == 0)
7135 errmsg ("missing IP address");
7138 else if (mac_set == 0)
7140 errmsg ("missing MAC address");
7144 M (BD_IP_MAC_ADD_DEL, mp);
7146 mp->entry.bd_id = ntohl (bd_id);
7147 mp->is_add = is_add;
7149 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7150 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7158 api_bd_ip_mac_flush (vat_main_t * vam)
7160 unformat_input_t *i = vam->input;
7161 vl_api_bd_ip_mac_flush_t *mp;
7166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7168 if (unformat (i, "bd_id %d", &bd_id))
7178 errmsg ("missing bridge domain");
7182 M (BD_IP_MAC_FLUSH, mp);
7184 mp->bd_id = ntohl (bd_id);
7191 static void vl_api_bd_ip_mac_details_t_handler
7192 (vl_api_bd_ip_mac_details_t * mp)
7194 vat_main_t *vam = &vat_main;
7198 ntohl (mp->entry.bd_id),
7199 format_vl_api_mac_address, mp->entry.mac,
7200 format_vl_api_address, &mp->entry.ip);
7203 static void vl_api_bd_ip_mac_details_t_handler_json
7204 (vl_api_bd_ip_mac_details_t * mp)
7206 vat_main_t *vam = &vat_main;
7207 vat_json_node_t *node = NULL;
7209 if (VAT_JSON_ARRAY != vam->json_tree.type)
7211 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7212 vat_json_init_array (&vam->json_tree);
7214 node = vat_json_array_add (&vam->json_tree);
7216 vat_json_init_object (node);
7217 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7218 vat_json_object_add_string_copy (node, "mac_address",
7219 format (0, "%U", format_vl_api_mac_address,
7223 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7224 vat_json_object_add_string_copy (node, "ip_address", ip);
7229 api_bd_ip_mac_dump (vat_main_t * vam)
7231 unformat_input_t *i = vam->input;
7232 vl_api_bd_ip_mac_dump_t *mp;
7233 vl_api_control_ping_t *mp_ping;
7238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7240 if (unformat (i, "bd_id %d", &bd_id))
7249 "\n%-5s %-7s %-20s %-30s",
7250 "bd_id", "is_ipv6", "mac_address", "ip_address");
7252 /* Dump Bridge Domain Ip to Mac entries */
7253 M (BD_IP_MAC_DUMP, mp);
7256 mp->bd_id = htonl (bd_id);
7262 /* Use a control ping for synchronization */
7263 MPING (CONTROL_PING, mp_ping);
7271 api_tap_create_v2 (vat_main_t * vam)
7273 unformat_input_t *i = vam->input;
7274 vl_api_tap_create_v2_t *mp;
7275 #define TAP_FLAG_GSO (1 << 0)
7279 u8 *host_if_name = 0;
7281 u8 host_mac_addr[6];
7282 u8 host_mac_addr_set = 0;
7283 u8 *host_bridge = 0;
7284 ip4_address_t host_ip4_addr;
7285 ip4_address_t host_ip4_gw;
7286 u8 host_ip4_gw_set = 0;
7287 u32 host_ip4_prefix_len = 0;
7288 ip6_address_t host_ip6_addr;
7289 ip6_address_t host_ip6_gw;
7290 u8 host_ip6_gw_set = 0;
7291 u32 host_ip6_prefix_len = 0;
7292 u8 host_mtu_set = 0;
7293 u32 host_mtu_size = 0;
7296 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7298 clib_memset (mac_address, 0, sizeof (mac_address));
7300 /* Parse args required to build the message */
7301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7303 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7307 else if (unformat (i, "id %u", &id))
7309 else if (unformat (i, "host-if-name %s", &host_if_name))
7311 else if (unformat (i, "host-ns %s", &host_ns))
7313 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7315 host_mac_addr_set = 1;
7316 else if (unformat (i, "host-bridge %s", &host_bridge))
7318 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7319 &host_ip4_addr, &host_ip4_prefix_len))
7321 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7322 &host_ip6_addr, &host_ip6_prefix_len))
7324 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7326 host_ip4_gw_set = 1;
7327 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7329 host_ip6_gw_set = 1;
7330 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7332 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7334 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7336 else if (unformat (i, "no-gso"))
7337 tap_flags &= ~TAP_FLAG_GSO;
7338 else if (unformat (i, "gso"))
7339 tap_flags |= TAP_FLAG_GSO;
7340 else if (unformat (i, "csum-offload"))
7341 tap_flags |= TAP_FLAG_CSUM_OFFLOAD;
7346 if (vec_len (host_if_name) > 63)
7348 errmsg ("tap name too long. ");
7351 if (vec_len (host_ns) > 63)
7353 errmsg ("host name space too long. ");
7356 if (vec_len (host_bridge) > 63)
7358 errmsg ("host bridge name too long. ");
7361 if (host_ip4_prefix_len > 32)
7363 errmsg ("host ip4 prefix length not valid. ");
7366 if (host_ip6_prefix_len > 128)
7368 errmsg ("host ip6 prefix length not valid. ");
7371 if (!is_pow2 (rx_ring_sz))
7373 errmsg ("rx ring size must be power of 2. ");
7376 if (rx_ring_sz > 32768)
7378 errmsg ("rx ring size must be 32768 or lower. ");
7381 if (!is_pow2 (tx_ring_sz))
7383 errmsg ("tx ring size must be power of 2. ");
7386 if (tx_ring_sz > 32768)
7388 errmsg ("tx ring size must be 32768 or lower. ");
7391 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7393 errmsg ("host MTU size must be in between 64 and 65355. ");
7397 /* Construct the API message */
7398 M (TAP_CREATE_V2, mp);
7400 mp->use_random_mac = random_mac;
7402 mp->id = ntohl (id);
7403 mp->host_namespace_set = host_ns != 0;
7404 mp->host_bridge_set = host_bridge != 0;
7405 mp->host_ip4_prefix_set = host_ip4_prefix_len != 0;
7406 mp->host_ip6_prefix_set = host_ip6_prefix_len != 0;
7407 mp->rx_ring_sz = ntohs (rx_ring_sz);
7408 mp->tx_ring_sz = ntohs (tx_ring_sz);
7409 mp->host_mtu_set = host_mtu_set;
7410 mp->host_mtu_size = ntohl (host_mtu_size);
7411 mp->tap_flags = ntohl (tap_flags);
7413 if (random_mac == 0)
7414 clib_memcpy (mp->mac_address, mac_address, 6);
7415 if (host_mac_addr_set)
7416 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7418 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7420 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7422 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7423 if (host_ip4_prefix_len)
7424 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7425 if (host_ip6_prefix_len)
7426 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7427 if (host_ip4_gw_set)
7428 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7429 if (host_ip6_gw_set)
7430 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7433 vec_free (host_if_name);
7434 vec_free (host_bridge);
7439 /* Wait for a reply... */
7445 api_tap_delete_v2 (vat_main_t * vam)
7447 unformat_input_t *i = vam->input;
7448 vl_api_tap_delete_v2_t *mp;
7449 u32 sw_if_index = ~0;
7450 u8 sw_if_index_set = 0;
7453 /* Parse args required to build the message */
7454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7456 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7457 sw_if_index_set = 1;
7458 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7459 sw_if_index_set = 1;
7464 if (sw_if_index_set == 0)
7466 errmsg ("missing vpp interface name. ");
7470 /* Construct the API message */
7471 M (TAP_DELETE_V2, mp);
7473 mp->sw_if_index = ntohl (sw_if_index);
7478 /* Wait for a reply... */
7484 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7486 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7489 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7492 addr->domain = x[0];
7495 addr->function = x[3];
7501 api_virtio_pci_create (vat_main_t * vam)
7503 unformat_input_t *i = vam->input;
7504 vl_api_virtio_pci_create_t *mp;
7508 u8 checksum_offload_enabled = 0;
7510 u64 features = (u64) ~ (0ULL);
7513 clib_memset (mac_address, 0, sizeof (mac_address));
7515 /* Parse args required to build the message */
7516 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7518 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7522 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7524 else if (unformat (i, "features 0x%llx", &features))
7526 else if (unformat (i, "gso-enabled"))
7528 else if (unformat (i, "csum-offload-enabled"))
7529 checksum_offload_enabled = 1;
7536 errmsg ("pci address must be non zero. ");
7540 /* Construct the API message */
7541 M (VIRTIO_PCI_CREATE, mp);
7543 mp->use_random_mac = random_mac;
7545 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7546 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7547 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7548 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7550 mp->features = clib_host_to_net_u64 (features);
7551 mp->gso_enabled = gso_enabled;
7552 mp->checksum_offload_enabled = checksum_offload_enabled;
7554 if (random_mac == 0)
7555 clib_memcpy (mp->mac_address, mac_address, 6);
7560 /* Wait for a reply... */
7566 api_virtio_pci_delete (vat_main_t * vam)
7568 unformat_input_t *i = vam->input;
7569 vl_api_virtio_pci_delete_t *mp;
7570 u32 sw_if_index = ~0;
7571 u8 sw_if_index_set = 0;
7574 /* Parse args required to build the message */
7575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7577 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7578 sw_if_index_set = 1;
7579 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7580 sw_if_index_set = 1;
7585 if (sw_if_index_set == 0)
7587 errmsg ("missing vpp interface name. ");
7591 /* Construct the API message */
7592 M (VIRTIO_PCI_DELETE, mp);
7594 mp->sw_if_index = htonl (sw_if_index);
7599 /* Wait for a reply... */
7605 api_bond_create (vat_main_t * vam)
7607 unformat_input_t *i = vam->input;
7608 vl_api_bond_create_t *mp;
7618 clib_memset (mac_address, 0, sizeof (mac_address));
7621 /* Parse args required to build the message */
7622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7624 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7626 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7627 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7629 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7632 else if (unformat (i, "numa-only"))
7634 else if (unformat (i, "id %u", &id))
7640 if (mode_is_set == 0)
7642 errmsg ("Missing bond mode. ");
7646 /* Construct the API message */
7647 M (BOND_CREATE, mp);
7649 mp->use_custom_mac = custom_mac;
7651 mp->mode = htonl (mode);
7652 mp->lb = htonl (lb);
7653 mp->id = htonl (id);
7654 mp->numa_only = numa_only;
7657 clib_memcpy (mp->mac_address, mac_address, 6);
7662 /* Wait for a reply... */
7668 api_bond_delete (vat_main_t * vam)
7670 unformat_input_t *i = vam->input;
7671 vl_api_bond_delete_t *mp;
7672 u32 sw_if_index = ~0;
7673 u8 sw_if_index_set = 0;
7676 /* Parse args required to build the message */
7677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7679 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7680 sw_if_index_set = 1;
7681 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7682 sw_if_index_set = 1;
7687 if (sw_if_index_set == 0)
7689 errmsg ("missing vpp interface name. ");
7693 /* Construct the API message */
7694 M (BOND_DELETE, mp);
7696 mp->sw_if_index = ntohl (sw_if_index);
7701 /* Wait for a reply... */
7707 api_bond_enslave (vat_main_t * vam)
7709 unformat_input_t *i = vam->input;
7710 vl_api_bond_enslave_t *mp;
7711 u32 bond_sw_if_index;
7715 u32 bond_sw_if_index_is_set = 0;
7717 u8 sw_if_index_is_set = 0;
7719 /* Parse args required to build the message */
7720 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7722 if (unformat (i, "sw_if_index %d", &sw_if_index))
7723 sw_if_index_is_set = 1;
7724 else if (unformat (i, "bond %u", &bond_sw_if_index))
7725 bond_sw_if_index_is_set = 1;
7726 else if (unformat (i, "passive %d", &is_passive))
7728 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7734 if (bond_sw_if_index_is_set == 0)
7736 errmsg ("Missing bond sw_if_index. ");
7739 if (sw_if_index_is_set == 0)
7741 errmsg ("Missing slave sw_if_index. ");
7745 /* Construct the API message */
7746 M (BOND_ENSLAVE, mp);
7748 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7749 mp->sw_if_index = ntohl (sw_if_index);
7750 mp->is_long_timeout = is_long_timeout;
7751 mp->is_passive = is_passive;
7756 /* Wait for a reply... */
7762 api_bond_detach_slave (vat_main_t * vam)
7764 unformat_input_t *i = vam->input;
7765 vl_api_bond_detach_slave_t *mp;
7766 u32 sw_if_index = ~0;
7767 u8 sw_if_index_set = 0;
7770 /* Parse args required to build the message */
7771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7773 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7774 sw_if_index_set = 1;
7775 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7776 sw_if_index_set = 1;
7781 if (sw_if_index_set == 0)
7783 errmsg ("missing vpp interface name. ");
7787 /* Construct the API message */
7788 M (BOND_DETACH_SLAVE, mp);
7790 mp->sw_if_index = ntohl (sw_if_index);
7795 /* Wait for a reply... */
7801 api_ip_table_add_del (vat_main_t * vam)
7803 unformat_input_t *i = vam->input;
7804 vl_api_ip_table_add_del_t *mp;
7810 /* Parse args required to build the message */
7811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7813 if (unformat (i, "ipv6"))
7815 else if (unformat (i, "del"))
7817 else if (unformat (i, "add"))
7819 else if (unformat (i, "table %d", &table_id))
7823 clib_warning ("parse error '%U'", format_unformat_error, i);
7830 errmsg ("missing table-ID");
7834 /* Construct the API message */
7835 M (IP_TABLE_ADD_DEL, mp);
7837 mp->table.table_id = ntohl (table_id);
7838 mp->table.is_ip6 = is_ipv6;
7839 mp->is_add = is_add;
7844 /* Wait for a reply... */
7851 unformat_fib_path (unformat_input_t * input, va_list * args)
7853 vat_main_t *vam = va_arg (*args, vat_main_t *);
7854 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7855 u32 weight, preference;
7856 mpls_label_t out_label;
7858 clib_memset (path, 0, sizeof (*path));
7860 path->sw_if_index = ~0;
7864 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7866 if (unformat (input, "%U %U",
7867 unformat_vl_api_ip4_address,
7868 &path->nh.address.ip4,
7869 api_unformat_sw_if_index, vam, &path->sw_if_index))
7871 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7873 else if (unformat (input, "%U %U",
7874 unformat_vl_api_ip6_address,
7875 &path->nh.address.ip6,
7876 api_unformat_sw_if_index, vam, &path->sw_if_index))
7878 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7880 else if (unformat (input, "weight %u", &weight))
7882 path->weight = weight;
7884 else if (unformat (input, "preference %u", &preference))
7886 path->preference = preference;
7888 else if (unformat (input, "%U next-hop-table %d",
7889 unformat_vl_api_ip4_address,
7890 &path->nh.address.ip4, &path->table_id))
7892 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7894 else if (unformat (input, "%U next-hop-table %d",
7895 unformat_vl_api_ip6_address,
7896 &path->nh.address.ip6, &path->table_id))
7898 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7900 else if (unformat (input, "%U",
7901 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7904 * the recursive next-hops are by default in the default table
7907 path->sw_if_index = ~0;
7908 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7910 else if (unformat (input, "%U",
7911 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7914 * the recursive next-hops are by default in the default table
7917 path->sw_if_index = ~0;
7918 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7920 else if (unformat (input, "resolve-via-host"))
7922 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7924 else if (unformat (input, "resolve-via-attached"))
7926 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7928 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7930 path->type = FIB_API_PATH_TYPE_LOCAL;
7931 path->sw_if_index = ~0;
7932 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7934 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7936 path->type = FIB_API_PATH_TYPE_LOCAL;
7937 path->sw_if_index = ~0;
7938 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7940 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7942 else if (unformat (input, "via-label %d", &path->nh.via_label))
7944 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7945 path->sw_if_index = ~0;
7947 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7949 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7950 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7952 else if (unformat (input, "local"))
7954 path->type = FIB_API_PATH_TYPE_LOCAL;
7956 else if (unformat (input, "out-labels"))
7958 while (unformat (input, "%d", &out_label))
7960 path->label_stack[path->n_labels].label = out_label;
7961 path->label_stack[path->n_labels].is_uniform = 0;
7962 path->label_stack[path->n_labels].ttl = 64;
7966 else if (unformat (input, "via"))
7968 /* new path, back up and return */
7969 unformat_put_input (input);
7970 unformat_put_input (input);
7971 unformat_put_input (input);
7972 unformat_put_input (input);
7981 path->proto = ntohl (path->proto);
7982 path->type = ntohl (path->type);
7983 path->flags = ntohl (path->flags);
7984 path->table_id = ntohl (path->table_id);
7985 path->sw_if_index = ntohl (path->sw_if_index);
7991 api_ip_route_add_del (vat_main_t * vam)
7993 unformat_input_t *i = vam->input;
7994 vl_api_ip_route_add_del_t *mp;
7997 u8 is_multipath = 0;
8000 vl_api_prefix_t pfx = { };
8001 vl_api_fib_path_t paths[8];
8005 u32 random_add_del = 0;
8006 u32 *random_vector = 0;
8007 u32 random_seed = 0xdeaddabe;
8009 /* Parse args required to build the message */
8010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8012 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8014 else if (unformat (i, "del"))
8016 else if (unformat (i, "add"))
8018 else if (unformat (i, "vrf %d", &vrf_id))
8020 else if (unformat (i, "count %d", &count))
8022 else if (unformat (i, "random"))
8024 else if (unformat (i, "multipath"))
8026 else if (unformat (i, "seed %d", &random_seed))
8030 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8033 if (8 == path_count)
8035 errmsg ("max 8 paths");
8041 clib_warning ("parse error '%U'", format_unformat_error, i);
8048 errmsg ("specify a path; via ...");
8051 if (prefix_set == 0)
8053 errmsg ("missing prefix");
8057 /* Generate a pile of unique, random routes */
8060 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8061 u32 this_random_address;
8064 random_hash = hash_create (count, sizeof (uword));
8066 hash_set (random_hash, i->as_u32, 1);
8067 for (j = 0; j <= count; j++)
8071 this_random_address = random_u32 (&random_seed);
8072 this_random_address =
8073 clib_host_to_net_u32 (this_random_address);
8075 while (hash_get (random_hash, this_random_address));
8076 vec_add1 (random_vector, this_random_address);
8077 hash_set (random_hash, this_random_address, 1);
8079 hash_free (random_hash);
8080 set_ip4_address (&pfx.address, random_vector[0]);
8085 /* Turn on async mode */
8086 vam->async_mode = 1;
8087 vam->async_errors = 0;
8088 before = vat_time_now (vam);
8091 for (j = 0; j < count; j++)
8093 /* Construct the API message */
8094 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8096 mp->is_add = is_add;
8097 mp->is_multipath = is_multipath;
8099 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8100 mp->route.table_id = ntohl (vrf_id);
8101 mp->route.n_paths = path_count;
8103 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8106 set_ip4_address (&pfx.address, random_vector[j + 1]);
8108 increment_address (&pfx.address);
8111 /* If we receive SIGTERM, stop now... */
8116 /* When testing multiple add/del ops, use a control-ping to sync */
8119 vl_api_control_ping_t *mp_ping;
8123 /* Shut off async mode */
8124 vam->async_mode = 0;
8126 MPING (CONTROL_PING, mp_ping);
8129 timeout = vat_time_now (vam) + 1.0;
8130 while (vat_time_now (vam) < timeout)
8131 if (vam->result_ready == 1)
8136 if (vam->retval == -99)
8139 if (vam->async_errors > 0)
8141 errmsg ("%d asynchronous errors", vam->async_errors);
8144 vam->async_errors = 0;
8145 after = vat_time_now (vam);
8147 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8151 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8152 count, after - before, count / (after - before));
8158 /* Wait for a reply... */
8163 /* Return the good/bad news */
8164 return (vam->retval);
8168 api_ip_mroute_add_del (vat_main_t * vam)
8170 unformat_input_t *i = vam->input;
8171 u8 path_set = 0, prefix_set = 0, is_add = 1;
8172 vl_api_ip_mroute_add_del_t *mp;
8173 mfib_entry_flags_t eflags = 0;
8174 vl_api_mfib_path_t path;
8175 vl_api_mprefix_t pfx = { };
8179 /* Parse args required to build the message */
8180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8182 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8185 pfx.grp_address_length = htons (pfx.grp_address_length);
8187 else if (unformat (i, "del"))
8189 else if (unformat (i, "add"))
8191 else if (unformat (i, "vrf %d", &vrf_id))
8193 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8194 path.itf_flags = htonl (path.itf_flags);
8195 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8197 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8201 clib_warning ("parse error '%U'", format_unformat_error, i);
8206 if (prefix_set == 0)
8208 errmsg ("missing addresses\n");
8213 errmsg ("missing path\n");
8217 /* Construct the API message */
8218 M (IP_MROUTE_ADD_DEL, mp);
8220 mp->is_add = is_add;
8221 mp->is_multipath = 1;
8223 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8224 mp->route.table_id = htonl (vrf_id);
8225 mp->route.n_paths = 1;
8226 mp->route.entry_flags = htonl (eflags);
8228 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8232 /* Wait for a reply... */
8238 api_mpls_table_add_del (vat_main_t * vam)
8240 unformat_input_t *i = vam->input;
8241 vl_api_mpls_table_add_del_t *mp;
8246 /* Parse args required to build the message */
8247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8249 if (unformat (i, "table %d", &table_id))
8251 else if (unformat (i, "del"))
8253 else if (unformat (i, "add"))
8257 clib_warning ("parse error '%U'", format_unformat_error, i);
8264 errmsg ("missing table-ID");
8268 /* Construct the API message */
8269 M (MPLS_TABLE_ADD_DEL, mp);
8271 mp->mt_table.mt_table_id = ntohl (table_id);
8272 mp->mt_is_add = is_add;
8277 /* Wait for a reply... */
8284 api_mpls_route_add_del (vat_main_t * vam)
8286 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8287 mpls_label_t local_label = MPLS_LABEL_INVALID;
8288 unformat_input_t *i = vam->input;
8289 vl_api_mpls_route_add_del_t *mp;
8290 vl_api_fib_path_t paths[8];
8294 /* Parse args required to build the message */
8295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8297 if (unformat (i, "%d", &local_label))
8299 else if (unformat (i, "eos"))
8301 else if (unformat (i, "non-eos"))
8303 else if (unformat (i, "del"))
8305 else if (unformat (i, "add"))
8307 else if (unformat (i, "multipath"))
8309 else if (unformat (i, "count %d", &count))
8313 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8316 if (8 == path_count)
8318 errmsg ("max 8 paths");
8324 clib_warning ("parse error '%U'", format_unformat_error, i);
8331 errmsg ("specify a path; via ...");
8335 if (MPLS_LABEL_INVALID == local_label)
8337 errmsg ("missing label");
8343 /* Turn on async mode */
8344 vam->async_mode = 1;
8345 vam->async_errors = 0;
8346 before = vat_time_now (vam);
8349 for (j = 0; j < count; j++)
8351 /* Construct the API message */
8352 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8354 mp->mr_is_add = is_add;
8355 mp->mr_is_multipath = is_multipath;
8357 mp->mr_route.mr_label = local_label;
8358 mp->mr_route.mr_eos = is_eos;
8359 mp->mr_route.mr_table_id = 0;
8360 mp->mr_route.mr_n_paths = path_count;
8362 clib_memcpy (&mp->mr_route.mr_paths, paths,
8363 sizeof (paths[0]) * path_count);
8369 /* If we receive SIGTERM, stop now... */
8374 /* When testing multiple add/del ops, use a control-ping to sync */
8377 vl_api_control_ping_t *mp_ping;
8381 /* Shut off async mode */
8382 vam->async_mode = 0;
8384 MPING (CONTROL_PING, mp_ping);
8387 timeout = vat_time_now (vam) + 1.0;
8388 while (vat_time_now (vam) < timeout)
8389 if (vam->result_ready == 1)
8394 if (vam->retval == -99)
8397 if (vam->async_errors > 0)
8399 errmsg ("%d asynchronous errors", vam->async_errors);
8402 vam->async_errors = 0;
8403 after = vat_time_now (vam);
8405 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8409 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8410 count, after - before, count / (after - before));
8416 /* Wait for a reply... */
8421 /* Return the good/bad news */
8422 return (vam->retval);
8427 api_mpls_ip_bind_unbind (vat_main_t * vam)
8429 unformat_input_t *i = vam->input;
8430 vl_api_mpls_ip_bind_unbind_t *mp;
8431 u32 ip_table_id = 0;
8433 vl_api_prefix_t pfx;
8435 mpls_label_t local_label = MPLS_LABEL_INVALID;
8438 /* Parse args required to build the message */
8439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8441 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8443 else if (unformat (i, "%d", &local_label))
8445 else if (unformat (i, "table-id %d", &ip_table_id))
8447 else if (unformat (i, "unbind"))
8449 else if (unformat (i, "bind"))
8453 clib_warning ("parse error '%U'", format_unformat_error, i);
8460 errmsg ("IP prefix not set");
8464 if (MPLS_LABEL_INVALID == local_label)
8466 errmsg ("missing label");
8470 /* Construct the API message */
8471 M (MPLS_IP_BIND_UNBIND, mp);
8473 mp->mb_is_bind = is_bind;
8474 mp->mb_ip_table_id = ntohl (ip_table_id);
8475 mp->mb_mpls_table_id = 0;
8476 mp->mb_label = ntohl (local_label);
8477 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8482 /* Wait for a reply... */
8489 api_sr_mpls_policy_add (vat_main_t * vam)
8491 unformat_input_t *i = vam->input;
8492 vl_api_sr_mpls_policy_add_t *mp;
8498 u32 *segments = NULL;
8501 /* Parse args required to build the message */
8502 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8504 if (unformat (i, "bsid %d", &bsid))
8506 else if (unformat (i, "weight %d", &weight))
8508 else if (unformat (i, "spray"))
8510 else if (unformat (i, "next %d", &sid))
8513 vec_add1 (segments, htonl (sid));
8517 clib_warning ("parse error '%U'", format_unformat_error, i);
8524 errmsg ("bsid not set");
8528 if (n_segments == 0)
8530 errmsg ("no sid in segment stack");
8534 /* Construct the API message */
8535 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8537 mp->bsid = htonl (bsid);
8538 mp->weight = htonl (weight);
8540 mp->n_segments = n_segments;
8541 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8542 vec_free (segments);
8547 /* Wait for a reply... */
8553 api_sr_mpls_policy_del (vat_main_t * vam)
8555 unformat_input_t *i = vam->input;
8556 vl_api_sr_mpls_policy_del_t *mp;
8560 /* Parse args required to build the message */
8561 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8563 if (unformat (i, "bsid %d", &bsid))
8567 clib_warning ("parse error '%U'", format_unformat_error, i);
8574 errmsg ("bsid not set");
8578 /* Construct the API message */
8579 M (SR_MPLS_POLICY_DEL, mp);
8581 mp->bsid = htonl (bsid);
8586 /* Wait for a reply... */
8592 api_bier_table_add_del (vat_main_t * vam)
8594 unformat_input_t *i = vam->input;
8595 vl_api_bier_table_add_del_t *mp;
8597 u32 set = 0, sub_domain = 0, hdr_len = 3;
8598 mpls_label_t local_label = MPLS_LABEL_INVALID;
8601 /* Parse args required to build the message */
8602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8604 if (unformat (i, "sub-domain %d", &sub_domain))
8606 else if (unformat (i, "set %d", &set))
8608 else if (unformat (i, "label %d", &local_label))
8610 else if (unformat (i, "hdr-len %d", &hdr_len))
8612 else if (unformat (i, "add"))
8614 else if (unformat (i, "del"))
8618 clib_warning ("parse error '%U'", format_unformat_error, i);
8623 if (MPLS_LABEL_INVALID == local_label)
8625 errmsg ("missing label\n");
8629 /* Construct the API message */
8630 M (BIER_TABLE_ADD_DEL, mp);
8632 mp->bt_is_add = is_add;
8633 mp->bt_label = ntohl (local_label);
8634 mp->bt_tbl_id.bt_set = set;
8635 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8636 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8641 /* Wait for a reply... */
8648 api_bier_route_add_del (vat_main_t * vam)
8650 unformat_input_t *i = vam->input;
8651 vl_api_bier_route_add_del_t *mp;
8653 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8654 ip4_address_t v4_next_hop_address;
8655 ip6_address_t v6_next_hop_address;
8656 u8 next_hop_set = 0;
8657 u8 next_hop_proto_is_ip4 = 1;
8658 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8661 /* Parse args required to build the message */
8662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8664 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8666 next_hop_proto_is_ip4 = 1;
8669 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8671 next_hop_proto_is_ip4 = 0;
8674 if (unformat (i, "sub-domain %d", &sub_domain))
8676 else if (unformat (i, "set %d", &set))
8678 else if (unformat (i, "hdr-len %d", &hdr_len))
8680 else if (unformat (i, "bp %d", &bp))
8682 else if (unformat (i, "add"))
8684 else if (unformat (i, "del"))
8686 else if (unformat (i, "out-label %d", &next_hop_out_label))
8690 clib_warning ("parse error '%U'", format_unformat_error, i);
8695 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8697 errmsg ("next hop / label set\n");
8702 errmsg ("bit=position not set\n");
8706 /* Construct the API message */
8707 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8709 mp->br_is_add = is_add;
8710 mp->br_route.br_tbl_id.bt_set = set;
8711 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8712 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8713 mp->br_route.br_bp = ntohs (bp);
8714 mp->br_route.br_n_paths = 1;
8715 mp->br_route.br_paths[0].n_labels = 1;
8716 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8717 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8718 FIB_API_PATH_NH_PROTO_IP4 :
8719 FIB_API_PATH_NH_PROTO_IP6);
8721 if (next_hop_proto_is_ip4)
8723 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8724 &v4_next_hop_address, sizeof (v4_next_hop_address));
8728 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8729 &v6_next_hop_address, sizeof (v6_next_hop_address));
8735 /* Wait for a reply... */
8742 api_mpls_tunnel_add_del (vat_main_t * vam)
8744 unformat_input_t *i = vam->input;
8745 vl_api_mpls_tunnel_add_del_t *mp;
8747 vl_api_fib_path_t paths[8];
8748 u32 sw_if_index = ~0;
8754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8756 if (unformat (i, "add"))
8760 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8762 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8764 else if (unformat (i, "l2-only"))
8768 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8771 if (8 == path_count)
8773 errmsg ("max 8 paths");
8779 clib_warning ("parse error '%U'", format_unformat_error, i);
8784 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8786 mp->mt_is_add = is_add;
8787 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8788 mp->mt_tunnel.mt_l2_only = l2_only;
8789 mp->mt_tunnel.mt_is_multicast = 0;
8790 mp->mt_tunnel.mt_n_paths = path_count;
8792 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8793 sizeof (paths[0]) * path_count);
8801 api_sw_interface_set_unnumbered (vat_main_t * vam)
8803 unformat_input_t *i = vam->input;
8804 vl_api_sw_interface_set_unnumbered_t *mp;
8806 u32 unnum_sw_index = ~0;
8808 u8 sw_if_index_set = 0;
8811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8813 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8814 sw_if_index_set = 1;
8815 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8816 sw_if_index_set = 1;
8817 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8819 else if (unformat (i, "del"))
8823 clib_warning ("parse error '%U'", format_unformat_error, i);
8828 if (sw_if_index_set == 0)
8830 errmsg ("missing interface name or sw_if_index");
8834 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8836 mp->sw_if_index = ntohl (sw_if_index);
8837 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8838 mp->is_add = is_add;
8847 api_create_vlan_subif (vat_main_t * vam)
8849 unformat_input_t *i = vam->input;
8850 vl_api_create_vlan_subif_t *mp;
8852 u8 sw_if_index_set = 0;
8857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8859 if (unformat (i, "sw_if_index %d", &sw_if_index))
8860 sw_if_index_set = 1;
8862 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8863 sw_if_index_set = 1;
8864 else if (unformat (i, "vlan %d", &vlan_id))
8868 clib_warning ("parse error '%U'", format_unformat_error, i);
8873 if (sw_if_index_set == 0)
8875 errmsg ("missing interface name or sw_if_index");
8879 if (vlan_id_set == 0)
8881 errmsg ("missing vlan_id");
8884 M (CREATE_VLAN_SUBIF, mp);
8886 mp->sw_if_index = ntohl (sw_if_index);
8887 mp->vlan_id = ntohl (vlan_id);
8894 #define foreach_create_subif_bit \
8901 _(outer_vlan_id_any) \
8902 _(inner_vlan_id_any)
8904 #define foreach_create_subif_flag \
8909 _(4, "exact_match") \
8910 _(5, "default_sub") \
8911 _(6, "outer_vlan_id_any") \
8912 _(7, "inner_vlan_id_any")
8915 api_create_subif (vat_main_t * vam)
8917 unformat_input_t *i = vam->input;
8918 vl_api_create_subif_t *mp;
8920 u8 sw_if_index_set = 0;
8923 u32 __attribute__ ((unused)) no_tags = 0;
8924 u32 __attribute__ ((unused)) one_tag = 0;
8925 u32 __attribute__ ((unused)) two_tags = 0;
8926 u32 __attribute__ ((unused)) dot1ad = 0;
8927 u32 __attribute__ ((unused)) exact_match = 0;
8928 u32 __attribute__ ((unused)) default_sub = 0;
8929 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8930 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8932 u16 outer_vlan_id = 0;
8933 u16 inner_vlan_id = 0;
8936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8938 if (unformat (i, "sw_if_index %d", &sw_if_index))
8939 sw_if_index_set = 1;
8941 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8942 sw_if_index_set = 1;
8943 else if (unformat (i, "sub_id %d", &sub_id))
8945 else if (unformat (i, "outer_vlan_id %d", &tmp))
8946 outer_vlan_id = tmp;
8947 else if (unformat (i, "inner_vlan_id %d", &tmp))
8948 inner_vlan_id = tmp;
8950 #define _(a) else if (unformat (i, #a)) a = 1 ;
8951 foreach_create_subif_bit
8955 clib_warning ("parse error '%U'", format_unformat_error, i);
8960 if (sw_if_index_set == 0)
8962 errmsg ("missing interface name or sw_if_index");
8966 if (sub_id_set == 0)
8968 errmsg ("missing sub_id");
8971 M (CREATE_SUBIF, mp);
8973 mp->sw_if_index = ntohl (sw_if_index);
8974 mp->sub_id = ntohl (sub_id);
8976 #define _(a,b) mp->sub_if_flags |= (1 << a);
8977 foreach_create_subif_flag;
8980 mp->outer_vlan_id = ntohs (outer_vlan_id);
8981 mp->inner_vlan_id = ntohs (inner_vlan_id);
8989 api_ip_table_replace_begin (vat_main_t * vam)
8991 unformat_input_t *i = vam->input;
8992 vl_api_ip_table_replace_begin_t *mp;
8997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8999 if (unformat (i, "table %d", &table_id))
9001 else if (unformat (i, "ipv6"))
9005 clib_warning ("parse error '%U'", format_unformat_error, i);
9010 M (IP_TABLE_REPLACE_BEGIN, mp);
9012 mp->table.table_id = ntohl (table_id);
9013 mp->table.is_ip6 = is_ipv6;
9021 api_ip_table_flush (vat_main_t * vam)
9023 unformat_input_t *i = vam->input;
9024 vl_api_ip_table_flush_t *mp;
9029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9031 if (unformat (i, "table %d", &table_id))
9033 else if (unformat (i, "ipv6"))
9037 clib_warning ("parse error '%U'", format_unformat_error, i);
9042 M (IP_TABLE_FLUSH, mp);
9044 mp->table.table_id = ntohl (table_id);
9045 mp->table.is_ip6 = is_ipv6;
9053 api_ip_table_replace_end (vat_main_t * vam)
9055 unformat_input_t *i = vam->input;
9056 vl_api_ip_table_replace_end_t *mp;
9061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9063 if (unformat (i, "table %d", &table_id))
9065 else if (unformat (i, "ipv6"))
9069 clib_warning ("parse error '%U'", format_unformat_error, i);
9074 M (IP_TABLE_REPLACE_END, mp);
9076 mp->table.table_id = ntohl (table_id);
9077 mp->table.is_ip6 = is_ipv6;
9085 api_set_ip_flow_hash (vat_main_t * vam)
9087 unformat_input_t *i = vam->input;
9088 vl_api_set_ip_flow_hash_t *mp;
9100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9102 if (unformat (i, "vrf %d", &vrf_id))
9104 else if (unformat (i, "ipv6"))
9106 else if (unformat (i, "src"))
9108 else if (unformat (i, "dst"))
9110 else if (unformat (i, "sport"))
9112 else if (unformat (i, "dport"))
9114 else if (unformat (i, "proto"))
9116 else if (unformat (i, "reverse"))
9121 clib_warning ("parse error '%U'", format_unformat_error, i);
9126 if (vrf_id_set == 0)
9128 errmsg ("missing vrf id");
9132 M (SET_IP_FLOW_HASH, mp);
9138 mp->reverse = reverse;
9139 mp->vrf_id = ntohl (vrf_id);
9140 mp->is_ipv6 = is_ipv6;
9148 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9150 unformat_input_t *i = vam->input;
9151 vl_api_sw_interface_ip6_enable_disable_t *mp;
9153 u8 sw_if_index_set = 0;
9157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9159 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9160 sw_if_index_set = 1;
9161 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9162 sw_if_index_set = 1;
9163 else if (unformat (i, "enable"))
9165 else if (unformat (i, "disable"))
9169 clib_warning ("parse error '%U'", format_unformat_error, i);
9174 if (sw_if_index_set == 0)
9176 errmsg ("missing interface name or sw_if_index");
9180 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9182 mp->sw_if_index = ntohl (sw_if_index);
9183 mp->enable = enable;
9192 api_l2_patch_add_del (vat_main_t * vam)
9194 unformat_input_t *i = vam->input;
9195 vl_api_l2_patch_add_del_t *mp;
9197 u8 rx_sw_if_index_set = 0;
9199 u8 tx_sw_if_index_set = 0;
9203 /* Parse args required to build the message */
9204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9206 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9207 rx_sw_if_index_set = 1;
9208 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9209 tx_sw_if_index_set = 1;
9210 else if (unformat (i, "rx"))
9212 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9214 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9216 rx_sw_if_index_set = 1;
9221 else if (unformat (i, "tx"))
9223 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9225 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9227 tx_sw_if_index_set = 1;
9232 else if (unformat (i, "del"))
9238 if (rx_sw_if_index_set == 0)
9240 errmsg ("missing rx interface name or rx_sw_if_index");
9244 if (tx_sw_if_index_set == 0)
9246 errmsg ("missing tx interface name or tx_sw_if_index");
9250 M (L2_PATCH_ADD_DEL, mp);
9252 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9253 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9254 mp->is_add = is_add;
9262 u8 localsid_addr[16];
9271 api_sr_localsid_add_del (vat_main_t * vam)
9273 unformat_input_t *i = vam->input;
9274 vl_api_sr_localsid_add_del_t *mp;
9277 ip6_address_t localsid;
9281 u32 fib_table = ~(u32) 0;
9282 ip6_address_t nh_addr6;
9283 ip4_address_t nh_addr4;
9284 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9285 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9287 bool nexthop_set = 0;
9291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9293 if (unformat (i, "del"))
9295 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9296 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9298 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9300 else if (unformat (i, "behavior %u", &behavior));
9301 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9302 else if (unformat (i, "fib-table %u", &fib_table));
9303 else if (unformat (i, "end.psp %u", &behavior));
9308 M (SR_LOCALSID_ADD_DEL, mp);
9310 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9314 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9315 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9317 mp->behavior = behavior;
9318 mp->sw_if_index = ntohl (sw_if_index);
9319 mp->fib_table = ntohl (fib_table);
9320 mp->end_psp = end_psp;
9321 mp->is_del = is_del;
9329 api_ioam_enable (vat_main_t * vam)
9331 unformat_input_t *input = vam->input;
9332 vl_api_ioam_enable_t *mp;
9334 int has_trace_option = 0;
9335 int has_pot_option = 0;
9336 int has_seqno_option = 0;
9337 int has_analyse_option = 0;
9340 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9342 if (unformat (input, "trace"))
9343 has_trace_option = 1;
9344 else if (unformat (input, "pot"))
9346 else if (unformat (input, "seqno"))
9347 has_seqno_option = 1;
9348 else if (unformat (input, "analyse"))
9349 has_analyse_option = 1;
9353 M (IOAM_ENABLE, mp);
9354 mp->id = htons (id);
9355 mp->seqno = has_seqno_option;
9356 mp->analyse = has_analyse_option;
9357 mp->pot_enable = has_pot_option;
9358 mp->trace_enable = has_trace_option;
9367 api_ioam_disable (vat_main_t * vam)
9369 vl_api_ioam_disable_t *mp;
9372 M (IOAM_DISABLE, mp);
9378 #define foreach_tcp_proto_field \
9382 #define foreach_udp_proto_field \
9386 #define foreach_ip4_proto_field \
9398 u16 src_port, dst_port;
9401 #if VPP_API_TEST_BUILTIN == 0
9403 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9405 u8 **maskp = va_arg (*args, u8 **);
9407 u8 found_something = 0;
9410 #define _(a) u8 a=0;
9411 foreach_tcp_proto_field;
9414 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9417 #define _(a) else if (unformat (input, #a)) a=1;
9418 foreach_tcp_proto_field
9424 #define _(a) found_something += a;
9425 foreach_tcp_proto_field;
9428 if (found_something == 0)
9431 vec_validate (mask, sizeof (*tcp) - 1);
9433 tcp = (tcp_header_t *) mask;
9435 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9436 foreach_tcp_proto_field;
9444 unformat_udp_mask (unformat_input_t * input, va_list * args)
9446 u8 **maskp = va_arg (*args, u8 **);
9448 u8 found_something = 0;
9451 #define _(a) u8 a=0;
9452 foreach_udp_proto_field;
9455 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9458 #define _(a) else if (unformat (input, #a)) a=1;
9459 foreach_udp_proto_field
9465 #define _(a) found_something += a;
9466 foreach_udp_proto_field;
9469 if (found_something == 0)
9472 vec_validate (mask, sizeof (*udp) - 1);
9474 udp = (udp_header_t *) mask;
9476 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9477 foreach_udp_proto_field;
9485 unformat_l4_mask (unformat_input_t * input, va_list * args)
9487 u8 **maskp = va_arg (*args, u8 **);
9488 u16 src_port = 0, dst_port = 0;
9489 tcpudp_header_t *tcpudp;
9491 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9493 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9495 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9497 else if (unformat (input, "src_port"))
9499 else if (unformat (input, "dst_port"))
9505 if (!src_port && !dst_port)
9509 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9511 tcpudp = (tcpudp_header_t *) mask;
9512 tcpudp->src_port = src_port;
9513 tcpudp->dst_port = dst_port;
9521 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9523 u8 **maskp = va_arg (*args, u8 **);
9525 u8 found_something = 0;
9528 #define _(a) u8 a=0;
9529 foreach_ip4_proto_field;
9535 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9537 if (unformat (input, "version"))
9539 else if (unformat (input, "hdr_length"))
9541 else if (unformat (input, "src"))
9543 else if (unformat (input, "dst"))
9545 else if (unformat (input, "proto"))
9548 #define _(a) else if (unformat (input, #a)) a=1;
9549 foreach_ip4_proto_field
9555 #define _(a) found_something += a;
9556 foreach_ip4_proto_field;
9559 if (found_something == 0)
9562 vec_validate (mask, sizeof (*ip) - 1);
9564 ip = (ip4_header_t *) mask;
9566 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9567 foreach_ip4_proto_field;
9570 ip->ip_version_and_header_length = 0;
9573 ip->ip_version_and_header_length |= 0xF0;
9576 ip->ip_version_and_header_length |= 0x0F;
9582 #define foreach_ip6_proto_field \
9590 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9592 u8 **maskp = va_arg (*args, u8 **);
9594 u8 found_something = 0;
9596 u32 ip_version_traffic_class_and_flow_label;
9598 #define _(a) u8 a=0;
9599 foreach_ip6_proto_field;
9602 u8 traffic_class = 0;
9605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9607 if (unformat (input, "version"))
9609 else if (unformat (input, "traffic-class"))
9611 else if (unformat (input, "flow-label"))
9613 else if (unformat (input, "src"))
9615 else if (unformat (input, "dst"))
9617 else if (unformat (input, "proto"))
9620 #define _(a) else if (unformat (input, #a)) a=1;
9621 foreach_ip6_proto_field
9627 #define _(a) found_something += a;
9628 foreach_ip6_proto_field;
9631 if (found_something == 0)
9634 vec_validate (mask, sizeof (*ip) - 1);
9636 ip = (ip6_header_t *) mask;
9638 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9639 foreach_ip6_proto_field;
9642 ip_version_traffic_class_and_flow_label = 0;
9645 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9648 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9651 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9653 ip->ip_version_traffic_class_and_flow_label =
9654 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9661 unformat_l3_mask (unformat_input_t * input, va_list * args)
9663 u8 **maskp = va_arg (*args, u8 **);
9665 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9667 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9669 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9678 unformat_l2_mask (unformat_input_t * input, va_list * args)
9680 u8 **maskp = va_arg (*args, u8 **);
9695 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9697 if (unformat (input, "src"))
9699 else if (unformat (input, "dst"))
9701 else if (unformat (input, "proto"))
9703 else if (unformat (input, "tag1"))
9705 else if (unformat (input, "tag2"))
9707 else if (unformat (input, "ignore-tag1"))
9709 else if (unformat (input, "ignore-tag2"))
9711 else if (unformat (input, "cos1"))
9713 else if (unformat (input, "cos2"))
9715 else if (unformat (input, "dot1q"))
9717 else if (unformat (input, "dot1ad"))
9722 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9723 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9726 if (tag1 || ignore_tag1 || cos1 || dot1q)
9728 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9731 vec_validate (mask, len - 1);
9734 clib_memset (mask, 0xff, 6);
9737 clib_memset (mask + 6, 0xff, 6);
9741 /* inner vlan tag */
9750 mask[21] = mask[20] = 0xff;
9771 mask[16] = mask[17] = 0xff;
9781 mask[12] = mask[13] = 0xff;
9788 unformat_classify_mask (unformat_input_t * input, va_list * args)
9790 u8 **maskp = va_arg (*args, u8 **);
9791 u32 *skipp = va_arg (*args, u32 *);
9792 u32 *matchp = va_arg (*args, u32 *);
9800 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9802 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9804 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9806 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9808 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9822 if (mask || l2 || l3 || l4)
9826 /* "With a free Ethernet header in every package" */
9828 vec_validate (l2, 13);
9832 vec_append (mask, l3);
9837 vec_append (mask, l4);
9842 /* Scan forward looking for the first significant mask octet */
9843 for (i = 0; i < vec_len (mask); i++)
9847 /* compute (skip, match) params */
9848 *skipp = i / sizeof (u32x4);
9849 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9851 /* Pad mask to an even multiple of the vector size */
9852 while (vec_len (mask) % sizeof (u32x4))
9855 match = vec_len (mask) / sizeof (u32x4);
9857 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9859 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9860 if (*tmp || *(tmp + 1))
9865 clib_warning ("BUG: match 0");
9867 _vec_len (mask) = match * sizeof (u32x4);
9877 #endif /* VPP_API_TEST_BUILTIN */
9879 #define foreach_l2_next \
9881 _(ethernet, ETHERNET_INPUT) \
9886 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9888 u32 *miss_next_indexp = va_arg (*args, u32 *);
9893 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9897 if (unformat (input, "%d", &tmp))
9906 *miss_next_indexp = next_index;
9910 #define foreach_ip_next \
9916 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9918 u32 *miss_next_indexp = va_arg (*args, u32 *);
9923 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9927 if (unformat (input, "%d", &tmp))
9936 *miss_next_indexp = next_index;
9940 #define foreach_acl_next \
9944 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9946 u32 *miss_next_indexp = va_arg (*args, u32 *);
9951 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9955 if (unformat (input, "permit"))
9960 else if (unformat (input, "%d", &tmp))
9969 *miss_next_indexp = next_index;
9974 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9976 u32 *r = va_arg (*args, u32 *);
9978 if (unformat (input, "conform-color"))
9979 *r = POLICE_CONFORM;
9980 else if (unformat (input, "exceed-color"))
9989 api_classify_add_del_table (vat_main_t * vam)
9991 unformat_input_t *i = vam->input;
9992 vl_api_classify_add_del_table_t *mp;
9999 u32 table_index = ~0;
10000 u32 next_table_index = ~0;
10001 u32 miss_next_index = ~0;
10002 u32 memory_size = 32 << 20;
10004 u32 current_data_flag = 0;
10005 int current_data_offset = 0;
10008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10010 if (unformat (i, "del"))
10012 else if (unformat (i, "del-chain"))
10017 else if (unformat (i, "buckets %d", &nbuckets))
10019 else if (unformat (i, "memory_size %d", &memory_size))
10021 else if (unformat (i, "skip %d", &skip))
10023 else if (unformat (i, "match %d", &match))
10025 else if (unformat (i, "table %d", &table_index))
10027 else if (unformat (i, "mask %U", unformat_classify_mask,
10028 &mask, &skip, &match))
10030 else if (unformat (i, "next-table %d", &next_table_index))
10032 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10035 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10038 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10041 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10043 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10049 if (is_add && mask == 0)
10051 errmsg ("Mask required");
10055 if (is_add && skip == ~0)
10057 errmsg ("skip count required");
10061 if (is_add && match == ~0)
10063 errmsg ("match count required");
10067 if (!is_add && table_index == ~0)
10069 errmsg ("table index required for delete");
10073 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10075 mp->is_add = is_add;
10076 mp->del_chain = del_chain;
10077 mp->table_index = ntohl (table_index);
10078 mp->nbuckets = ntohl (nbuckets);
10079 mp->memory_size = ntohl (memory_size);
10080 mp->skip_n_vectors = ntohl (skip);
10081 mp->match_n_vectors = ntohl (match);
10082 mp->next_table_index = ntohl (next_table_index);
10083 mp->miss_next_index = ntohl (miss_next_index);
10084 mp->current_data_flag = ntohl (current_data_flag);
10085 mp->current_data_offset = ntohl (current_data_offset);
10086 mp->mask_len = ntohl (vec_len (mask));
10087 clib_memcpy (mp->mask, mask, vec_len (mask));
10096 #if VPP_API_TEST_BUILTIN == 0
10098 unformat_l4_match (unformat_input_t * input, va_list * args)
10100 u8 **matchp = va_arg (*args, u8 **);
10102 u8 *proto_header = 0;
10108 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10110 if (unformat (input, "src_port %d", &src_port))
10112 else if (unformat (input, "dst_port %d", &dst_port))
10118 h.src_port = clib_host_to_net_u16 (src_port);
10119 h.dst_port = clib_host_to_net_u16 (dst_port);
10120 vec_validate (proto_header, sizeof (h) - 1);
10121 memcpy (proto_header, &h, sizeof (h));
10123 *matchp = proto_header;
10129 unformat_ip4_match (unformat_input_t * input, va_list * args)
10131 u8 **matchp = va_arg (*args, u8 **);
10136 int hdr_length = 0;
10137 u32 hdr_length_val;
10138 int src = 0, dst = 0;
10139 ip4_address_t src_val, dst_val;
10146 int fragment_id = 0;
10147 u32 fragment_id_val;
10153 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10155 if (unformat (input, "version %d", &version_val))
10157 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10159 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10161 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10163 else if (unformat (input, "proto %d", &proto_val))
10165 else if (unformat (input, "tos %d", &tos_val))
10167 else if (unformat (input, "length %d", &length_val))
10169 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10171 else if (unformat (input, "ttl %d", &ttl_val))
10173 else if (unformat (input, "checksum %d", &checksum_val))
10179 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10180 + ttl + checksum == 0)
10184 * Aligned because we use the real comparison functions
10186 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10188 ip = (ip4_header_t *) match;
10190 /* These are realistically matched in practice */
10192 ip->src_address.as_u32 = src_val.as_u32;
10195 ip->dst_address.as_u32 = dst_val.as_u32;
10198 ip->protocol = proto_val;
10201 /* These are not, but they're included for completeness */
10203 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10206 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10212 ip->length = clib_host_to_net_u16 (length_val);
10218 ip->checksum = clib_host_to_net_u16 (checksum_val);
10225 unformat_ip6_match (unformat_input_t * input, va_list * args)
10227 u8 **matchp = va_arg (*args, u8 **);
10232 u8 traffic_class = 0;
10233 u32 traffic_class_val = 0;
10236 int src = 0, dst = 0;
10237 ip6_address_t src_val, dst_val;
10240 int payload_length = 0;
10241 u32 payload_length_val;
10244 u32 ip_version_traffic_class_and_flow_label;
10246 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10248 if (unformat (input, "version %d", &version_val))
10250 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10252 else if (unformat (input, "flow_label %d", &flow_label_val))
10254 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10256 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10258 else if (unformat (input, "proto %d", &proto_val))
10260 else if (unformat (input, "payload_length %d", &payload_length_val))
10261 payload_length = 1;
10262 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10268 if (version + traffic_class + flow_label + src + dst + proto +
10269 payload_length + hop_limit == 0)
10273 * Aligned because we use the real comparison functions
10275 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10277 ip = (ip6_header_t *) match;
10280 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10283 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10286 ip->protocol = proto_val;
10288 ip_version_traffic_class_and_flow_label = 0;
10291 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10294 ip_version_traffic_class_and_flow_label |=
10295 (traffic_class_val & 0xFF) << 20;
10298 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10300 ip->ip_version_traffic_class_and_flow_label =
10301 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10303 if (payload_length)
10304 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10307 ip->hop_limit = hop_limit_val;
10314 unformat_l3_match (unformat_input_t * input, va_list * args)
10316 u8 **matchp = va_arg (*args, u8 **);
10318 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10320 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10322 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10331 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10333 u8 *tagp = va_arg (*args, u8 *);
10336 if (unformat (input, "%d", &tag))
10338 tagp[0] = (tag >> 8) & 0x0F;
10339 tagp[1] = tag & 0xFF;
10347 unformat_l2_match (unformat_input_t * input, va_list * args)
10349 u8 **matchp = va_arg (*args, u8 **);
10362 u8 ignore_tag1 = 0;
10363 u8 ignore_tag2 = 0;
10369 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10371 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10374 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10376 else if (unformat (input, "proto %U",
10377 unformat_ethernet_type_host_byte_order, &proto_val))
10379 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10381 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10383 else if (unformat (input, "ignore-tag1"))
10385 else if (unformat (input, "ignore-tag2"))
10387 else if (unformat (input, "cos1 %d", &cos1_val))
10389 else if (unformat (input, "cos2 %d", &cos2_val))
10394 if ((src + dst + proto + tag1 + tag2 +
10395 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10398 if (tag1 || ignore_tag1 || cos1)
10400 if (tag2 || ignore_tag2 || cos2)
10403 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10406 clib_memcpy (match, dst_val, 6);
10409 clib_memcpy (match + 6, src_val, 6);
10413 /* inner vlan tag */
10414 match[19] = tag2_val[1];
10415 match[18] = tag2_val[0];
10417 match[18] |= (cos2_val & 0x7) << 5;
10420 match[21] = proto_val & 0xff;
10421 match[20] = proto_val >> 8;
10425 match[15] = tag1_val[1];
10426 match[14] = tag1_val[0];
10429 match[14] |= (cos1_val & 0x7) << 5;
10435 match[15] = tag1_val[1];
10436 match[14] = tag1_val[0];
10439 match[17] = proto_val & 0xff;
10440 match[16] = proto_val >> 8;
10443 match[14] |= (cos1_val & 0x7) << 5;
10449 match[18] |= (cos2_val & 0x7) << 5;
10451 match[14] |= (cos1_val & 0x7) << 5;
10454 match[13] = proto_val & 0xff;
10455 match[12] = proto_val >> 8;
10463 unformat_qos_source (unformat_input_t * input, va_list * args)
10465 int *qs = va_arg (*args, int *);
10467 if (unformat (input, "ip"))
10468 *qs = QOS_SOURCE_IP;
10469 else if (unformat (input, "mpls"))
10470 *qs = QOS_SOURCE_MPLS;
10471 else if (unformat (input, "ext"))
10472 *qs = QOS_SOURCE_EXT;
10473 else if (unformat (input, "vlan"))
10474 *qs = QOS_SOURCE_VLAN;
10483 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10485 u8 **matchp = va_arg (*args, u8 **);
10486 u32 skip_n_vectors = va_arg (*args, u32);
10487 u32 match_n_vectors = va_arg (*args, u32);
10494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10496 if (unformat (input, "hex %U", unformat_hex_string, &match))
10498 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10500 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10502 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10516 if (match || l2 || l3 || l4)
10518 if (l2 || l3 || l4)
10520 /* "Win a free Ethernet header in every packet" */
10522 vec_validate_aligned (l2, 13, sizeof (u32x4));
10526 vec_append_aligned (match, l3, sizeof (u32x4));
10531 vec_append_aligned (match, l4, sizeof (u32x4));
10536 /* Make sure the vector is big enough even if key is all 0's */
10537 vec_validate_aligned
10538 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10541 /* Set size, include skipped vectors */
10542 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10553 api_classify_add_del_session (vat_main_t * vam)
10555 unformat_input_t *i = vam->input;
10556 vl_api_classify_add_del_session_t *mp;
10558 u32 table_index = ~0;
10559 u32 hit_next_index = ~0;
10560 u32 opaque_index = ~0;
10563 u32 skip_n_vectors = 0;
10564 u32 match_n_vectors = 0;
10570 * Warning: you have to supply skip_n and match_n
10571 * because the API client cant simply look at the classify
10575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10577 if (unformat (i, "del"))
10579 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10582 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10585 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10588 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10590 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10592 else if (unformat (i, "opaque-index %d", &opaque_index))
10594 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10596 else if (unformat (i, "match_n %d", &match_n_vectors))
10598 else if (unformat (i, "match %U", api_unformat_classify_match,
10599 &match, skip_n_vectors, match_n_vectors))
10601 else if (unformat (i, "advance %d", &advance))
10603 else if (unformat (i, "table-index %d", &table_index))
10605 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10607 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10609 else if (unformat (i, "action %d", &action))
10611 else if (unformat (i, "metadata %d", &metadata))
10617 if (table_index == ~0)
10619 errmsg ("Table index required");
10623 if (is_add && match == 0)
10625 errmsg ("Match value required");
10629 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10631 mp->is_add = is_add;
10632 mp->table_index = ntohl (table_index);
10633 mp->hit_next_index = ntohl (hit_next_index);
10634 mp->opaque_index = ntohl (opaque_index);
10635 mp->advance = ntohl (advance);
10636 mp->action = action;
10637 mp->metadata = ntohl (metadata);
10638 mp->match_len = ntohl (vec_len (match));
10639 clib_memcpy (mp->match, match, vec_len (match));
10648 api_classify_set_interface_ip_table (vat_main_t * vam)
10650 unformat_input_t *i = vam->input;
10651 vl_api_classify_set_interface_ip_table_t *mp;
10653 int sw_if_index_set;
10654 u32 table_index = ~0;
10658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10660 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10661 sw_if_index_set = 1;
10662 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10663 sw_if_index_set = 1;
10664 else if (unformat (i, "table %d", &table_index))
10668 clib_warning ("parse error '%U'", format_unformat_error, i);
10673 if (sw_if_index_set == 0)
10675 errmsg ("missing interface name or sw_if_index");
10680 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10682 mp->sw_if_index = ntohl (sw_if_index);
10683 mp->table_index = ntohl (table_index);
10684 mp->is_ipv6 = is_ipv6;
10692 api_classify_set_interface_l2_tables (vat_main_t * vam)
10694 unformat_input_t *i = vam->input;
10695 vl_api_classify_set_interface_l2_tables_t *mp;
10697 int sw_if_index_set;
10698 u32 ip4_table_index = ~0;
10699 u32 ip6_table_index = ~0;
10700 u32 other_table_index = ~0;
10704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10706 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10707 sw_if_index_set = 1;
10708 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10709 sw_if_index_set = 1;
10710 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10712 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10714 else if (unformat (i, "other-table %d", &other_table_index))
10716 else if (unformat (i, "is-input %d", &is_input))
10720 clib_warning ("parse error '%U'", format_unformat_error, i);
10725 if (sw_if_index_set == 0)
10727 errmsg ("missing interface name or sw_if_index");
10732 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10734 mp->sw_if_index = ntohl (sw_if_index);
10735 mp->ip4_table_index = ntohl (ip4_table_index);
10736 mp->ip6_table_index = ntohl (ip6_table_index);
10737 mp->other_table_index = ntohl (other_table_index);
10738 mp->is_input = (u8) is_input;
10746 api_set_ipfix_exporter (vat_main_t * vam)
10748 unformat_input_t *i = vam->input;
10749 vl_api_set_ipfix_exporter_t *mp;
10750 ip4_address_t collector_address;
10751 u8 collector_address_set = 0;
10752 u32 collector_port = ~0;
10753 ip4_address_t src_address;
10754 u8 src_address_set = 0;
10757 u32 template_interval = ~0;
10758 u8 udp_checksum = 0;
10761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10763 if (unformat (i, "collector_address %U", unformat_ip4_address,
10764 &collector_address))
10765 collector_address_set = 1;
10766 else if (unformat (i, "collector_port %d", &collector_port))
10768 else if (unformat (i, "src_address %U", unformat_ip4_address,
10770 src_address_set = 1;
10771 else if (unformat (i, "vrf_id %d", &vrf_id))
10773 else if (unformat (i, "path_mtu %d", &path_mtu))
10775 else if (unformat (i, "template_interval %d", &template_interval))
10777 else if (unformat (i, "udp_checksum"))
10783 if (collector_address_set == 0)
10785 errmsg ("collector_address required");
10789 if (src_address_set == 0)
10791 errmsg ("src_address required");
10795 M (SET_IPFIX_EXPORTER, mp);
10797 memcpy (mp->collector_address.un.ip4, collector_address.data,
10798 sizeof (collector_address.data));
10799 mp->collector_port = htons ((u16) collector_port);
10800 memcpy (mp->src_address.un.ip4, src_address.data,
10801 sizeof (src_address.data));
10802 mp->vrf_id = htonl (vrf_id);
10803 mp->path_mtu = htonl (path_mtu);
10804 mp->template_interval = htonl (template_interval);
10805 mp->udp_checksum = udp_checksum;
10813 api_set_ipfix_classify_stream (vat_main_t * vam)
10815 unformat_input_t *i = vam->input;
10816 vl_api_set_ipfix_classify_stream_t *mp;
10818 u32 src_port = UDP_DST_PORT_ipfix;
10821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10823 if (unformat (i, "domain %d", &domain_id))
10825 else if (unformat (i, "src_port %d", &src_port))
10829 errmsg ("unknown input `%U'", format_unformat_error, i);
10834 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10836 mp->domain_id = htonl (domain_id);
10837 mp->src_port = htons ((u16) src_port);
10845 api_ipfix_classify_table_add_del (vat_main_t * vam)
10847 unformat_input_t *i = vam->input;
10848 vl_api_ipfix_classify_table_add_del_t *mp;
10850 u32 classify_table_index = ~0;
10852 u8 transport_protocol = 255;
10855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10857 if (unformat (i, "add"))
10859 else if (unformat (i, "del"))
10861 else if (unformat (i, "table %d", &classify_table_index))
10863 else if (unformat (i, "ip4"))
10865 else if (unformat (i, "ip6"))
10867 else if (unformat (i, "tcp"))
10868 transport_protocol = 6;
10869 else if (unformat (i, "udp"))
10870 transport_protocol = 17;
10873 errmsg ("unknown input `%U'", format_unformat_error, i);
10880 errmsg ("expecting: add|del");
10883 if (classify_table_index == ~0)
10885 errmsg ("classifier table not specified");
10888 if (ip_version == 0)
10890 errmsg ("IP version not specified");
10894 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10896 mp->is_add = is_add;
10897 mp->table_id = htonl (classify_table_index);
10898 mp->ip_version = ip_version;
10899 mp->transport_protocol = transport_protocol;
10907 api_get_node_index (vat_main_t * vam)
10909 unformat_input_t *i = vam->input;
10910 vl_api_get_node_index_t *mp;
10914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10916 if (unformat (i, "node %s", &name))
10923 errmsg ("node name required");
10926 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10928 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10932 M (GET_NODE_INDEX, mp);
10933 clib_memcpy (mp->node_name, name, vec_len (name));
10942 api_get_next_index (vat_main_t * vam)
10944 unformat_input_t *i = vam->input;
10945 vl_api_get_next_index_t *mp;
10946 u8 *node_name = 0, *next_node_name = 0;
10949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10951 if (unformat (i, "node-name %s", &node_name))
10953 else if (unformat (i, "next-node-name %s", &next_node_name))
10957 if (node_name == 0)
10959 errmsg ("node name required");
10962 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10964 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10968 if (next_node_name == 0)
10970 errmsg ("next node name required");
10973 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10975 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10979 M (GET_NEXT_INDEX, mp);
10980 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10981 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10982 vec_free (node_name);
10983 vec_free (next_node_name);
10991 api_add_node_next (vat_main_t * vam)
10993 unformat_input_t *i = vam->input;
10994 vl_api_add_node_next_t *mp;
10999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11001 if (unformat (i, "node %s", &name))
11003 else if (unformat (i, "next %s", &next))
11010 errmsg ("node name required");
11013 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11015 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11020 errmsg ("next node required");
11023 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11025 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11029 M (ADD_NODE_NEXT, mp);
11030 clib_memcpy (mp->node_name, name, vec_len (name));
11031 clib_memcpy (mp->next_name, next, vec_len (next));
11041 api_l2tpv3_create_tunnel (vat_main_t * vam)
11043 unformat_input_t *i = vam->input;
11044 ip6_address_t client_address, our_address;
11045 int client_address_set = 0;
11046 int our_address_set = 0;
11047 u32 local_session_id = 0;
11048 u32 remote_session_id = 0;
11049 u64 local_cookie = 0;
11050 u64 remote_cookie = 0;
11051 u8 l2_sublayer_present = 0;
11052 vl_api_l2tpv3_create_tunnel_t *mp;
11055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11057 if (unformat (i, "client_address %U", unformat_ip6_address,
11059 client_address_set = 1;
11060 else if (unformat (i, "our_address %U", unformat_ip6_address,
11062 our_address_set = 1;
11063 else if (unformat (i, "local_session_id %d", &local_session_id))
11065 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11067 else if (unformat (i, "local_cookie %lld", &local_cookie))
11069 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11071 else if (unformat (i, "l2-sublayer-present"))
11072 l2_sublayer_present = 1;
11077 if (client_address_set == 0)
11079 errmsg ("client_address required");
11083 if (our_address_set == 0)
11085 errmsg ("our_address required");
11089 M (L2TPV3_CREATE_TUNNEL, mp);
11091 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11092 sizeof (ip6_address_t));
11094 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11095 sizeof (ip6_address_t));
11097 mp->local_session_id = ntohl (local_session_id);
11098 mp->remote_session_id = ntohl (remote_session_id);
11099 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11100 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11101 mp->l2_sublayer_present = l2_sublayer_present;
11109 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11111 unformat_input_t *i = vam->input;
11113 u8 sw_if_index_set = 0;
11114 u64 new_local_cookie = 0;
11115 u64 new_remote_cookie = 0;
11116 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11121 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11122 sw_if_index_set = 1;
11123 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11124 sw_if_index_set = 1;
11125 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11127 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11133 if (sw_if_index_set == 0)
11135 errmsg ("missing interface name or sw_if_index");
11139 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11141 mp->sw_if_index = ntohl (sw_if_index);
11142 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11143 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11151 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11153 unformat_input_t *i = vam->input;
11154 vl_api_l2tpv3_interface_enable_disable_t *mp;
11156 u8 sw_if_index_set = 0;
11157 u8 enable_disable = 1;
11160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11163 sw_if_index_set = 1;
11164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11165 sw_if_index_set = 1;
11166 else if (unformat (i, "enable"))
11167 enable_disable = 1;
11168 else if (unformat (i, "disable"))
11169 enable_disable = 0;
11174 if (sw_if_index_set == 0)
11176 errmsg ("missing interface name or sw_if_index");
11180 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11182 mp->sw_if_index = ntohl (sw_if_index);
11183 mp->enable_disable = enable_disable;
11191 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11193 unformat_input_t *i = vam->input;
11194 vl_api_l2tpv3_set_lookup_key_t *mp;
11198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11200 if (unformat (i, "lookup_v6_src"))
11201 key = L2T_LOOKUP_SRC_ADDRESS;
11202 else if (unformat (i, "lookup_v6_dst"))
11203 key = L2T_LOOKUP_DST_ADDRESS;
11204 else if (unformat (i, "lookup_session_id"))
11205 key = L2T_LOOKUP_SESSION_ID;
11210 if (key == (u8) ~ 0)
11212 errmsg ("l2tp session lookup key unset");
11216 M (L2TPV3_SET_LOOKUP_KEY, mp);
11225 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11226 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11228 vat_main_t *vam = &vat_main;
11230 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11231 format_ip6_address, mp->our_address,
11232 format_ip6_address, mp->client_address,
11233 clib_net_to_host_u32 (mp->sw_if_index));
11236 " local cookies %016llx %016llx remote cookie %016llx",
11237 clib_net_to_host_u64 (mp->local_cookie[0]),
11238 clib_net_to_host_u64 (mp->local_cookie[1]),
11239 clib_net_to_host_u64 (mp->remote_cookie));
11241 print (vam->ofp, " local session-id %d remote session-id %d",
11242 clib_net_to_host_u32 (mp->local_session_id),
11243 clib_net_to_host_u32 (mp->remote_session_id));
11245 print (vam->ofp, " l2 specific sublayer %s\n",
11246 mp->l2_sublayer_present ? "preset" : "absent");
11250 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11251 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11253 vat_main_t *vam = &vat_main;
11254 vat_json_node_t *node = NULL;
11255 struct in6_addr addr;
11257 if (VAT_JSON_ARRAY != vam->json_tree.type)
11259 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11260 vat_json_init_array (&vam->json_tree);
11262 node = vat_json_array_add (&vam->json_tree);
11264 vat_json_init_object (node);
11266 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11267 vat_json_object_add_ip6 (node, "our_address", addr);
11268 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11269 vat_json_object_add_ip6 (node, "client_address", addr);
11271 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11272 vat_json_init_array (lc);
11273 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11274 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11275 vat_json_object_add_uint (node, "remote_cookie",
11276 clib_net_to_host_u64 (mp->remote_cookie));
11278 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11279 vat_json_object_add_uint (node, "local_session_id",
11280 clib_net_to_host_u32 (mp->local_session_id));
11281 vat_json_object_add_uint (node, "remote_session_id",
11282 clib_net_to_host_u32 (mp->remote_session_id));
11283 vat_json_object_add_string_copy (node, "l2_sublayer",
11284 mp->l2_sublayer_present ? (u8 *) "present"
11285 : (u8 *) "absent");
11289 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11291 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11292 vl_api_control_ping_t *mp_ping;
11295 /* Get list of l2tpv3-tunnel interfaces */
11296 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11299 /* Use a control ping for synchronization */
11300 MPING (CONTROL_PING, mp_ping);
11308 static void vl_api_sw_interface_tap_v2_details_t_handler
11309 (vl_api_sw_interface_tap_v2_details_t * mp)
11311 vat_main_t *vam = &vat_main;
11314 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11315 mp->host_ip4_prefix.len);
11317 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11318 mp->host_ip6_prefix.len);
11321 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11322 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11323 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11324 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11325 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11331 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11332 (vl_api_sw_interface_tap_v2_details_t * mp)
11334 vat_main_t *vam = &vat_main;
11335 vat_json_node_t *node = NULL;
11337 if (VAT_JSON_ARRAY != vam->json_tree.type)
11339 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11340 vat_json_init_array (&vam->json_tree);
11342 node = vat_json_array_add (&vam->json_tree);
11344 vat_json_init_object (node);
11345 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11346 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11347 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11348 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11349 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11350 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11351 vat_json_object_add_string_copy (node, "host_mac_addr",
11352 format (0, "%U", format_ethernet_address,
11353 &mp->host_mac_addr));
11354 vat_json_object_add_string_copy (node, "host_namespace",
11355 mp->host_namespace);
11356 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11357 vat_json_object_add_string_copy (node, "host_ip4_addr",
11358 format (0, "%U/%d", format_ip4_address,
11359 mp->host_ip4_prefix.address,
11360 mp->host_ip4_prefix.len));
11361 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11362 format (0, "%U/%d", format_ip6_address,
11363 mp->host_ip6_prefix.address,
11364 mp->host_ip6_prefix.len));
11369 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11371 vl_api_sw_interface_tap_v2_dump_t *mp;
11372 vl_api_control_ping_t *mp_ping;
11376 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11377 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11378 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11381 /* Get list of tap interfaces */
11382 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11385 /* Use a control ping for synchronization */
11386 MPING (CONTROL_PING, mp_ping);
11393 static void vl_api_sw_interface_virtio_pci_details_t_handler
11394 (vl_api_sw_interface_virtio_pci_details_t * mp)
11396 vat_main_t *vam = &vat_main;
11411 addr.domain = ntohs (mp->pci_addr.domain);
11412 addr.bus = mp->pci_addr.bus;
11413 addr.slot = mp->pci_addr.slot;
11414 addr.function = mp->pci_addr.function;
11416 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11417 addr.slot, addr.function);
11420 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11421 pci_addr, ntohl (mp->sw_if_index),
11422 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11423 format_ethernet_address, mp->mac_addr,
11424 clib_net_to_host_u64 (mp->features));
11425 vec_free (pci_addr);
11428 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11429 (vl_api_sw_interface_virtio_pci_details_t * mp)
11431 vat_main_t *vam = &vat_main;
11432 vat_json_node_t *node = NULL;
11433 vlib_pci_addr_t pci_addr;
11435 if (VAT_JSON_ARRAY != vam->json_tree.type)
11437 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11438 vat_json_init_array (&vam->json_tree);
11440 node = vat_json_array_add (&vam->json_tree);
11442 pci_addr.domain = ntohs (mp->pci_addr.domain);
11443 pci_addr.bus = mp->pci_addr.bus;
11444 pci_addr.slot = mp->pci_addr.slot;
11445 pci_addr.function = mp->pci_addr.function;
11447 vat_json_init_object (node);
11448 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11449 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11450 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11451 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11452 vat_json_object_add_uint (node, "features",
11453 clib_net_to_host_u64 (mp->features));
11454 vat_json_object_add_string_copy (node, "mac_addr",
11455 format (0, "%U", format_ethernet_address,
11460 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11462 vl_api_sw_interface_virtio_pci_dump_t *mp;
11463 vl_api_control_ping_t *mp_ping;
11467 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11468 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11469 "mac_addr", "features");
11471 /* Get list of tap interfaces */
11472 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11475 /* Use a control ping for synchronization */
11476 MPING (CONTROL_PING, mp_ping);
11484 api_vxlan_offload_rx (vat_main_t * vam)
11486 unformat_input_t *line_input = vam->input;
11487 vl_api_vxlan_offload_rx_t *mp;
11488 u32 hw_if_index = ~0, rx_if_index = ~0;
11492 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11494 if (unformat (line_input, "del"))
11496 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11499 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11501 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11504 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11508 errmsg ("parse error '%U'", format_unformat_error, line_input);
11513 if (hw_if_index == ~0)
11515 errmsg ("no hw interface");
11519 if (rx_if_index == ~0)
11521 errmsg ("no rx tunnel");
11525 M (VXLAN_OFFLOAD_RX, mp);
11527 mp->hw_if_index = ntohl (hw_if_index);
11528 mp->sw_if_index = ntohl (rx_if_index);
11529 mp->enable = is_add;
11536 static uword unformat_vxlan_decap_next
11537 (unformat_input_t * input, va_list * args)
11539 u32 *result = va_arg (*args, u32 *);
11542 if (unformat (input, "l2"))
11543 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11544 else if (unformat (input, "%d", &tmp))
11552 api_vxlan_add_del_tunnel (vat_main_t * vam)
11554 unformat_input_t *line_input = vam->input;
11555 vl_api_vxlan_add_del_tunnel_t *mp;
11556 ip46_address_t src, dst;
11558 u8 ipv4_set = 0, ipv6_set = 0;
11563 u32 mcast_sw_if_index = ~0;
11564 u32 encap_vrf_id = 0;
11565 u32 decap_next_index = ~0;
11569 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11570 clib_memset (&src, 0, sizeof src);
11571 clib_memset (&dst, 0, sizeof dst);
11573 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11575 if (unformat (line_input, "del"))
11577 else if (unformat (line_input, "instance %d", &instance))
11580 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11586 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11592 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11598 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11603 else if (unformat (line_input, "group %U %U",
11604 unformat_ip4_address, &dst.ip4,
11605 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11607 grp_set = dst_set = 1;
11610 else if (unformat (line_input, "group %U",
11611 unformat_ip4_address, &dst.ip4))
11613 grp_set = dst_set = 1;
11616 else if (unformat (line_input, "group %U %U",
11617 unformat_ip6_address, &dst.ip6,
11618 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11620 grp_set = dst_set = 1;
11623 else if (unformat (line_input, "group %U",
11624 unformat_ip6_address, &dst.ip6))
11626 grp_set = dst_set = 1;
11630 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11632 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11634 else if (unformat (line_input, "decap-next %U",
11635 unformat_vxlan_decap_next, &decap_next_index))
11637 else if (unformat (line_input, "vni %d", &vni))
11641 errmsg ("parse error '%U'", format_unformat_error, line_input);
11648 errmsg ("tunnel src address not specified");
11653 errmsg ("tunnel dst address not specified");
11657 if (grp_set && !ip46_address_is_multicast (&dst))
11659 errmsg ("tunnel group address not multicast");
11662 if (grp_set && mcast_sw_if_index == ~0)
11664 errmsg ("tunnel nonexistent multicast device");
11667 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11669 errmsg ("tunnel dst address must be unicast");
11674 if (ipv4_set && ipv6_set)
11676 errmsg ("both IPv4 and IPv6 addresses specified");
11680 if ((vni == 0) || (vni >> 24))
11682 errmsg ("vni not specified or out of range");
11686 M (VXLAN_ADD_DEL_TUNNEL, mp);
11690 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11691 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11695 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11696 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11699 mp->instance = htonl (instance);
11700 mp->encap_vrf_id = ntohl (encap_vrf_id);
11701 mp->decap_next_index = ntohl (decap_next_index);
11702 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11703 mp->vni = ntohl (vni);
11704 mp->is_add = is_add;
11705 mp->is_ipv6 = ipv6_set;
11712 static void vl_api_vxlan_tunnel_details_t_handler
11713 (vl_api_vxlan_tunnel_details_t * mp)
11715 vat_main_t *vam = &vat_main;
11716 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11717 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11719 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11720 ntohl (mp->sw_if_index),
11721 ntohl (mp->instance),
11722 format_ip46_address, &src, IP46_TYPE_ANY,
11723 format_ip46_address, &dst, IP46_TYPE_ANY,
11724 ntohl (mp->encap_vrf_id),
11725 ntohl (mp->decap_next_index), ntohl (mp->vni),
11726 ntohl (mp->mcast_sw_if_index));
11729 static void vl_api_vxlan_tunnel_details_t_handler_json
11730 (vl_api_vxlan_tunnel_details_t * mp)
11732 vat_main_t *vam = &vat_main;
11733 vat_json_node_t *node = NULL;
11735 if (VAT_JSON_ARRAY != vam->json_tree.type)
11737 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11738 vat_json_init_array (&vam->json_tree);
11740 node = vat_json_array_add (&vam->json_tree);
11742 vat_json_init_object (node);
11743 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11745 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11749 struct in6_addr ip6;
11751 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11752 vat_json_object_add_ip6 (node, "src_address", ip6);
11753 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11754 vat_json_object_add_ip6 (node, "dst_address", ip6);
11758 struct in_addr ip4;
11760 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11761 vat_json_object_add_ip4 (node, "src_address", ip4);
11762 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11763 vat_json_object_add_ip4 (node, "dst_address", ip4);
11765 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11766 vat_json_object_add_uint (node, "decap_next_index",
11767 ntohl (mp->decap_next_index));
11768 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11769 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11770 vat_json_object_add_uint (node, "mcast_sw_if_index",
11771 ntohl (mp->mcast_sw_if_index));
11775 api_vxlan_tunnel_dump (vat_main_t * vam)
11777 unformat_input_t *i = vam->input;
11778 vl_api_vxlan_tunnel_dump_t *mp;
11779 vl_api_control_ping_t *mp_ping;
11781 u8 sw_if_index_set = 0;
11784 /* Parse args required to build the message */
11785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11787 if (unformat (i, "sw_if_index %d", &sw_if_index))
11788 sw_if_index_set = 1;
11793 if (sw_if_index_set == 0)
11798 if (!vam->json_output)
11800 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11801 "sw_if_index", "instance", "src_address", "dst_address",
11802 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11805 /* Get list of vxlan-tunnel interfaces */
11806 M (VXLAN_TUNNEL_DUMP, mp);
11808 mp->sw_if_index = htonl (sw_if_index);
11812 /* Use a control ping for synchronization */
11813 MPING (CONTROL_PING, mp_ping);
11820 static uword unformat_geneve_decap_next
11821 (unformat_input_t * input, va_list * args)
11823 u32 *result = va_arg (*args, u32 *);
11826 if (unformat (input, "l2"))
11827 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11828 else if (unformat (input, "%d", &tmp))
11836 api_geneve_add_del_tunnel (vat_main_t * vam)
11838 unformat_input_t *line_input = vam->input;
11839 vl_api_geneve_add_del_tunnel_t *mp;
11840 ip46_address_t src, dst;
11842 u8 ipv4_set = 0, ipv6_set = 0;
11846 u32 mcast_sw_if_index = ~0;
11847 u32 encap_vrf_id = 0;
11848 u32 decap_next_index = ~0;
11852 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11853 clib_memset (&src, 0, sizeof src);
11854 clib_memset (&dst, 0, sizeof dst);
11856 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11858 if (unformat (line_input, "del"))
11861 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11867 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11873 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11879 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11884 else if (unformat (line_input, "group %U %U",
11885 unformat_ip4_address, &dst.ip4,
11886 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11888 grp_set = dst_set = 1;
11891 else if (unformat (line_input, "group %U",
11892 unformat_ip4_address, &dst.ip4))
11894 grp_set = dst_set = 1;
11897 else if (unformat (line_input, "group %U %U",
11898 unformat_ip6_address, &dst.ip6,
11899 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11901 grp_set = dst_set = 1;
11904 else if (unformat (line_input, "group %U",
11905 unformat_ip6_address, &dst.ip6))
11907 grp_set = dst_set = 1;
11911 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11913 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11915 else if (unformat (line_input, "decap-next %U",
11916 unformat_geneve_decap_next, &decap_next_index))
11918 else if (unformat (line_input, "vni %d", &vni))
11922 errmsg ("parse error '%U'", format_unformat_error, line_input);
11929 errmsg ("tunnel src address not specified");
11934 errmsg ("tunnel dst address not specified");
11938 if (grp_set && !ip46_address_is_multicast (&dst))
11940 errmsg ("tunnel group address not multicast");
11943 if (grp_set && mcast_sw_if_index == ~0)
11945 errmsg ("tunnel nonexistent multicast device");
11948 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11950 errmsg ("tunnel dst address must be unicast");
11955 if (ipv4_set && ipv6_set)
11957 errmsg ("both IPv4 and IPv6 addresses specified");
11961 if ((vni == 0) || (vni >> 24))
11963 errmsg ("vni not specified or out of range");
11967 M (GENEVE_ADD_DEL_TUNNEL, mp);
11971 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
11972 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11976 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
11977 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11979 mp->encap_vrf_id = ntohl (encap_vrf_id);
11980 mp->decap_next_index = ntohl (decap_next_index);
11981 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11982 mp->vni = ntohl (vni);
11983 mp->is_add = is_add;
11990 static void vl_api_geneve_tunnel_details_t_handler
11991 (vl_api_geneve_tunnel_details_t * mp)
11993 vat_main_t *vam = &vat_main;
11994 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
11995 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
11997 if (mp->src_address.af == ADDRESS_IP6)
11999 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12000 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12004 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12005 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12008 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12009 ntohl (mp->sw_if_index),
12010 format_ip46_address, &src, IP46_TYPE_ANY,
12011 format_ip46_address, &dst, IP46_TYPE_ANY,
12012 ntohl (mp->encap_vrf_id),
12013 ntohl (mp->decap_next_index), ntohl (mp->vni),
12014 ntohl (mp->mcast_sw_if_index));
12017 static void vl_api_geneve_tunnel_details_t_handler_json
12018 (vl_api_geneve_tunnel_details_t * mp)
12020 vat_main_t *vam = &vat_main;
12021 vat_json_node_t *node = NULL;
12024 if (VAT_JSON_ARRAY != vam->json_tree.type)
12026 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12027 vat_json_init_array (&vam->json_tree);
12029 node = vat_json_array_add (&vam->json_tree);
12031 vat_json_init_object (node);
12032 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12033 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12036 struct in6_addr ip6;
12038 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12039 vat_json_object_add_ip6 (node, "src_address", ip6);
12040 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12041 vat_json_object_add_ip6 (node, "dst_address", ip6);
12045 struct in_addr ip4;
12047 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12048 vat_json_object_add_ip4 (node, "src_address", ip4);
12049 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12050 vat_json_object_add_ip4 (node, "dst_address", ip4);
12052 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12053 vat_json_object_add_uint (node, "decap_next_index",
12054 ntohl (mp->decap_next_index));
12055 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12056 vat_json_object_add_uint (node, "mcast_sw_if_index",
12057 ntohl (mp->mcast_sw_if_index));
12061 api_geneve_tunnel_dump (vat_main_t * vam)
12063 unformat_input_t *i = vam->input;
12064 vl_api_geneve_tunnel_dump_t *mp;
12065 vl_api_control_ping_t *mp_ping;
12067 u8 sw_if_index_set = 0;
12070 /* Parse args required to build the message */
12071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12073 if (unformat (i, "sw_if_index %d", &sw_if_index))
12074 sw_if_index_set = 1;
12079 if (sw_if_index_set == 0)
12084 if (!vam->json_output)
12086 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12087 "sw_if_index", "local_address", "remote_address",
12088 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12091 /* Get list of geneve-tunnel interfaces */
12092 M (GENEVE_TUNNEL_DUMP, mp);
12094 mp->sw_if_index = htonl (sw_if_index);
12098 /* Use a control ping for synchronization */
12099 M (CONTROL_PING, mp_ping);
12107 api_gre_tunnel_add_del (vat_main_t * vam)
12109 unformat_input_t *line_input = vam->input;
12110 vl_api_address_t src = { }, dst =
12113 vl_api_gre_tunnel_add_del_t *mp;
12114 vl_api_gre_tunnel_type_t t_type;
12118 u32 outer_table_id = 0;
12119 u32 session_id = 0;
12123 t_type = GRE_API_TUNNEL_TYPE_L3;
12125 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12127 if (unformat (line_input, "del"))
12129 else if (unformat (line_input, "instance %d", &instance))
12131 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12135 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12139 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12141 else if (unformat (line_input, "teb"))
12142 t_type = GRE_API_TUNNEL_TYPE_TEB;
12143 else if (unformat (line_input, "erspan %d", &session_id))
12144 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12147 errmsg ("parse error '%U'", format_unformat_error, line_input);
12154 errmsg ("tunnel src address not specified");
12159 errmsg ("tunnel dst address not specified");
12163 M (GRE_TUNNEL_ADD_DEL, mp);
12165 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12166 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12168 mp->tunnel.instance = htonl (instance);
12169 mp->tunnel.outer_table_id = htonl (outer_table_id);
12170 mp->is_add = is_add;
12171 mp->tunnel.session_id = htons ((u16) session_id);
12172 mp->tunnel.type = htonl (t_type);
12179 static void vl_api_gre_tunnel_details_t_handler
12180 (vl_api_gre_tunnel_details_t * mp)
12182 vat_main_t *vam = &vat_main;
12184 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12185 ntohl (mp->tunnel.sw_if_index),
12186 ntohl (mp->tunnel.instance),
12187 format_vl_api_address, &mp->tunnel.src,
12188 format_vl_api_address, &mp->tunnel.dst,
12189 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12190 ntohl (mp->tunnel.session_id));
12193 static void vl_api_gre_tunnel_details_t_handler_json
12194 (vl_api_gre_tunnel_details_t * mp)
12196 vat_main_t *vam = &vat_main;
12197 vat_json_node_t *node = NULL;
12199 if (VAT_JSON_ARRAY != vam->json_tree.type)
12201 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12202 vat_json_init_array (&vam->json_tree);
12204 node = vat_json_array_add (&vam->json_tree);
12206 vat_json_init_object (node);
12207 vat_json_object_add_uint (node, "sw_if_index",
12208 ntohl (mp->tunnel.sw_if_index));
12209 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12211 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12212 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12213 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12214 vat_json_object_add_uint (node, "outer_table_id",
12215 ntohl (mp->tunnel.outer_table_id));
12216 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12220 api_gre_tunnel_dump (vat_main_t * vam)
12222 unformat_input_t *i = vam->input;
12223 vl_api_gre_tunnel_dump_t *mp;
12224 vl_api_control_ping_t *mp_ping;
12226 u8 sw_if_index_set = 0;
12229 /* Parse args required to build the message */
12230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12232 if (unformat (i, "sw_if_index %d", &sw_if_index))
12233 sw_if_index_set = 1;
12238 if (sw_if_index_set == 0)
12243 if (!vam->json_output)
12245 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12246 "sw_if_index", "instance", "src_address", "dst_address",
12247 "tunnel_type", "outer_fib_id", "session_id");
12250 /* Get list of gre-tunnel interfaces */
12251 M (GRE_TUNNEL_DUMP, mp);
12253 mp->sw_if_index = htonl (sw_if_index);
12257 /* Use a control ping for synchronization */
12258 MPING (CONTROL_PING, mp_ping);
12266 api_l2_fib_clear_table (vat_main_t * vam)
12268 // unformat_input_t * i = vam->input;
12269 vl_api_l2_fib_clear_table_t *mp;
12272 M (L2_FIB_CLEAR_TABLE, mp);
12280 api_l2_interface_efp_filter (vat_main_t * vam)
12282 unformat_input_t *i = vam->input;
12283 vl_api_l2_interface_efp_filter_t *mp;
12286 u8 sw_if_index_set = 0;
12289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12291 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12292 sw_if_index_set = 1;
12293 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12294 sw_if_index_set = 1;
12295 else if (unformat (i, "enable"))
12297 else if (unformat (i, "disable"))
12301 clib_warning ("parse error '%U'", format_unformat_error, i);
12306 if (sw_if_index_set == 0)
12308 errmsg ("missing sw_if_index");
12312 M (L2_INTERFACE_EFP_FILTER, mp);
12314 mp->sw_if_index = ntohl (sw_if_index);
12315 mp->enable_disable = enable;
12322 #define foreach_vtr_op \
12323 _("disable", L2_VTR_DISABLED) \
12324 _("push-1", L2_VTR_PUSH_1) \
12325 _("push-2", L2_VTR_PUSH_2) \
12326 _("pop-1", L2_VTR_POP_1) \
12327 _("pop-2", L2_VTR_POP_2) \
12328 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12329 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12330 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12331 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12334 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12336 unformat_input_t *i = vam->input;
12337 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12339 u8 sw_if_index_set = 0;
12342 u32 push_dot1q = 1;
12347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12349 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12350 sw_if_index_set = 1;
12351 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12352 sw_if_index_set = 1;
12353 else if (unformat (i, "vtr_op %d", &vtr_op))
12355 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12358 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12360 else if (unformat (i, "tag1 %d", &tag1))
12362 else if (unformat (i, "tag2 %d", &tag2))
12366 clib_warning ("parse error '%U'", format_unformat_error, i);
12371 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12373 errmsg ("missing vtr operation or sw_if_index");
12377 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12378 mp->sw_if_index = ntohl (sw_if_index);
12379 mp->vtr_op = ntohl (vtr_op);
12380 mp->push_dot1q = ntohl (push_dot1q);
12381 mp->tag1 = ntohl (tag1);
12382 mp->tag2 = ntohl (tag2);
12390 api_create_vhost_user_if (vat_main_t * vam)
12392 unformat_input_t *i = vam->input;
12393 vl_api_create_vhost_user_if_t *mp;
12396 u8 file_name_set = 0;
12397 u32 custom_dev_instance = ~0;
12399 u8 use_custom_mac = 0;
12400 u8 disable_mrg_rxbuf = 0;
12401 u8 disable_indirect_desc = 0;
12406 /* Shut up coverity */
12407 clib_memset (hwaddr, 0, sizeof (hwaddr));
12409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12411 if (unformat (i, "socket %s", &file_name))
12415 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12417 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12418 use_custom_mac = 1;
12419 else if (unformat (i, "server"))
12421 else if (unformat (i, "disable_mrg_rxbuf"))
12422 disable_mrg_rxbuf = 1;
12423 else if (unformat (i, "disable_indirect_desc"))
12424 disable_indirect_desc = 1;
12425 else if (unformat (i, "gso"))
12427 else if (unformat (i, "tag %s", &tag))
12433 if (file_name_set == 0)
12435 errmsg ("missing socket file name");
12439 if (vec_len (file_name) > 255)
12441 errmsg ("socket file name too long");
12444 vec_add1 (file_name, 0);
12446 M (CREATE_VHOST_USER_IF, mp);
12448 mp->is_server = is_server;
12449 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12450 mp->disable_indirect_desc = disable_indirect_desc;
12451 mp->enable_gso = enable_gso;
12452 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12453 vec_free (file_name);
12454 if (custom_dev_instance != ~0)
12457 mp->custom_dev_instance = ntohl (custom_dev_instance);
12460 mp->use_custom_mac = use_custom_mac;
12461 clib_memcpy (mp->mac_address, hwaddr, 6);
12463 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12472 api_modify_vhost_user_if (vat_main_t * vam)
12474 unformat_input_t *i = vam->input;
12475 vl_api_modify_vhost_user_if_t *mp;
12478 u8 file_name_set = 0;
12479 u32 custom_dev_instance = ~0;
12480 u8 sw_if_index_set = 0;
12481 u32 sw_if_index = (u32) ~ 0;
12485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12487 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12488 sw_if_index_set = 1;
12489 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12490 sw_if_index_set = 1;
12491 else if (unformat (i, "socket %s", &file_name))
12495 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12497 else if (unformat (i, "server"))
12499 else if (unformat (i, "gso"))
12505 if (sw_if_index_set == 0)
12507 errmsg ("missing sw_if_index or interface name");
12511 if (file_name_set == 0)
12513 errmsg ("missing socket file name");
12517 if (vec_len (file_name) > 255)
12519 errmsg ("socket file name too long");
12522 vec_add1 (file_name, 0);
12524 M (MODIFY_VHOST_USER_IF, mp);
12526 mp->sw_if_index = ntohl (sw_if_index);
12527 mp->is_server = is_server;
12528 mp->enable_gso = enable_gso;
12529 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12530 vec_free (file_name);
12531 if (custom_dev_instance != ~0)
12534 mp->custom_dev_instance = ntohl (custom_dev_instance);
12543 api_delete_vhost_user_if (vat_main_t * vam)
12545 unformat_input_t *i = vam->input;
12546 vl_api_delete_vhost_user_if_t *mp;
12547 u32 sw_if_index = ~0;
12548 u8 sw_if_index_set = 0;
12551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12553 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12554 sw_if_index_set = 1;
12555 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12556 sw_if_index_set = 1;
12561 if (sw_if_index_set == 0)
12563 errmsg ("missing sw_if_index or interface name");
12568 M (DELETE_VHOST_USER_IF, mp);
12570 mp->sw_if_index = ntohl (sw_if_index);
12577 static void vl_api_sw_interface_vhost_user_details_t_handler
12578 (vl_api_sw_interface_vhost_user_details_t * mp)
12580 vat_main_t *vam = &vat_main;
12584 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12585 clib_net_to_host_u32
12586 (mp->features_last_32) <<
12589 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12590 (char *) mp->interface_name,
12591 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12592 features, mp->is_server,
12593 ntohl (mp->num_regions), (char *) mp->sock_filename);
12594 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12597 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12598 (vl_api_sw_interface_vhost_user_details_t * mp)
12600 vat_main_t *vam = &vat_main;
12601 vat_json_node_t *node = NULL;
12603 if (VAT_JSON_ARRAY != vam->json_tree.type)
12605 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12606 vat_json_init_array (&vam->json_tree);
12608 node = vat_json_array_add (&vam->json_tree);
12610 vat_json_init_object (node);
12611 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12612 vat_json_object_add_string_copy (node, "interface_name",
12613 mp->interface_name);
12614 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12615 ntohl (mp->virtio_net_hdr_sz));
12616 vat_json_object_add_uint (node, "features_first_32",
12617 clib_net_to_host_u32 (mp->features_first_32));
12618 vat_json_object_add_uint (node, "features_last_32",
12619 clib_net_to_host_u32 (mp->features_last_32));
12620 vat_json_object_add_uint (node, "is_server", mp->is_server);
12621 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12622 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12623 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12627 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12629 vl_api_sw_interface_vhost_user_dump_t *mp;
12630 vl_api_control_ping_t *mp_ping;
12633 "Interface name idx hdr_sz features server regions filename");
12635 /* Get list of vhost-user interfaces */
12636 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12637 mp->sw_if_index = ntohl (~0);
12640 /* Use a control ping for synchronization */
12641 MPING (CONTROL_PING, mp_ping);
12649 api_show_version (vat_main_t * vam)
12651 vl_api_show_version_t *mp;
12654 M (SHOW_VERSION, mp);
12663 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12665 unformat_input_t *line_input = vam->input;
12666 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12667 ip4_address_t local4, remote4;
12668 ip6_address_t local6, remote6;
12670 u8 ipv4_set = 0, ipv6_set = 0;
12674 u32 mcast_sw_if_index = ~0;
12675 u32 encap_vrf_id = 0;
12676 u32 decap_vrf_id = 0;
12682 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12683 clib_memset (&local4, 0, sizeof local4);
12684 clib_memset (&remote4, 0, sizeof remote4);
12685 clib_memset (&local6, 0, sizeof local6);
12686 clib_memset (&remote6, 0, sizeof remote6);
12688 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12690 if (unformat (line_input, "del"))
12692 else if (unformat (line_input, "local %U",
12693 unformat_ip4_address, &local4))
12698 else if (unformat (line_input, "remote %U",
12699 unformat_ip4_address, &remote4))
12704 else if (unformat (line_input, "local %U",
12705 unformat_ip6_address, &local6))
12710 else if (unformat (line_input, "remote %U",
12711 unformat_ip6_address, &remote6))
12716 else if (unformat (line_input, "group %U %U",
12717 unformat_ip4_address, &remote4,
12718 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12720 grp_set = remote_set = 1;
12723 else if (unformat (line_input, "group %U",
12724 unformat_ip4_address, &remote4))
12726 grp_set = remote_set = 1;
12729 else if (unformat (line_input, "group %U %U",
12730 unformat_ip6_address, &remote6,
12731 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12733 grp_set = remote_set = 1;
12736 else if (unformat (line_input, "group %U",
12737 unformat_ip6_address, &remote6))
12739 grp_set = remote_set = 1;
12743 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12745 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12747 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12749 else if (unformat (line_input, "vni %d", &vni))
12751 else if (unformat (line_input, "next-ip4"))
12753 else if (unformat (line_input, "next-ip6"))
12755 else if (unformat (line_input, "next-ethernet"))
12757 else if (unformat (line_input, "next-nsh"))
12761 errmsg ("parse error '%U'", format_unformat_error, line_input);
12766 if (local_set == 0)
12768 errmsg ("tunnel local address not specified");
12771 if (remote_set == 0)
12773 errmsg ("tunnel remote address not specified");
12776 if (grp_set && mcast_sw_if_index == ~0)
12778 errmsg ("tunnel nonexistent multicast device");
12781 if (ipv4_set && ipv6_set)
12783 errmsg ("both IPv4 and IPv6 addresses specified");
12789 errmsg ("vni not specified");
12793 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12798 clib_memcpy (&mp->local, &local6, sizeof (local6));
12799 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12803 clib_memcpy (&mp->local, &local4, sizeof (local4));
12804 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12807 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12808 mp->encap_vrf_id = ntohl (encap_vrf_id);
12809 mp->decap_vrf_id = ntohl (decap_vrf_id);
12810 mp->protocol = protocol;
12811 mp->vni = ntohl (vni);
12812 mp->is_add = is_add;
12813 mp->is_ipv6 = ipv6_set;
12820 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12821 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12823 vat_main_t *vam = &vat_main;
12824 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12825 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12827 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12828 ntohl (mp->sw_if_index),
12829 format_ip46_address, &local, IP46_TYPE_ANY,
12830 format_ip46_address, &remote, IP46_TYPE_ANY,
12831 ntohl (mp->vni), mp->protocol,
12832 ntohl (mp->mcast_sw_if_index),
12833 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12837 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12838 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12840 vat_main_t *vam = &vat_main;
12841 vat_json_node_t *node = NULL;
12842 struct in_addr ip4;
12843 struct in6_addr ip6;
12845 if (VAT_JSON_ARRAY != vam->json_tree.type)
12847 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12848 vat_json_init_array (&vam->json_tree);
12850 node = vat_json_array_add (&vam->json_tree);
12852 vat_json_init_object (node);
12853 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12856 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12857 vat_json_object_add_ip6 (node, "local", ip6);
12858 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12859 vat_json_object_add_ip6 (node, "remote", ip6);
12863 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12864 vat_json_object_add_ip4 (node, "local", ip4);
12865 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12866 vat_json_object_add_ip4 (node, "remote", ip4);
12868 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12869 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12870 vat_json_object_add_uint (node, "mcast_sw_if_index",
12871 ntohl (mp->mcast_sw_if_index));
12872 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12873 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12874 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12878 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12880 unformat_input_t *i = vam->input;
12881 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12882 vl_api_control_ping_t *mp_ping;
12884 u8 sw_if_index_set = 0;
12887 /* Parse args required to build the message */
12888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12890 if (unformat (i, "sw_if_index %d", &sw_if_index))
12891 sw_if_index_set = 1;
12896 if (sw_if_index_set == 0)
12901 if (!vam->json_output)
12903 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12904 "sw_if_index", "local", "remote", "vni",
12905 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12908 /* Get list of vxlan-tunnel interfaces */
12909 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12911 mp->sw_if_index = htonl (sw_if_index);
12915 /* Use a control ping for synchronization */
12916 MPING (CONTROL_PING, mp_ping);
12923 static void vl_api_l2_fib_table_details_t_handler
12924 (vl_api_l2_fib_table_details_t * mp)
12926 vat_main_t *vam = &vat_main;
12928 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12930 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12931 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12935 static void vl_api_l2_fib_table_details_t_handler_json
12936 (vl_api_l2_fib_table_details_t * mp)
12938 vat_main_t *vam = &vat_main;
12939 vat_json_node_t *node = NULL;
12941 if (VAT_JSON_ARRAY != vam->json_tree.type)
12943 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12944 vat_json_init_array (&vam->json_tree);
12946 node = vat_json_array_add (&vam->json_tree);
12948 vat_json_init_object (node);
12949 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12950 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12951 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12952 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12953 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12954 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12958 api_l2_fib_table_dump (vat_main_t * vam)
12960 unformat_input_t *i = vam->input;
12961 vl_api_l2_fib_table_dump_t *mp;
12962 vl_api_control_ping_t *mp_ping;
12967 /* Parse args required to build the message */
12968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12970 if (unformat (i, "bd_id %d", &bd_id))
12976 if (bd_id_set == 0)
12978 errmsg ("missing bridge domain");
12982 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12984 /* Get list of l2 fib entries */
12985 M (L2_FIB_TABLE_DUMP, mp);
12987 mp->bd_id = ntohl (bd_id);
12990 /* Use a control ping for synchronization */
12991 MPING (CONTROL_PING, mp_ping);
13000 api_interface_name_renumber (vat_main_t * vam)
13002 unformat_input_t *line_input = vam->input;
13003 vl_api_interface_name_renumber_t *mp;
13004 u32 sw_if_index = ~0;
13005 u32 new_show_dev_instance = ~0;
13008 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13010 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13013 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13015 else if (unformat (line_input, "new_show_dev_instance %d",
13016 &new_show_dev_instance))
13022 if (sw_if_index == ~0)
13024 errmsg ("missing interface name or sw_if_index");
13028 if (new_show_dev_instance == ~0)
13030 errmsg ("missing new_show_dev_instance");
13034 M (INTERFACE_NAME_RENUMBER, mp);
13036 mp->sw_if_index = ntohl (sw_if_index);
13037 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13045 api_want_l2_macs_events (vat_main_t * vam)
13047 unformat_input_t *line_input = vam->input;
13048 vl_api_want_l2_macs_events_t *mp;
13049 u8 enable_disable = 1;
13050 u32 scan_delay = 0;
13051 u32 max_macs_in_event = 0;
13052 u32 learn_limit = 0;
13055 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13057 if (unformat (line_input, "learn-limit %d", &learn_limit))
13059 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13061 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13063 else if (unformat (line_input, "disable"))
13064 enable_disable = 0;
13069 M (WANT_L2_MACS_EVENTS, mp);
13070 mp->enable_disable = enable_disable;
13071 mp->pid = htonl (getpid ());
13072 mp->learn_limit = htonl (learn_limit);
13073 mp->scan_delay = (u8) scan_delay;
13074 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13081 api_input_acl_set_interface (vat_main_t * vam)
13083 unformat_input_t *i = vam->input;
13084 vl_api_input_acl_set_interface_t *mp;
13086 int sw_if_index_set;
13087 u32 ip4_table_index = ~0;
13088 u32 ip6_table_index = ~0;
13089 u32 l2_table_index = ~0;
13093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13095 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13096 sw_if_index_set = 1;
13097 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13098 sw_if_index_set = 1;
13099 else if (unformat (i, "del"))
13101 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13103 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13105 else if (unformat (i, "l2-table %d", &l2_table_index))
13109 clib_warning ("parse error '%U'", format_unformat_error, i);
13114 if (sw_if_index_set == 0)
13116 errmsg ("missing interface name or sw_if_index");
13120 M (INPUT_ACL_SET_INTERFACE, mp);
13122 mp->sw_if_index = ntohl (sw_if_index);
13123 mp->ip4_table_index = ntohl (ip4_table_index);
13124 mp->ip6_table_index = ntohl (ip6_table_index);
13125 mp->l2_table_index = ntohl (l2_table_index);
13126 mp->is_add = is_add;
13134 api_output_acl_set_interface (vat_main_t * vam)
13136 unformat_input_t *i = vam->input;
13137 vl_api_output_acl_set_interface_t *mp;
13139 int sw_if_index_set;
13140 u32 ip4_table_index = ~0;
13141 u32 ip6_table_index = ~0;
13142 u32 l2_table_index = ~0;
13146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13148 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13149 sw_if_index_set = 1;
13150 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13151 sw_if_index_set = 1;
13152 else if (unformat (i, "del"))
13154 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13156 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13158 else if (unformat (i, "l2-table %d", &l2_table_index))
13162 clib_warning ("parse error '%U'", format_unformat_error, i);
13167 if (sw_if_index_set == 0)
13169 errmsg ("missing interface name or sw_if_index");
13173 M (OUTPUT_ACL_SET_INTERFACE, mp);
13175 mp->sw_if_index = ntohl (sw_if_index);
13176 mp->ip4_table_index = ntohl (ip4_table_index);
13177 mp->ip6_table_index = ntohl (ip6_table_index);
13178 mp->l2_table_index = ntohl (l2_table_index);
13179 mp->is_add = is_add;
13187 api_ip_address_dump (vat_main_t * vam)
13189 unformat_input_t *i = vam->input;
13190 vl_api_ip_address_dump_t *mp;
13191 vl_api_control_ping_t *mp_ping;
13192 u32 sw_if_index = ~0;
13193 u8 sw_if_index_set = 0;
13198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13200 if (unformat (i, "sw_if_index %d", &sw_if_index))
13201 sw_if_index_set = 1;
13203 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13204 sw_if_index_set = 1;
13205 else if (unformat (i, "ipv4"))
13207 else if (unformat (i, "ipv6"))
13213 if (ipv4_set && ipv6_set)
13215 errmsg ("ipv4 and ipv6 flags cannot be both set");
13219 if ((!ipv4_set) && (!ipv6_set))
13221 errmsg ("no ipv4 nor ipv6 flag set");
13225 if (sw_if_index_set == 0)
13227 errmsg ("missing interface name or sw_if_index");
13231 vam->current_sw_if_index = sw_if_index;
13232 vam->is_ipv6 = ipv6_set;
13234 M (IP_ADDRESS_DUMP, mp);
13235 mp->sw_if_index = ntohl (sw_if_index);
13236 mp->is_ipv6 = ipv6_set;
13239 /* Use a control ping for synchronization */
13240 MPING (CONTROL_PING, mp_ping);
13248 api_ip_dump (vat_main_t * vam)
13250 vl_api_ip_dump_t *mp;
13251 vl_api_control_ping_t *mp_ping;
13252 unformat_input_t *in = vam->input;
13259 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13261 if (unformat (in, "ipv4"))
13263 else if (unformat (in, "ipv6"))
13269 if (ipv4_set && ipv6_set)
13271 errmsg ("ipv4 and ipv6 flags cannot be both set");
13275 if ((!ipv4_set) && (!ipv6_set))
13277 errmsg ("no ipv4 nor ipv6 flag set");
13281 is_ipv6 = ipv6_set;
13282 vam->is_ipv6 = is_ipv6;
13284 /* free old data */
13285 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13287 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13289 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13292 mp->is_ipv6 = ipv6_set;
13295 /* Use a control ping for synchronization */
13296 MPING (CONTROL_PING, mp_ping);
13304 api_ipsec_spd_add_del (vat_main_t * vam)
13306 unformat_input_t *i = vam->input;
13307 vl_api_ipsec_spd_add_del_t *mp;
13312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13314 if (unformat (i, "spd_id %d", &spd_id))
13316 else if (unformat (i, "del"))
13320 clib_warning ("parse error '%U'", format_unformat_error, i);
13326 errmsg ("spd_id must be set");
13330 M (IPSEC_SPD_ADD_DEL, mp);
13332 mp->spd_id = ntohl (spd_id);
13333 mp->is_add = is_add;
13341 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13343 unformat_input_t *i = vam->input;
13344 vl_api_ipsec_interface_add_del_spd_t *mp;
13346 u8 sw_if_index_set = 0;
13347 u32 spd_id = (u32) ~ 0;
13351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13353 if (unformat (i, "del"))
13355 else if (unformat (i, "spd_id %d", &spd_id))
13358 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13359 sw_if_index_set = 1;
13360 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13361 sw_if_index_set = 1;
13364 clib_warning ("parse error '%U'", format_unformat_error, i);
13370 if (spd_id == (u32) ~ 0)
13372 errmsg ("spd_id must be set");
13376 if (sw_if_index_set == 0)
13378 errmsg ("missing interface name or sw_if_index");
13382 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13384 mp->spd_id = ntohl (spd_id);
13385 mp->sw_if_index = ntohl (sw_if_index);
13386 mp->is_add = is_add;
13394 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13396 unformat_input_t *i = vam->input;
13397 vl_api_ipsec_spd_entry_add_del_t *mp;
13398 u8 is_add = 1, is_outbound = 0;
13399 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13401 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13402 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13403 vl_api_address_t laddr_start = { }, laddr_stop =
13412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13414 if (unformat (i, "del"))
13416 if (unformat (i, "outbound"))
13418 if (unformat (i, "inbound"))
13420 else if (unformat (i, "spd_id %d", &spd_id))
13422 else if (unformat (i, "sa_id %d", &sa_id))
13424 else if (unformat (i, "priority %d", &priority))
13426 else if (unformat (i, "protocol %d", &protocol))
13428 else if (unformat (i, "lport_start %d", &lport_start))
13430 else if (unformat (i, "lport_stop %d", &lport_stop))
13432 else if (unformat (i, "rport_start %d", &rport_start))
13434 else if (unformat (i, "rport_stop %d", &rport_stop))
13436 else if (unformat (i, "laddr_start %U",
13437 unformat_vl_api_address, &laddr_start))
13439 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13442 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13445 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13449 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13451 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13453 clib_warning ("unsupported action: 'resolve'");
13459 clib_warning ("parse error '%U'", format_unformat_error, i);
13465 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13467 mp->is_add = is_add;
13469 mp->entry.spd_id = ntohl (spd_id);
13470 mp->entry.priority = ntohl (priority);
13471 mp->entry.is_outbound = is_outbound;
13473 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13474 sizeof (vl_api_address_t));
13475 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13476 sizeof (vl_api_address_t));
13477 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13478 sizeof (vl_api_address_t));
13479 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13480 sizeof (vl_api_address_t));
13482 mp->entry.protocol = (u8) protocol;
13483 mp->entry.local_port_start = ntohs ((u16) lport_start);
13484 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13485 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13486 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13487 mp->entry.policy = (u8) policy;
13488 mp->entry.sa_id = ntohl (sa_id);
13496 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13498 unformat_input_t *i = vam->input;
13499 vl_api_ipsec_sad_entry_add_del_t *mp;
13500 u32 sad_id = 0, spi = 0;
13501 u8 *ck = 0, *ik = 0;
13504 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13505 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13506 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13507 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13508 vl_api_address_t tun_src, tun_dst;
13511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13513 if (unformat (i, "del"))
13515 else if (unformat (i, "sad_id %d", &sad_id))
13517 else if (unformat (i, "spi %d", &spi))
13519 else if (unformat (i, "esp"))
13520 protocol = IPSEC_API_PROTO_ESP;
13522 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13524 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13525 if (ADDRESS_IP6 == tun_src.af)
13526 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13529 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13531 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13532 if (ADDRESS_IP6 == tun_src.af)
13533 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13536 if (unformat (i, "crypto_alg %U",
13537 unformat_ipsec_api_crypto_alg, &crypto_alg))
13539 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13541 else if (unformat (i, "integ_alg %U",
13542 unformat_ipsec_api_integ_alg, &integ_alg))
13544 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13548 clib_warning ("parse error '%U'", format_unformat_error, i);
13554 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13556 mp->is_add = is_add;
13557 mp->entry.sad_id = ntohl (sad_id);
13558 mp->entry.protocol = protocol;
13559 mp->entry.spi = ntohl (spi);
13560 mp->entry.flags = flags;
13562 mp->entry.crypto_algorithm = crypto_alg;
13563 mp->entry.integrity_algorithm = integ_alg;
13564 mp->entry.crypto_key.length = vec_len (ck);
13565 mp->entry.integrity_key.length = vec_len (ik);
13567 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13568 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13570 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13571 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13574 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13576 clib_memcpy (mp->entry.integrity_key.data, ik,
13577 mp->entry.integrity_key.length);
13579 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13581 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13582 sizeof (mp->entry.tunnel_src));
13583 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13584 sizeof (mp->entry.tunnel_dst));
13593 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13595 unformat_input_t *i = vam->input;
13596 vl_api_ipsec_tunnel_if_add_del_t *mp;
13597 u32 local_spi = 0, remote_spi = 0;
13598 u32 crypto_alg = 0, integ_alg = 0;
13599 u8 *lck = NULL, *rck = NULL;
13600 u8 *lik = NULL, *rik = NULL;
13601 vl_api_address_t local_ip = { 0 };
13602 vl_api_address_t remote_ip = { 0 };
13606 u8 anti_replay = 0;
13612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13614 if (unformat (i, "del"))
13616 else if (unformat (i, "esn"))
13618 else if (unformat (i, "anti-replay"))
13620 else if (unformat (i, "count %d", &count))
13622 else if (unformat (i, "local_spi %d", &local_spi))
13624 else if (unformat (i, "remote_spi %d", &remote_spi))
13627 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13630 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13632 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13635 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13637 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13639 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13643 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13645 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13647 errmsg ("unsupported crypto-alg: '%U'\n",
13648 format_ipsec_crypto_alg, crypto_alg);
13654 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13656 if (integ_alg >= IPSEC_INTEG_N_ALG)
13658 errmsg ("unsupported integ-alg: '%U'\n",
13659 format_ipsec_integ_alg, integ_alg);
13663 else if (unformat (i, "instance %u", &instance))
13667 errmsg ("parse error '%U'\n", format_unformat_error, i);
13674 /* Turn on async mode */
13675 vam->async_mode = 1;
13676 vam->async_errors = 0;
13677 before = vat_time_now (vam);
13680 for (jj = 0; jj < count; jj++)
13682 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13684 mp->is_add = is_add;
13686 mp->anti_replay = anti_replay;
13689 increment_address (&remote_ip);
13691 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13692 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13694 mp->local_spi = htonl (local_spi + jj);
13695 mp->remote_spi = htonl (remote_spi + jj);
13696 mp->crypto_alg = (u8) crypto_alg;
13698 mp->local_crypto_key_len = 0;
13701 mp->local_crypto_key_len = vec_len (lck);
13702 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13703 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13704 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13707 mp->remote_crypto_key_len = 0;
13710 mp->remote_crypto_key_len = vec_len (rck);
13711 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13712 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13713 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13716 mp->integ_alg = (u8) integ_alg;
13718 mp->local_integ_key_len = 0;
13721 mp->local_integ_key_len = vec_len (lik);
13722 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13723 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13724 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13727 mp->remote_integ_key_len = 0;
13730 mp->remote_integ_key_len = vec_len (rik);
13731 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13732 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13733 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13738 mp->renumber = renumber;
13739 mp->show_instance = ntohl (instance);
13744 /* When testing multiple add/del ops, use a control-ping to sync */
13747 vl_api_control_ping_t *mp_ping;
13751 /* Shut off async mode */
13752 vam->async_mode = 0;
13754 MPING (CONTROL_PING, mp_ping);
13757 timeout = vat_time_now (vam) + 1.0;
13758 while (vat_time_now (vam) < timeout)
13759 if (vam->result_ready == 1)
13764 if (vam->retval == -99)
13765 errmsg ("timeout");
13767 if (vam->async_errors > 0)
13769 errmsg ("%d asynchronous errors", vam->async_errors);
13772 vam->async_errors = 0;
13773 after = vat_time_now (vam);
13775 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13779 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13780 count, after - before, count / (after - before));
13784 /* Wait for a reply... */
13793 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13795 vat_main_t *vam = &vat_main;
13797 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13798 "crypto_key %U integ_alg %u integ_key %U flags %x "
13799 "tunnel_src_addr %U tunnel_dst_addr %U "
13800 "salt %u seq_outbound %lu last_seq_inbound %lu "
13801 "replay_window %lu\n",
13802 ntohl (mp->entry.sad_id),
13803 ntohl (mp->sw_if_index),
13804 ntohl (mp->entry.spi),
13805 ntohl (mp->entry.protocol),
13806 ntohl (mp->entry.crypto_algorithm),
13807 format_hex_bytes, mp->entry.crypto_key.data,
13808 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13809 format_hex_bytes, mp->entry.integrity_key.data,
13810 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13811 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13812 &mp->entry.tunnel_dst, ntohl (mp->salt),
13813 clib_net_to_host_u64 (mp->seq_outbound),
13814 clib_net_to_host_u64 (mp->last_seq_inbound),
13815 clib_net_to_host_u64 (mp->replay_window));
13818 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13819 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13821 static void vl_api_ipsec_sa_details_t_handler_json
13822 (vl_api_ipsec_sa_details_t * mp)
13824 vat_main_t *vam = &vat_main;
13825 vat_json_node_t *node = NULL;
13826 vl_api_ipsec_sad_flags_t flags;
13828 if (VAT_JSON_ARRAY != vam->json_tree.type)
13830 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13831 vat_json_init_array (&vam->json_tree);
13833 node = vat_json_array_add (&vam->json_tree);
13835 vat_json_init_object (node);
13836 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13837 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13838 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13839 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13840 vat_json_object_add_uint (node, "crypto_alg",
13841 ntohl (mp->entry.crypto_algorithm));
13842 vat_json_object_add_uint (node, "integ_alg",
13843 ntohl (mp->entry.integrity_algorithm));
13844 flags = ntohl (mp->entry.flags);
13845 vat_json_object_add_uint (node, "use_esn",
13846 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13847 vat_json_object_add_uint (node, "use_anti_replay",
13848 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13849 vat_json_object_add_uint (node, "is_tunnel",
13850 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13851 vat_json_object_add_uint (node, "is_tunnel_ip6",
13852 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13853 vat_json_object_add_uint (node, "udp_encap",
13854 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13855 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13856 mp->entry.crypto_key.length);
13857 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13858 mp->entry.integrity_key.length);
13859 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13860 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13861 vat_json_object_add_uint (node, "replay_window",
13862 clib_net_to_host_u64 (mp->replay_window));
13866 api_ipsec_sa_dump (vat_main_t * vam)
13868 unformat_input_t *i = vam->input;
13869 vl_api_ipsec_sa_dump_t *mp;
13870 vl_api_control_ping_t *mp_ping;
13874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13876 if (unformat (i, "sa_id %d", &sa_id))
13880 clib_warning ("parse error '%U'", format_unformat_error, i);
13885 M (IPSEC_SA_DUMP, mp);
13887 mp->sa_id = ntohl (sa_id);
13891 /* Use a control ping for synchronization */
13892 M (CONTROL_PING, mp_ping);
13900 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13902 unformat_input_t *i = vam->input;
13903 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13904 u32 sw_if_index = ~0;
13906 u8 is_outbound = (u8) ~ 0;
13909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13911 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13913 else if (unformat (i, "sa_id %d", &sa_id))
13915 else if (unformat (i, "outbound"))
13917 else if (unformat (i, "inbound"))
13921 clib_warning ("parse error '%U'", format_unformat_error, i);
13926 if (sw_if_index == ~0)
13928 errmsg ("interface must be specified");
13934 errmsg ("SA ID must be specified");
13938 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13940 mp->sw_if_index = htonl (sw_if_index);
13941 mp->sa_id = htonl (sa_id);
13942 mp->is_outbound = is_outbound;
13951 api_get_first_msg_id (vat_main_t * vam)
13953 vl_api_get_first_msg_id_t *mp;
13954 unformat_input_t *i = vam->input;
13959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13961 if (unformat (i, "client %s", &name))
13969 errmsg ("missing client name");
13972 vec_add1 (name, 0);
13974 if (vec_len (name) > 63)
13976 errmsg ("client name too long");
13980 M (GET_FIRST_MSG_ID, mp);
13981 clib_memcpy (mp->name, name, vec_len (name));
13988 api_cop_interface_enable_disable (vat_main_t * vam)
13990 unformat_input_t *line_input = vam->input;
13991 vl_api_cop_interface_enable_disable_t *mp;
13992 u32 sw_if_index = ~0;
13993 u8 enable_disable = 1;
13996 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13998 if (unformat (line_input, "disable"))
13999 enable_disable = 0;
14000 if (unformat (line_input, "enable"))
14001 enable_disable = 1;
14002 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14003 vam, &sw_if_index))
14005 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14011 if (sw_if_index == ~0)
14013 errmsg ("missing interface name or sw_if_index");
14017 /* Construct the API message */
14018 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14019 mp->sw_if_index = ntohl (sw_if_index);
14020 mp->enable_disable = enable_disable;
14024 /* Wait for the reply */
14030 api_cop_whitelist_enable_disable (vat_main_t * vam)
14032 unformat_input_t *line_input = vam->input;
14033 vl_api_cop_whitelist_enable_disable_t *mp;
14034 u32 sw_if_index = ~0;
14035 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14039 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14041 if (unformat (line_input, "ip4"))
14043 else if (unformat (line_input, "ip6"))
14045 else if (unformat (line_input, "default"))
14047 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14048 vam, &sw_if_index))
14050 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14052 else if (unformat (line_input, "fib-id %d", &fib_id))
14058 if (sw_if_index == ~0)
14060 errmsg ("missing interface name or sw_if_index");
14064 /* Construct the API message */
14065 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14066 mp->sw_if_index = ntohl (sw_if_index);
14067 mp->fib_id = ntohl (fib_id);
14070 mp->default_cop = default_cop;
14074 /* Wait for the reply */
14080 api_get_node_graph (vat_main_t * vam)
14082 vl_api_get_node_graph_t *mp;
14085 M (GET_NODE_GRAPH, mp);
14089 /* Wait for the reply */
14095 /** Used for parsing LISP eids */
14096 typedef CLIB_PACKED(struct{
14097 u8 addr[16]; /**< eid address */
14098 u32 len; /**< prefix length if IP */
14099 u8 type; /**< type of eid */
14104 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14106 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14108 clib_memset (a, 0, sizeof (a[0]));
14110 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14112 a->type = 0; /* ipv4 type */
14114 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14116 a->type = 1; /* ipv6 type */
14118 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14120 a->type = 2; /* mac type */
14122 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14124 a->type = 3; /* NSH type */
14125 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14126 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14133 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14142 lisp_eid_size_vat (u8 type)
14159 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14161 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14165 api_one_add_del_locator_set (vat_main_t * vam)
14167 unformat_input_t *input = vam->input;
14168 vl_api_one_add_del_locator_set_t *mp;
14170 u8 *locator_set_name = NULL;
14171 u8 locator_set_name_set = 0;
14172 vl_api_local_locator_t locator, *locators = 0;
14173 u32 sw_if_index, priority, weight;
14177 /* Parse args required to build the message */
14178 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14180 if (unformat (input, "del"))
14184 else if (unformat (input, "locator-set %s", &locator_set_name))
14186 locator_set_name_set = 1;
14188 else if (unformat (input, "sw_if_index %u p %u w %u",
14189 &sw_if_index, &priority, &weight))
14191 locator.sw_if_index = htonl (sw_if_index);
14192 locator.priority = priority;
14193 locator.weight = weight;
14194 vec_add1 (locators, locator);
14198 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14199 &sw_if_index, &priority, &weight))
14201 locator.sw_if_index = htonl (sw_if_index);
14202 locator.priority = priority;
14203 locator.weight = weight;
14204 vec_add1 (locators, locator);
14210 if (locator_set_name_set == 0)
14212 errmsg ("missing locator-set name");
14213 vec_free (locators);
14217 if (vec_len (locator_set_name) > 64)
14219 errmsg ("locator-set name too long");
14220 vec_free (locator_set_name);
14221 vec_free (locators);
14224 vec_add1 (locator_set_name, 0);
14226 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14228 /* Construct the API message */
14229 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14231 mp->is_add = is_add;
14232 clib_memcpy (mp->locator_set_name, locator_set_name,
14233 vec_len (locator_set_name));
14234 vec_free (locator_set_name);
14236 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14238 clib_memcpy (mp->locators, locators, data_len);
14239 vec_free (locators);
14244 /* Wait for a reply... */
14249 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14252 api_one_add_del_locator (vat_main_t * vam)
14254 unformat_input_t *input = vam->input;
14255 vl_api_one_add_del_locator_t *mp;
14256 u32 tmp_if_index = ~0;
14257 u32 sw_if_index = ~0;
14258 u8 sw_if_index_set = 0;
14259 u8 sw_if_index_if_name_set = 0;
14261 u8 priority_set = 0;
14265 u8 *locator_set_name = NULL;
14266 u8 locator_set_name_set = 0;
14269 /* Parse args required to build the message */
14270 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14272 if (unformat (input, "del"))
14276 else if (unformat (input, "locator-set %s", &locator_set_name))
14278 locator_set_name_set = 1;
14280 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14283 sw_if_index_if_name_set = 1;
14284 sw_if_index = tmp_if_index;
14286 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14288 sw_if_index_set = 1;
14289 sw_if_index = tmp_if_index;
14291 else if (unformat (input, "p %d", &priority))
14295 else if (unformat (input, "w %d", &weight))
14303 if (locator_set_name_set == 0)
14305 errmsg ("missing locator-set name");
14309 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14311 errmsg ("missing sw_if_index");
14312 vec_free (locator_set_name);
14316 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14318 errmsg ("cannot use both params interface name and sw_if_index");
14319 vec_free (locator_set_name);
14323 if (priority_set == 0)
14325 errmsg ("missing locator-set priority");
14326 vec_free (locator_set_name);
14330 if (weight_set == 0)
14332 errmsg ("missing locator-set weight");
14333 vec_free (locator_set_name);
14337 if (vec_len (locator_set_name) > 64)
14339 errmsg ("locator-set name too long");
14340 vec_free (locator_set_name);
14343 vec_add1 (locator_set_name, 0);
14345 /* Construct the API message */
14346 M (ONE_ADD_DEL_LOCATOR, mp);
14348 mp->is_add = is_add;
14349 mp->sw_if_index = ntohl (sw_if_index);
14350 mp->priority = priority;
14351 mp->weight = weight;
14352 clib_memcpy (mp->locator_set_name, locator_set_name,
14353 vec_len (locator_set_name));
14354 vec_free (locator_set_name);
14359 /* Wait for a reply... */
14364 #define api_lisp_add_del_locator api_one_add_del_locator
14367 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14369 u32 *key_id = va_arg (*args, u32 *);
14372 if (unformat (input, "%s", &s))
14374 if (!strcmp ((char *) s, "sha1"))
14375 key_id[0] = HMAC_SHA_1_96;
14376 else if (!strcmp ((char *) s, "sha256"))
14377 key_id[0] = HMAC_SHA_256_128;
14380 clib_warning ("invalid key_id: '%s'", s);
14381 key_id[0] = HMAC_NO_KEY;
14392 api_one_add_del_local_eid (vat_main_t * vam)
14394 unformat_input_t *input = vam->input;
14395 vl_api_one_add_del_local_eid_t *mp;
14398 lisp_eid_vat_t _eid, *eid = &_eid;
14399 u8 *locator_set_name = 0;
14400 u8 locator_set_name_set = 0;
14406 /* Parse args required to build the message */
14407 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14409 if (unformat (input, "del"))
14413 else if (unformat (input, "vni %d", &vni))
14417 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14421 else if (unformat (input, "locator-set %s", &locator_set_name))
14423 locator_set_name_set = 1;
14425 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14427 else if (unformat (input, "secret-key %_%v%_", &key))
14433 if (locator_set_name_set == 0)
14435 errmsg ("missing locator-set name");
14441 errmsg ("EID address not set!");
14442 vec_free (locator_set_name);
14446 if (key && (0 == key_id))
14448 errmsg ("invalid key_id!");
14452 if (vec_len (key) > 64)
14454 errmsg ("key too long");
14459 if (vec_len (locator_set_name) > 64)
14461 errmsg ("locator-set name too long");
14462 vec_free (locator_set_name);
14465 vec_add1 (locator_set_name, 0);
14467 /* Construct the API message */
14468 M (ONE_ADD_DEL_LOCAL_EID, mp);
14470 mp->is_add = is_add;
14471 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14472 mp->eid_type = eid->type;
14473 mp->prefix_len = eid->len;
14474 mp->vni = clib_host_to_net_u32 (vni);
14475 mp->key_id = clib_host_to_net_u16 (key_id);
14476 clib_memcpy (mp->locator_set_name, locator_set_name,
14477 vec_len (locator_set_name));
14478 clib_memcpy (mp->key, key, vec_len (key));
14480 vec_free (locator_set_name);
14486 /* Wait for a reply... */
14491 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14494 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14496 u32 dp_table = 0, vni = 0;;
14497 unformat_input_t *input = vam->input;
14498 vl_api_gpe_add_del_fwd_entry_t *mp;
14500 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14501 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14502 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14503 u32 action = ~0, w;
14504 ip4_address_t rmt_rloc4, lcl_rloc4;
14505 ip6_address_t rmt_rloc6, lcl_rloc6;
14506 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14509 clib_memset (&rloc, 0, sizeof (rloc));
14511 /* Parse args required to build the message */
14512 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14514 if (unformat (input, "del"))
14516 else if (unformat (input, "add"))
14518 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14522 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14526 else if (unformat (input, "vrf %d", &dp_table))
14528 else if (unformat (input, "bd %d", &dp_table))
14530 else if (unformat (input, "vni %d", &vni))
14532 else if (unformat (input, "w %d", &w))
14536 errmsg ("No RLOC configured for setting priority/weight!");
14539 curr_rloc->weight = w;
14541 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14542 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14546 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14548 vec_add1 (lcl_locs, rloc);
14550 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14551 vec_add1 (rmt_locs, rloc);
14552 /* weight saved in rmt loc */
14553 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14555 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14556 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14559 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14561 vec_add1 (lcl_locs, rloc);
14563 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14564 vec_add1 (rmt_locs, rloc);
14565 /* weight saved in rmt loc */
14566 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14568 else if (unformat (input, "action %d", &action))
14574 clib_warning ("parse error '%U'", format_unformat_error, input);
14581 errmsg ("remote eid addresses not set");
14585 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14587 errmsg ("eid types don't match");
14591 if (0 == rmt_locs && (u32) ~ 0 == action)
14593 errmsg ("action not set for negative mapping");
14597 /* Construct the API message */
14598 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14599 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14601 mp->is_add = is_add;
14602 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14603 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14604 mp->eid_type = rmt_eid->type;
14605 mp->dp_table = clib_host_to_net_u32 (dp_table);
14606 mp->vni = clib_host_to_net_u32 (vni);
14607 mp->rmt_len = rmt_eid->len;
14608 mp->lcl_len = lcl_eid->len;
14609 mp->action = action;
14611 if (0 != rmt_locs && 0 != lcl_locs)
14613 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14614 clib_memcpy (mp->locs, lcl_locs,
14615 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14617 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14618 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14619 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14621 vec_free (lcl_locs);
14622 vec_free (rmt_locs);
14627 /* Wait for a reply... */
14633 api_one_add_del_map_server (vat_main_t * vam)
14635 unformat_input_t *input = vam->input;
14636 vl_api_one_add_del_map_server_t *mp;
14640 ip4_address_t ipv4;
14641 ip6_address_t ipv6;
14644 /* Parse args required to build the message */
14645 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14647 if (unformat (input, "del"))
14651 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14655 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14663 if (ipv4_set && ipv6_set)
14665 errmsg ("both eid v4 and v6 addresses set");
14669 if (!ipv4_set && !ipv6_set)
14671 errmsg ("eid addresses not set");
14675 /* Construct the API message */
14676 M (ONE_ADD_DEL_MAP_SERVER, mp);
14678 mp->is_add = is_add;
14682 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14687 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14693 /* Wait for a reply... */
14698 #define api_lisp_add_del_map_server api_one_add_del_map_server
14701 api_one_add_del_map_resolver (vat_main_t * vam)
14703 unformat_input_t *input = vam->input;
14704 vl_api_one_add_del_map_resolver_t *mp;
14708 ip4_address_t ipv4;
14709 ip6_address_t ipv6;
14712 /* Parse args required to build the message */
14713 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14715 if (unformat (input, "del"))
14719 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14723 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14731 if (ipv4_set && ipv6_set)
14733 errmsg ("both eid v4 and v6 addresses set");
14737 if (!ipv4_set && !ipv6_set)
14739 errmsg ("eid addresses not set");
14743 /* Construct the API message */
14744 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14746 mp->is_add = is_add;
14750 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14755 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14761 /* Wait for a reply... */
14766 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14769 api_lisp_gpe_enable_disable (vat_main_t * vam)
14771 unformat_input_t *input = vam->input;
14772 vl_api_gpe_enable_disable_t *mp;
14777 /* Parse args required to build the message */
14778 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14780 if (unformat (input, "enable"))
14785 else if (unformat (input, "disable"))
14796 errmsg ("Value not set");
14800 /* Construct the API message */
14801 M (GPE_ENABLE_DISABLE, mp);
14808 /* Wait for a reply... */
14814 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14816 unformat_input_t *input = vam->input;
14817 vl_api_one_rloc_probe_enable_disable_t *mp;
14822 /* Parse args required to build the message */
14823 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14825 if (unformat (input, "enable"))
14830 else if (unformat (input, "disable"))
14838 errmsg ("Value not set");
14842 /* Construct the API message */
14843 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14845 mp->is_enabled = is_en;
14850 /* Wait for a reply... */
14855 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14858 api_one_map_register_enable_disable (vat_main_t * vam)
14860 unformat_input_t *input = vam->input;
14861 vl_api_one_map_register_enable_disable_t *mp;
14866 /* Parse args required to build the message */
14867 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14869 if (unformat (input, "enable"))
14874 else if (unformat (input, "disable"))
14882 errmsg ("Value not set");
14886 /* Construct the API message */
14887 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14889 mp->is_enabled = is_en;
14894 /* Wait for a reply... */
14899 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14902 api_one_enable_disable (vat_main_t * vam)
14904 unformat_input_t *input = vam->input;
14905 vl_api_one_enable_disable_t *mp;
14910 /* Parse args required to build the message */
14911 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14913 if (unformat (input, "enable"))
14918 else if (unformat (input, "disable"))
14928 errmsg ("Value not set");
14932 /* Construct the API message */
14933 M (ONE_ENABLE_DISABLE, mp);
14940 /* Wait for a reply... */
14945 #define api_lisp_enable_disable api_one_enable_disable
14948 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14950 unformat_input_t *input = vam->input;
14951 vl_api_one_enable_disable_xtr_mode_t *mp;
14956 /* Parse args required to build the message */
14957 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14959 if (unformat (input, "enable"))
14964 else if (unformat (input, "disable"))
14974 errmsg ("Value not set");
14978 /* Construct the API message */
14979 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
14986 /* Wait for a reply... */
14992 api_one_show_xtr_mode (vat_main_t * vam)
14994 vl_api_one_show_xtr_mode_t *mp;
14997 /* Construct the API message */
14998 M (ONE_SHOW_XTR_MODE, mp);
15003 /* Wait for a reply... */
15009 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15011 unformat_input_t *input = vam->input;
15012 vl_api_one_enable_disable_pitr_mode_t *mp;
15017 /* Parse args required to build the message */
15018 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15020 if (unformat (input, "enable"))
15025 else if (unformat (input, "disable"))
15035 errmsg ("Value not set");
15039 /* Construct the API message */
15040 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15047 /* Wait for a reply... */
15053 api_one_show_pitr_mode (vat_main_t * vam)
15055 vl_api_one_show_pitr_mode_t *mp;
15058 /* Construct the API message */
15059 M (ONE_SHOW_PITR_MODE, mp);
15064 /* Wait for a reply... */
15070 api_one_enable_disable_petr_mode (vat_main_t * vam)
15072 unformat_input_t *input = vam->input;
15073 vl_api_one_enable_disable_petr_mode_t *mp;
15078 /* Parse args required to build the message */
15079 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15081 if (unformat (input, "enable"))
15086 else if (unformat (input, "disable"))
15096 errmsg ("Value not set");
15100 /* Construct the API message */
15101 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15108 /* Wait for a reply... */
15114 api_one_show_petr_mode (vat_main_t * vam)
15116 vl_api_one_show_petr_mode_t *mp;
15119 /* Construct the API message */
15120 M (ONE_SHOW_PETR_MODE, mp);
15125 /* Wait for a reply... */
15131 api_show_one_map_register_state (vat_main_t * vam)
15133 vl_api_show_one_map_register_state_t *mp;
15136 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15141 /* wait for reply */
15146 #define api_show_lisp_map_register_state api_show_one_map_register_state
15149 api_show_one_rloc_probe_state (vat_main_t * vam)
15151 vl_api_show_one_rloc_probe_state_t *mp;
15154 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15159 /* wait for reply */
15164 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15167 api_one_add_del_ndp_entry (vat_main_t * vam)
15169 vl_api_one_add_del_ndp_entry_t *mp;
15170 unformat_input_t *input = vam->input;
15175 u8 mac[6] = { 0, };
15176 u8 ip6[16] = { 0, };
15180 /* Parse args required to build the message */
15181 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15183 if (unformat (input, "del"))
15185 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15187 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15189 else if (unformat (input, "bd %d", &bd))
15193 errmsg ("parse error '%U'", format_unformat_error, input);
15198 if (!bd_set || !ip_set || (!mac_set && is_add))
15200 errmsg ("Missing BD, IP or MAC!");
15204 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15205 mp->is_add = is_add;
15206 clib_memcpy (mp->mac, mac, 6);
15207 mp->bd = clib_host_to_net_u32 (bd);
15208 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15213 /* wait for reply */
15219 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15221 vl_api_one_add_del_l2_arp_entry_t *mp;
15222 unformat_input_t *input = vam->input;
15227 u8 mac[6] = { 0, };
15228 u32 ip4 = 0, bd = ~0;
15231 /* Parse args required to build the message */
15232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15234 if (unformat (input, "del"))
15236 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15238 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15240 else if (unformat (input, "bd %d", &bd))
15244 errmsg ("parse error '%U'", format_unformat_error, input);
15249 if (!bd_set || !ip_set || (!mac_set && is_add))
15251 errmsg ("Missing BD, IP or MAC!");
15255 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15256 mp->is_add = is_add;
15257 clib_memcpy (mp->mac, mac, 6);
15258 mp->bd = clib_host_to_net_u32 (bd);
15264 /* wait for reply */
15270 api_one_ndp_bd_get (vat_main_t * vam)
15272 vl_api_one_ndp_bd_get_t *mp;
15275 M (ONE_NDP_BD_GET, mp);
15280 /* wait for reply */
15286 api_one_ndp_entries_get (vat_main_t * vam)
15288 vl_api_one_ndp_entries_get_t *mp;
15289 unformat_input_t *input = vam->input;
15294 /* Parse args required to build the message */
15295 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15297 if (unformat (input, "bd %d", &bd))
15301 errmsg ("parse error '%U'", format_unformat_error, input);
15308 errmsg ("Expected bridge domain!");
15312 M (ONE_NDP_ENTRIES_GET, mp);
15313 mp->bd = clib_host_to_net_u32 (bd);
15318 /* wait for reply */
15324 api_one_l2_arp_bd_get (vat_main_t * vam)
15326 vl_api_one_l2_arp_bd_get_t *mp;
15329 M (ONE_L2_ARP_BD_GET, mp);
15334 /* wait for reply */
15340 api_one_l2_arp_entries_get (vat_main_t * vam)
15342 vl_api_one_l2_arp_entries_get_t *mp;
15343 unformat_input_t *input = vam->input;
15348 /* Parse args required to build the message */
15349 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15351 if (unformat (input, "bd %d", &bd))
15355 errmsg ("parse error '%U'", format_unformat_error, input);
15362 errmsg ("Expected bridge domain!");
15366 M (ONE_L2_ARP_ENTRIES_GET, mp);
15367 mp->bd = clib_host_to_net_u32 (bd);
15372 /* wait for reply */
15378 api_one_stats_enable_disable (vat_main_t * vam)
15380 vl_api_one_stats_enable_disable_t *mp;
15381 unformat_input_t *input = vam->input;
15386 /* Parse args required to build the message */
15387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15389 if (unformat (input, "enable"))
15394 else if (unformat (input, "disable"))
15404 errmsg ("Value not set");
15408 M (ONE_STATS_ENABLE_DISABLE, mp);
15414 /* wait for reply */
15420 api_show_one_stats_enable_disable (vat_main_t * vam)
15422 vl_api_show_one_stats_enable_disable_t *mp;
15425 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15430 /* wait for reply */
15436 api_show_one_map_request_mode (vat_main_t * vam)
15438 vl_api_show_one_map_request_mode_t *mp;
15441 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15446 /* wait for reply */
15451 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15454 api_one_map_request_mode (vat_main_t * vam)
15456 unformat_input_t *input = vam->input;
15457 vl_api_one_map_request_mode_t *mp;
15461 /* Parse args required to build the message */
15462 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15464 if (unformat (input, "dst-only"))
15466 else if (unformat (input, "src-dst"))
15470 errmsg ("parse error '%U'", format_unformat_error, input);
15475 M (ONE_MAP_REQUEST_MODE, mp);
15482 /* wait for reply */
15487 #define api_lisp_map_request_mode api_one_map_request_mode
15490 * Enable/disable ONE proxy ITR.
15492 * @param vam vpp API test context
15493 * @return return code
15496 api_one_pitr_set_locator_set (vat_main_t * vam)
15498 u8 ls_name_set = 0;
15499 unformat_input_t *input = vam->input;
15500 vl_api_one_pitr_set_locator_set_t *mp;
15505 /* Parse args required to build the message */
15506 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15508 if (unformat (input, "del"))
15510 else if (unformat (input, "locator-set %s", &ls_name))
15514 errmsg ("parse error '%U'", format_unformat_error, input);
15521 errmsg ("locator-set name not set!");
15525 M (ONE_PITR_SET_LOCATOR_SET, mp);
15527 mp->is_add = is_add;
15528 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15529 vec_free (ls_name);
15534 /* wait for reply */
15539 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15542 api_one_nsh_set_locator_set (vat_main_t * vam)
15544 u8 ls_name_set = 0;
15545 unformat_input_t *input = vam->input;
15546 vl_api_one_nsh_set_locator_set_t *mp;
15551 /* Parse args required to build the message */
15552 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15554 if (unformat (input, "del"))
15556 else if (unformat (input, "ls %s", &ls_name))
15560 errmsg ("parse error '%U'", format_unformat_error, input);
15565 if (!ls_name_set && is_add)
15567 errmsg ("locator-set name not set!");
15571 M (ONE_NSH_SET_LOCATOR_SET, mp);
15573 mp->is_add = is_add;
15574 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15575 vec_free (ls_name);
15580 /* wait for reply */
15586 api_show_one_pitr (vat_main_t * vam)
15588 vl_api_show_one_pitr_t *mp;
15591 if (!vam->json_output)
15593 print (vam->ofp, "%=20s", "lisp status:");
15596 M (SHOW_ONE_PITR, mp);
15600 /* Wait for a reply... */
15605 #define api_show_lisp_pitr api_show_one_pitr
15608 api_one_use_petr (vat_main_t * vam)
15610 unformat_input_t *input = vam->input;
15611 vl_api_one_use_petr_t *mp;
15616 clib_memset (&ip, 0, sizeof (ip));
15618 /* Parse args required to build the message */
15619 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15621 if (unformat (input, "disable"))
15624 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15627 ip_addr_version (&ip) = AF_IP4;
15630 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15633 ip_addr_version (&ip) = AF_IP6;
15637 errmsg ("parse error '%U'", format_unformat_error, input);
15642 M (ONE_USE_PETR, mp);
15644 mp->is_add = is_add;
15647 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15649 clib_memcpy (mp->address, &ip, 4);
15651 clib_memcpy (mp->address, &ip, 16);
15657 /* wait for reply */
15662 #define api_lisp_use_petr api_one_use_petr
15665 api_show_one_nsh_mapping (vat_main_t * vam)
15667 vl_api_show_one_use_petr_t *mp;
15670 if (!vam->json_output)
15672 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15675 M (SHOW_ONE_NSH_MAPPING, mp);
15679 /* Wait for a reply... */
15685 api_show_one_use_petr (vat_main_t * vam)
15687 vl_api_show_one_use_petr_t *mp;
15690 if (!vam->json_output)
15692 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15695 M (SHOW_ONE_USE_PETR, mp);
15699 /* Wait for a reply... */
15704 #define api_show_lisp_use_petr api_show_one_use_petr
15707 * Add/delete mapping between vni and vrf
15710 api_one_eid_table_add_del_map (vat_main_t * vam)
15712 unformat_input_t *input = vam->input;
15713 vl_api_one_eid_table_add_del_map_t *mp;
15714 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15715 u32 vni, vrf, bd_index;
15718 /* Parse args required to build the message */
15719 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15721 if (unformat (input, "del"))
15723 else if (unformat (input, "vrf %d", &vrf))
15725 else if (unformat (input, "bd_index %d", &bd_index))
15727 else if (unformat (input, "vni %d", &vni))
15733 if (!vni_set || (!vrf_set && !bd_index_set))
15735 errmsg ("missing arguments!");
15739 if (vrf_set && bd_index_set)
15741 errmsg ("error: both vrf and bd entered!");
15745 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15747 mp->is_add = is_add;
15748 mp->vni = htonl (vni);
15749 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15750 mp->is_l2 = bd_index_set;
15755 /* wait for reply */
15760 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15763 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15765 u32 *action = va_arg (*args, u32 *);
15768 if (unformat (input, "%s", &s))
15770 if (!strcmp ((char *) s, "no-action"))
15772 else if (!strcmp ((char *) s, "natively-forward"))
15774 else if (!strcmp ((char *) s, "send-map-request"))
15776 else if (!strcmp ((char *) s, "drop"))
15780 clib_warning ("invalid action: '%s'", s);
15792 * Add/del remote mapping to/from ONE control plane
15794 * @param vam vpp API test context
15795 * @return return code
15798 api_one_add_del_remote_mapping (vat_main_t * vam)
15800 unformat_input_t *input = vam->input;
15801 vl_api_one_add_del_remote_mapping_t *mp;
15803 lisp_eid_vat_t _eid, *eid = &_eid;
15804 lisp_eid_vat_t _seid, *seid = &_seid;
15805 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15806 u32 action = ~0, p, w, data_len;
15807 ip4_address_t rloc4;
15808 ip6_address_t rloc6;
15809 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15812 clib_memset (&rloc, 0, sizeof (rloc));
15814 /* Parse args required to build the message */
15815 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15817 if (unformat (input, "del-all"))
15821 else if (unformat (input, "del"))
15825 else if (unformat (input, "add"))
15829 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15833 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15837 else if (unformat (input, "vni %d", &vni))
15841 else if (unformat (input, "p %d w %d", &p, &w))
15845 errmsg ("No RLOC configured for setting priority/weight!");
15848 curr_rloc->priority = p;
15849 curr_rloc->weight = w;
15851 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15854 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15855 vec_add1 (rlocs, rloc);
15856 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15858 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15861 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15862 vec_add1 (rlocs, rloc);
15863 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15865 else if (unformat (input, "action %U",
15866 unformat_negative_mapping_action, &action))
15872 clib_warning ("parse error '%U'", format_unformat_error, input);
15879 errmsg ("missing params!");
15883 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15885 errmsg ("no action set for negative map-reply!");
15889 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15891 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15892 mp->is_add = is_add;
15893 mp->vni = htonl (vni);
15894 mp->action = (u8) action;
15895 mp->is_src_dst = seid_set;
15896 mp->eid_len = eid->len;
15897 mp->seid_len = seid->len;
15898 mp->del_all = del_all;
15899 mp->eid_type = eid->type;
15900 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15901 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15903 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15904 clib_memcpy (mp->rlocs, rlocs, data_len);
15910 /* Wait for a reply... */
15915 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15918 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15919 * forwarding entries in data-plane accordingly.
15921 * @param vam vpp API test context
15922 * @return return code
15925 api_one_add_del_adjacency (vat_main_t * vam)
15927 unformat_input_t *input = vam->input;
15928 vl_api_one_add_del_adjacency_t *mp;
15930 ip4_address_t leid4, reid4;
15931 ip6_address_t leid6, reid6;
15932 u8 reid_mac[6] = { 0 };
15933 u8 leid_mac[6] = { 0 };
15934 u8 reid_type, leid_type;
15935 u32 leid_len = 0, reid_len = 0, len;
15939 leid_type = reid_type = (u8) ~ 0;
15941 /* Parse args required to build the message */
15942 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15944 if (unformat (input, "del"))
15948 else if (unformat (input, "add"))
15952 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15955 reid_type = 0; /* ipv4 */
15958 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15961 reid_type = 1; /* ipv6 */
15964 else if (unformat (input, "reid %U", unformat_ethernet_address,
15967 reid_type = 2; /* mac */
15969 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15972 leid_type = 0; /* ipv4 */
15975 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15978 leid_type = 1; /* ipv6 */
15981 else if (unformat (input, "leid %U", unformat_ethernet_address,
15984 leid_type = 2; /* mac */
15986 else if (unformat (input, "vni %d", &vni))
15992 errmsg ("parse error '%U'", format_unformat_error, input);
15997 if ((u8) ~ 0 == reid_type)
15999 errmsg ("missing params!");
16003 if (leid_type != reid_type)
16005 errmsg ("remote and local EIDs are of different types!");
16009 M (ONE_ADD_DEL_ADJACENCY, mp);
16010 mp->is_add = is_add;
16011 mp->vni = htonl (vni);
16012 mp->leid_len = leid_len;
16013 mp->reid_len = reid_len;
16014 mp->eid_type = reid_type;
16016 switch (mp->eid_type)
16019 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16020 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16023 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16024 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16027 clib_memcpy (mp->leid, leid_mac, 6);
16028 clib_memcpy (mp->reid, reid_mac, 6);
16031 errmsg ("unknown EID type %d!", mp->eid_type);
16038 /* Wait for a reply... */
16043 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16046 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16048 u32 *mode = va_arg (*args, u32 *);
16050 if (unformat (input, "lisp"))
16052 else if (unformat (input, "vxlan"))
16061 api_gpe_get_encap_mode (vat_main_t * vam)
16063 vl_api_gpe_get_encap_mode_t *mp;
16066 /* Construct the API message */
16067 M (GPE_GET_ENCAP_MODE, mp);
16072 /* Wait for a reply... */
16078 api_gpe_set_encap_mode (vat_main_t * vam)
16080 unformat_input_t *input = vam->input;
16081 vl_api_gpe_set_encap_mode_t *mp;
16085 /* Parse args required to build the message */
16086 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16088 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16094 /* Construct the API message */
16095 M (GPE_SET_ENCAP_MODE, mp);
16102 /* Wait for a reply... */
16108 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16110 unformat_input_t *input = vam->input;
16111 vl_api_gpe_add_del_iface_t *mp;
16112 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16113 u32 dp_table = 0, vni = 0;
16116 /* Parse args required to build the message */
16117 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16119 if (unformat (input, "up"))
16124 else if (unformat (input, "down"))
16129 else if (unformat (input, "table_id %d", &dp_table))
16133 else if (unformat (input, "bd_id %d", &dp_table))
16138 else if (unformat (input, "vni %d", &vni))
16146 if (action_set == 0)
16148 errmsg ("Action not set");
16151 if (dp_table_set == 0 || vni_set == 0)
16153 errmsg ("vni and dp_table must be set");
16157 /* Construct the API message */
16158 M (GPE_ADD_DEL_IFACE, mp);
16160 mp->is_add = is_add;
16161 mp->dp_table = clib_host_to_net_u32 (dp_table);
16163 mp->vni = clib_host_to_net_u32 (vni);
16168 /* Wait for a reply... */
16174 api_one_map_register_fallback_threshold (vat_main_t * vam)
16176 unformat_input_t *input = vam->input;
16177 vl_api_one_map_register_fallback_threshold_t *mp;
16182 /* Parse args required to build the message */
16183 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16185 if (unformat (input, "%u", &value))
16189 clib_warning ("parse error '%U'", format_unformat_error, input);
16196 errmsg ("fallback threshold value is missing!");
16200 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16201 mp->value = clib_host_to_net_u32 (value);
16206 /* Wait for a reply... */
16212 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16214 vl_api_show_one_map_register_fallback_threshold_t *mp;
16217 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16222 /* Wait for a reply... */
16228 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16230 u32 *proto = va_arg (*args, u32 *);
16232 if (unformat (input, "udp"))
16234 else if (unformat (input, "api"))
16243 api_one_set_transport_protocol (vat_main_t * vam)
16245 unformat_input_t *input = vam->input;
16246 vl_api_one_set_transport_protocol_t *mp;
16251 /* Parse args required to build the message */
16252 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16254 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16258 clib_warning ("parse error '%U'", format_unformat_error, input);
16265 errmsg ("Transport protocol missing!");
16269 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16270 mp->protocol = (u8) protocol;
16275 /* Wait for a reply... */
16281 api_one_get_transport_protocol (vat_main_t * vam)
16283 vl_api_one_get_transport_protocol_t *mp;
16286 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16291 /* Wait for a reply... */
16297 api_one_map_register_set_ttl (vat_main_t * vam)
16299 unformat_input_t *input = vam->input;
16300 vl_api_one_map_register_set_ttl_t *mp;
16305 /* Parse args required to build the message */
16306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16308 if (unformat (input, "%u", &ttl))
16312 clib_warning ("parse error '%U'", format_unformat_error, input);
16319 errmsg ("TTL value missing!");
16323 M (ONE_MAP_REGISTER_SET_TTL, mp);
16324 mp->ttl = clib_host_to_net_u32 (ttl);
16329 /* Wait for a reply... */
16335 api_show_one_map_register_ttl (vat_main_t * vam)
16337 vl_api_show_one_map_register_ttl_t *mp;
16340 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16345 /* Wait for a reply... */
16351 * Add/del map request itr rlocs from ONE control plane and updates
16353 * @param vam vpp API test context
16354 * @return return code
16357 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16359 unformat_input_t *input = vam->input;
16360 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16361 u8 *locator_set_name = 0;
16362 u8 locator_set_name_set = 0;
16366 /* Parse args required to build the message */
16367 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16369 if (unformat (input, "del"))
16373 else if (unformat (input, "%_%v%_", &locator_set_name))
16375 locator_set_name_set = 1;
16379 clib_warning ("parse error '%U'", format_unformat_error, input);
16384 if (is_add && !locator_set_name_set)
16386 errmsg ("itr-rloc is not set!");
16390 if (is_add && vec_len (locator_set_name) > 64)
16392 errmsg ("itr-rloc locator-set name too long");
16393 vec_free (locator_set_name);
16397 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16398 mp->is_add = is_add;
16401 clib_memcpy (mp->locator_set_name, locator_set_name,
16402 vec_len (locator_set_name));
16406 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16408 vec_free (locator_set_name);
16413 /* Wait for a reply... */
16418 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16421 api_one_locator_dump (vat_main_t * vam)
16423 unformat_input_t *input = vam->input;
16424 vl_api_one_locator_dump_t *mp;
16425 vl_api_control_ping_t *mp_ping;
16426 u8 is_index_set = 0, is_name_set = 0;
16431 /* Parse args required to build the message */
16432 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16434 if (unformat (input, "ls_name %_%v%_", &ls_name))
16438 else if (unformat (input, "ls_index %d", &ls_index))
16444 errmsg ("parse error '%U'", format_unformat_error, input);
16449 if (!is_index_set && !is_name_set)
16451 errmsg ("error: expected one of index or name!");
16455 if (is_index_set && is_name_set)
16457 errmsg ("error: only one param expected!");
16461 if (vec_len (ls_name) > 62)
16463 errmsg ("error: locator set name too long!");
16467 if (!vam->json_output)
16469 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16472 M (ONE_LOCATOR_DUMP, mp);
16473 mp->is_index_set = is_index_set;
16476 mp->ls_index = clib_host_to_net_u32 (ls_index);
16479 vec_add1 (ls_name, 0);
16480 strncpy ((char *) mp->ls_name, (char *) ls_name,
16481 sizeof (mp->ls_name) - 1);
16487 /* Use a control ping for synchronization */
16488 MPING (CONTROL_PING, mp_ping);
16491 /* Wait for a reply... */
16496 #define api_lisp_locator_dump api_one_locator_dump
16499 api_one_locator_set_dump (vat_main_t * vam)
16501 vl_api_one_locator_set_dump_t *mp;
16502 vl_api_control_ping_t *mp_ping;
16503 unformat_input_t *input = vam->input;
16507 /* Parse args required to build the message */
16508 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16510 if (unformat (input, "local"))
16514 else if (unformat (input, "remote"))
16520 errmsg ("parse error '%U'", format_unformat_error, input);
16525 if (!vam->json_output)
16527 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16530 M (ONE_LOCATOR_SET_DUMP, mp);
16532 mp->filter = filter;
16537 /* Use a control ping for synchronization */
16538 MPING (CONTROL_PING, mp_ping);
16541 /* Wait for a reply... */
16546 #define api_lisp_locator_set_dump api_one_locator_set_dump
16549 api_one_eid_table_map_dump (vat_main_t * vam)
16553 unformat_input_t *input = vam->input;
16554 vl_api_one_eid_table_map_dump_t *mp;
16555 vl_api_control_ping_t *mp_ping;
16558 /* Parse args required to build the message */
16559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16561 if (unformat (input, "l2"))
16566 else if (unformat (input, "l3"))
16573 errmsg ("parse error '%U'", format_unformat_error, input);
16580 errmsg ("expected one of 'l2' or 'l3' parameter!");
16584 if (!vam->json_output)
16586 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16589 M (ONE_EID_TABLE_MAP_DUMP, mp);
16595 /* Use a control ping for synchronization */
16596 MPING (CONTROL_PING, mp_ping);
16599 /* Wait for a reply... */
16604 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16607 api_one_eid_table_vni_dump (vat_main_t * vam)
16609 vl_api_one_eid_table_vni_dump_t *mp;
16610 vl_api_control_ping_t *mp_ping;
16613 if (!vam->json_output)
16615 print (vam->ofp, "VNI");
16618 M (ONE_EID_TABLE_VNI_DUMP, mp);
16623 /* Use a control ping for synchronization */
16624 MPING (CONTROL_PING, mp_ping);
16627 /* Wait for a reply... */
16632 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16635 api_one_eid_table_dump (vat_main_t * vam)
16637 unformat_input_t *i = vam->input;
16638 vl_api_one_eid_table_dump_t *mp;
16639 vl_api_control_ping_t *mp_ping;
16640 struct in_addr ip4;
16641 struct in6_addr ip6;
16643 u8 eid_type = ~0, eid_set = 0;
16644 u32 prefix_length = ~0, t, vni = 0;
16647 lisp_nsh_api_t nsh;
16649 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16651 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16657 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16663 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16668 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16673 else if (unformat (i, "vni %d", &t))
16677 else if (unformat (i, "local"))
16681 else if (unformat (i, "remote"))
16687 errmsg ("parse error '%U'", format_unformat_error, i);
16692 if (!vam->json_output)
16694 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16695 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16698 M (ONE_EID_TABLE_DUMP, mp);
16700 mp->filter = filter;
16704 mp->vni = htonl (vni);
16705 mp->eid_type = eid_type;
16709 mp->prefix_length = prefix_length;
16710 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16713 mp->prefix_length = prefix_length;
16714 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16717 clib_memcpy (mp->eid, mac, sizeof (mac));
16720 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16723 errmsg ("unknown EID type %d!", eid_type);
16731 /* Use a control ping for synchronization */
16732 MPING (CONTROL_PING, mp_ping);
16735 /* Wait for a reply... */
16740 #define api_lisp_eid_table_dump api_one_eid_table_dump
16743 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16745 unformat_input_t *i = vam->input;
16746 vl_api_gpe_fwd_entries_get_t *mp;
16751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16753 if (unformat (i, "vni %d", &vni))
16759 errmsg ("parse error '%U'", format_unformat_error, i);
16766 errmsg ("vni not set!");
16770 if (!vam->json_output)
16772 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16776 M (GPE_FWD_ENTRIES_GET, mp);
16777 mp->vni = clib_host_to_net_u32 (vni);
16782 /* Wait for a reply... */
16787 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16788 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16789 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16790 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16791 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16792 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16793 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16794 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16797 api_one_adjacencies_get (vat_main_t * vam)
16799 unformat_input_t *i = vam->input;
16800 vl_api_one_adjacencies_get_t *mp;
16805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16807 if (unformat (i, "vni %d", &vni))
16813 errmsg ("parse error '%U'", format_unformat_error, i);
16820 errmsg ("vni not set!");
16824 if (!vam->json_output)
16826 print (vam->ofp, "%s %40s", "leid", "reid");
16829 M (ONE_ADJACENCIES_GET, mp);
16830 mp->vni = clib_host_to_net_u32 (vni);
16835 /* Wait for a reply... */
16840 #define api_lisp_adjacencies_get api_one_adjacencies_get
16843 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16845 unformat_input_t *i = vam->input;
16846 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16848 u8 ip_family_set = 0, is_ip4 = 1;
16850 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16852 if (unformat (i, "ip4"))
16857 else if (unformat (i, "ip6"))
16864 errmsg ("parse error '%U'", format_unformat_error, i);
16869 if (!ip_family_set)
16871 errmsg ("ip family not set!");
16875 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16876 mp->is_ip4 = is_ip4;
16881 /* Wait for a reply... */
16887 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16889 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16892 if (!vam->json_output)
16894 print (vam->ofp, "VNIs");
16897 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16902 /* Wait for a reply... */
16908 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16910 unformat_input_t *i = vam->input;
16911 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16913 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16914 struct in_addr ip4;
16915 struct in6_addr ip6;
16916 u32 table_id = 0, nh_sw_if_index = ~0;
16918 clib_memset (&ip4, 0, sizeof (ip4));
16919 clib_memset (&ip6, 0, sizeof (ip6));
16921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16923 if (unformat (i, "del"))
16925 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16926 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16931 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16932 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16937 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16941 nh_sw_if_index = ~0;
16943 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16947 nh_sw_if_index = ~0;
16949 else if (unformat (i, "table %d", &table_id))
16953 errmsg ("parse error '%U'", format_unformat_error, i);
16960 errmsg ("nh addr not set!");
16964 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16965 mp->is_add = is_add;
16966 mp->table_id = clib_host_to_net_u32 (table_id);
16967 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16968 mp->is_ip4 = is_ip4;
16970 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16972 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16977 /* Wait for a reply... */
16983 api_one_map_server_dump (vat_main_t * vam)
16985 vl_api_one_map_server_dump_t *mp;
16986 vl_api_control_ping_t *mp_ping;
16989 if (!vam->json_output)
16991 print (vam->ofp, "%=20s", "Map server");
16994 M (ONE_MAP_SERVER_DUMP, mp);
16998 /* Use a control ping for synchronization */
16999 MPING (CONTROL_PING, mp_ping);
17002 /* Wait for a reply... */
17007 #define api_lisp_map_server_dump api_one_map_server_dump
17010 api_one_map_resolver_dump (vat_main_t * vam)
17012 vl_api_one_map_resolver_dump_t *mp;
17013 vl_api_control_ping_t *mp_ping;
17016 if (!vam->json_output)
17018 print (vam->ofp, "%=20s", "Map resolver");
17021 M (ONE_MAP_RESOLVER_DUMP, mp);
17025 /* Use a control ping for synchronization */
17026 MPING (CONTROL_PING, mp_ping);
17029 /* Wait for a reply... */
17034 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17037 api_one_stats_flush (vat_main_t * vam)
17039 vl_api_one_stats_flush_t *mp;
17042 M (ONE_STATS_FLUSH, mp);
17049 api_one_stats_dump (vat_main_t * vam)
17051 vl_api_one_stats_dump_t *mp;
17052 vl_api_control_ping_t *mp_ping;
17055 M (ONE_STATS_DUMP, mp);
17059 /* Use a control ping for synchronization */
17060 MPING (CONTROL_PING, mp_ping);
17063 /* Wait for a reply... */
17069 api_show_one_status (vat_main_t * vam)
17071 vl_api_show_one_status_t *mp;
17074 if (!vam->json_output)
17076 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17079 M (SHOW_ONE_STATUS, mp);
17082 /* Wait for a reply... */
17087 #define api_show_lisp_status api_show_one_status
17090 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17092 vl_api_gpe_fwd_entry_path_dump_t *mp;
17093 vl_api_control_ping_t *mp_ping;
17094 unformat_input_t *i = vam->input;
17095 u32 fwd_entry_index = ~0;
17098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17100 if (unformat (i, "index %d", &fwd_entry_index))
17106 if (~0 == fwd_entry_index)
17108 errmsg ("no index specified!");
17112 if (!vam->json_output)
17114 print (vam->ofp, "first line");
17117 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17121 /* Use a control ping for synchronization */
17122 MPING (CONTROL_PING, mp_ping);
17125 /* Wait for a reply... */
17131 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17133 vl_api_one_get_map_request_itr_rlocs_t *mp;
17136 if (!vam->json_output)
17138 print (vam->ofp, "%=20s", "itr-rlocs:");
17141 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17144 /* Wait for a reply... */
17149 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17152 api_af_packet_create (vat_main_t * vam)
17154 unformat_input_t *i = vam->input;
17155 vl_api_af_packet_create_t *mp;
17156 u8 *host_if_name = 0;
17158 u8 random_hw_addr = 1;
17161 clib_memset (hw_addr, 0, sizeof (hw_addr));
17163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17165 if (unformat (i, "name %s", &host_if_name))
17166 vec_add1 (host_if_name, 0);
17167 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17168 random_hw_addr = 0;
17173 if (!vec_len (host_if_name))
17175 errmsg ("host-interface name must be specified");
17179 if (vec_len (host_if_name) > 64)
17181 errmsg ("host-interface name too long");
17185 M (AF_PACKET_CREATE, mp);
17187 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17188 clib_memcpy (mp->hw_addr, hw_addr, 6);
17189 mp->use_random_hw_addr = random_hw_addr;
17190 vec_free (host_if_name);
17198 fprintf (vam->ofp ? vam->ofp : stderr,
17199 " new sw_if_index = %d\n", vam->sw_if_index);
17206 api_af_packet_delete (vat_main_t * vam)
17208 unformat_input_t *i = vam->input;
17209 vl_api_af_packet_delete_t *mp;
17210 u8 *host_if_name = 0;
17213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17215 if (unformat (i, "name %s", &host_if_name))
17216 vec_add1 (host_if_name, 0);
17221 if (!vec_len (host_if_name))
17223 errmsg ("host-interface name must be specified");
17227 if (vec_len (host_if_name) > 64)
17229 errmsg ("host-interface name too long");
17233 M (AF_PACKET_DELETE, mp);
17235 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17236 vec_free (host_if_name);
17243 static void vl_api_af_packet_details_t_handler
17244 (vl_api_af_packet_details_t * mp)
17246 vat_main_t *vam = &vat_main;
17248 print (vam->ofp, "%-16s %d",
17249 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17252 static void vl_api_af_packet_details_t_handler_json
17253 (vl_api_af_packet_details_t * mp)
17255 vat_main_t *vam = &vat_main;
17256 vat_json_node_t *node = NULL;
17258 if (VAT_JSON_ARRAY != vam->json_tree.type)
17260 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17261 vat_json_init_array (&vam->json_tree);
17263 node = vat_json_array_add (&vam->json_tree);
17265 vat_json_init_object (node);
17266 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17267 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17271 api_af_packet_dump (vat_main_t * vam)
17273 vl_api_af_packet_dump_t *mp;
17274 vl_api_control_ping_t *mp_ping;
17277 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17278 /* Get list of tap interfaces */
17279 M (AF_PACKET_DUMP, mp);
17282 /* Use a control ping for synchronization */
17283 MPING (CONTROL_PING, mp_ping);
17291 api_policer_add_del (vat_main_t * vam)
17293 unformat_input_t *i = vam->input;
17294 vl_api_policer_add_del_t *mp;
17304 u8 color_aware = 0;
17305 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17308 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17309 conform_action.dscp = 0;
17310 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17311 exceed_action.dscp = 0;
17312 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17313 violate_action.dscp = 0;
17315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17317 if (unformat (i, "del"))
17319 else if (unformat (i, "name %s", &name))
17320 vec_add1 (name, 0);
17321 else if (unformat (i, "cir %u", &cir))
17323 else if (unformat (i, "eir %u", &eir))
17325 else if (unformat (i, "cb %u", &cb))
17327 else if (unformat (i, "eb %u", &eb))
17329 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17332 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17335 else if (unformat (i, "type %U", unformat_policer_type, &type))
17337 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17340 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17343 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17346 else if (unformat (i, "color-aware"))
17352 if (!vec_len (name))
17354 errmsg ("policer name must be specified");
17358 if (vec_len (name) > 64)
17360 errmsg ("policer name too long");
17364 M (POLICER_ADD_DEL, mp);
17366 clib_memcpy (mp->name, name, vec_len (name));
17368 mp->is_add = is_add;
17369 mp->cir = ntohl (cir);
17370 mp->eir = ntohl (eir);
17371 mp->cb = clib_net_to_host_u64 (cb);
17372 mp->eb = clib_net_to_host_u64 (eb);
17373 mp->rate_type = rate_type;
17374 mp->round_type = round_type;
17376 mp->conform_action_type = conform_action.action_type;
17377 mp->conform_dscp = conform_action.dscp;
17378 mp->exceed_action_type = exceed_action.action_type;
17379 mp->exceed_dscp = exceed_action.dscp;
17380 mp->violate_action_type = violate_action.action_type;
17381 mp->violate_dscp = violate_action.dscp;
17382 mp->color_aware = color_aware;
17390 api_policer_dump (vat_main_t * vam)
17392 unformat_input_t *i = vam->input;
17393 vl_api_policer_dump_t *mp;
17394 vl_api_control_ping_t *mp_ping;
17395 u8 *match_name = 0;
17396 u8 match_name_valid = 0;
17399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17401 if (unformat (i, "name %s", &match_name))
17403 vec_add1 (match_name, 0);
17404 match_name_valid = 1;
17410 M (POLICER_DUMP, mp);
17411 mp->match_name_valid = match_name_valid;
17412 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17413 vec_free (match_name);
17417 /* Use a control ping for synchronization */
17418 MPING (CONTROL_PING, mp_ping);
17421 /* Wait for a reply... */
17427 api_policer_classify_set_interface (vat_main_t * vam)
17429 unformat_input_t *i = vam->input;
17430 vl_api_policer_classify_set_interface_t *mp;
17432 int sw_if_index_set;
17433 u32 ip4_table_index = ~0;
17434 u32 ip6_table_index = ~0;
17435 u32 l2_table_index = ~0;
17439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17441 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17442 sw_if_index_set = 1;
17443 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17444 sw_if_index_set = 1;
17445 else if (unformat (i, "del"))
17447 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17449 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17451 else if (unformat (i, "l2-table %d", &l2_table_index))
17455 clib_warning ("parse error '%U'", format_unformat_error, i);
17460 if (sw_if_index_set == 0)
17462 errmsg ("missing interface name or sw_if_index");
17466 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17468 mp->sw_if_index = ntohl (sw_if_index);
17469 mp->ip4_table_index = ntohl (ip4_table_index);
17470 mp->ip6_table_index = ntohl (ip6_table_index);
17471 mp->l2_table_index = ntohl (l2_table_index);
17472 mp->is_add = is_add;
17480 api_policer_classify_dump (vat_main_t * vam)
17482 unformat_input_t *i = vam->input;
17483 vl_api_policer_classify_dump_t *mp;
17484 vl_api_control_ping_t *mp_ping;
17485 u8 type = POLICER_CLASSIFY_N_TABLES;
17488 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17492 errmsg ("classify table type must be specified");
17496 if (!vam->json_output)
17498 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17501 M (POLICER_CLASSIFY_DUMP, mp);
17506 /* Use a control ping for synchronization */
17507 MPING (CONTROL_PING, mp_ping);
17510 /* Wait for a reply... */
17516 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17518 vl_api_fib_path_nh_proto_t proto =
17519 va_arg (*args, vl_api_fib_path_nh_proto_t);
17523 case FIB_API_PATH_NH_PROTO_IP4:
17524 s = format (s, "ip4");
17526 case FIB_API_PATH_NH_PROTO_IP6:
17527 s = format (s, "ip6");
17529 case FIB_API_PATH_NH_PROTO_MPLS:
17530 s = format (s, "mpls");
17532 case FIB_API_PATH_NH_PROTO_BIER:
17533 s = format (s, "bier");
17535 case FIB_API_PATH_NH_PROTO_ETHERNET:
17536 s = format (s, "ethernet");
17544 format_vl_api_ip_address_union (u8 * s, va_list * args)
17546 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
17547 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17552 s = format (s, "%U", format_ip4_address, u->ip4);
17555 s = format (s, "%U", format_ip6_address, u->ip6);
17562 format_vl_api_fib_path_type (u8 * s, va_list * args)
17564 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17568 case FIB_API_PATH_TYPE_NORMAL:
17569 s = format (s, "normal");
17571 case FIB_API_PATH_TYPE_LOCAL:
17572 s = format (s, "local");
17574 case FIB_API_PATH_TYPE_DROP:
17575 s = format (s, "drop");
17577 case FIB_API_PATH_TYPE_UDP_ENCAP:
17578 s = format (s, "udp-encap");
17580 case FIB_API_PATH_TYPE_BIER_IMP:
17581 s = format (s, "bier-imp");
17583 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17584 s = format (s, "unreach");
17586 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17587 s = format (s, "prohibit");
17589 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17590 s = format (s, "src-lookup");
17592 case FIB_API_PATH_TYPE_DVR:
17593 s = format (s, "dvr");
17595 case FIB_API_PATH_TYPE_INTERFACE_RX:
17596 s = format (s, "interface-rx");
17598 case FIB_API_PATH_TYPE_CLASSIFY:
17599 s = format (s, "classify");
17607 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17610 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17611 ntohl (fp->weight), ntohl (fp->sw_if_index),
17612 format_vl_api_fib_path_type, fp->type,
17613 format_fib_api_path_nh_proto, fp->proto,
17614 format_vl_api_ip_address_union, &fp->nh.address);
17618 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17619 vl_api_fib_path_t * fp)
17621 struct in_addr ip4;
17622 struct in6_addr ip6;
17624 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17625 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17626 vat_json_object_add_uint (node, "type", fp->type);
17627 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17628 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17630 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17631 vat_json_object_add_ip4 (node, "next_hop", ip4);
17633 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17635 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17636 vat_json_object_add_ip6 (node, "next_hop", ip6);
17641 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17643 vat_main_t *vam = &vat_main;
17644 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17645 vl_api_fib_path_t *fp;
17648 print (vam->ofp, "sw_if_index %d via:",
17649 ntohl (mp->mt_tunnel.mt_sw_if_index));
17650 fp = mp->mt_tunnel.mt_paths;
17651 for (i = 0; i < count; i++)
17653 vl_api_fib_path_print (vam, fp);
17657 print (vam->ofp, "");
17660 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17661 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17664 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17666 vat_main_t *vam = &vat_main;
17667 vat_json_node_t *node = NULL;
17668 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17669 vl_api_fib_path_t *fp;
17672 if (VAT_JSON_ARRAY != vam->json_tree.type)
17674 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17675 vat_json_init_array (&vam->json_tree);
17677 node = vat_json_array_add (&vam->json_tree);
17679 vat_json_init_object (node);
17680 vat_json_object_add_uint (node, "sw_if_index",
17681 ntohl (mp->mt_tunnel.mt_sw_if_index));
17683 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17685 fp = mp->mt_tunnel.mt_paths;
17686 for (i = 0; i < count; i++)
17688 vl_api_mpls_fib_path_json_print (node, fp);
17694 api_mpls_tunnel_dump (vat_main_t * vam)
17696 vl_api_mpls_tunnel_dump_t *mp;
17697 vl_api_control_ping_t *mp_ping;
17700 M (MPLS_TUNNEL_DUMP, mp);
17704 /* Use a control ping for synchronization */
17705 MPING (CONTROL_PING, mp_ping);
17712 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17713 #define vl_api_mpls_table_details_t_print vl_noop_handler
17717 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17719 vat_main_t *vam = &vat_main;
17721 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17724 static void vl_api_mpls_table_details_t_handler_json
17725 (vl_api_mpls_table_details_t * mp)
17727 vat_main_t *vam = &vat_main;
17728 vat_json_node_t *node = NULL;
17730 if (VAT_JSON_ARRAY != vam->json_tree.type)
17732 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17733 vat_json_init_array (&vam->json_tree);
17735 node = vat_json_array_add (&vam->json_tree);
17737 vat_json_init_object (node);
17738 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17742 api_mpls_table_dump (vat_main_t * vam)
17744 vl_api_mpls_table_dump_t *mp;
17745 vl_api_control_ping_t *mp_ping;
17748 M (MPLS_TABLE_DUMP, mp);
17751 /* Use a control ping for synchronization */
17752 MPING (CONTROL_PING, mp_ping);
17759 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17760 #define vl_api_mpls_route_details_t_print vl_noop_handler
17763 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17765 vat_main_t *vam = &vat_main;
17766 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17767 vl_api_fib_path_t *fp;
17771 "table-id %d, label %u, ess_bit %u",
17772 ntohl (mp->mr_route.mr_table_id),
17773 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17774 fp = mp->mr_route.mr_paths;
17775 for (i = 0; i < count; i++)
17777 vl_api_fib_path_print (vam, fp);
17782 static void vl_api_mpls_route_details_t_handler_json
17783 (vl_api_mpls_route_details_t * mp)
17785 vat_main_t *vam = &vat_main;
17786 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17787 vat_json_node_t *node = NULL;
17788 vl_api_fib_path_t *fp;
17791 if (VAT_JSON_ARRAY != vam->json_tree.type)
17793 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17794 vat_json_init_array (&vam->json_tree);
17796 node = vat_json_array_add (&vam->json_tree);
17798 vat_json_init_object (node);
17799 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17800 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17801 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17802 vat_json_object_add_uint (node, "path_count", count);
17803 fp = mp->mr_route.mr_paths;
17804 for (i = 0; i < count; i++)
17806 vl_api_mpls_fib_path_json_print (node, fp);
17812 api_mpls_route_dump (vat_main_t * vam)
17814 unformat_input_t *input = vam->input;
17815 vl_api_mpls_route_dump_t *mp;
17816 vl_api_control_ping_t *mp_ping;
17820 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17822 if (unformat (input, "table_id %d", &table_id))
17827 if (table_id == ~0)
17829 errmsg ("missing table id");
17833 M (MPLS_ROUTE_DUMP, mp);
17835 mp->table.mt_table_id = ntohl (table_id);
17838 /* Use a control ping for synchronization */
17839 MPING (CONTROL_PING, mp_ping);
17846 #define vl_api_ip_table_details_t_endian vl_noop_handler
17847 #define vl_api_ip_table_details_t_print vl_noop_handler
17850 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17852 vat_main_t *vam = &vat_main;
17855 "%s; table-id %d, prefix %U/%d",
17856 mp->table.name, ntohl (mp->table.table_id));
17860 static void vl_api_ip_table_details_t_handler_json
17861 (vl_api_ip_table_details_t * mp)
17863 vat_main_t *vam = &vat_main;
17864 vat_json_node_t *node = NULL;
17866 if (VAT_JSON_ARRAY != vam->json_tree.type)
17868 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17869 vat_json_init_array (&vam->json_tree);
17871 node = vat_json_array_add (&vam->json_tree);
17873 vat_json_init_object (node);
17874 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17878 api_ip_table_dump (vat_main_t * vam)
17880 vl_api_ip_table_dump_t *mp;
17881 vl_api_control_ping_t *mp_ping;
17884 M (IP_TABLE_DUMP, mp);
17887 /* Use a control ping for synchronization */
17888 MPING (CONTROL_PING, mp_ping);
17896 api_ip_mtable_dump (vat_main_t * vam)
17898 vl_api_ip_mtable_dump_t *mp;
17899 vl_api_control_ping_t *mp_ping;
17902 M (IP_MTABLE_DUMP, mp);
17905 /* Use a control ping for synchronization */
17906 MPING (CONTROL_PING, mp_ping);
17914 api_ip_mroute_dump (vat_main_t * vam)
17916 unformat_input_t *input = vam->input;
17917 vl_api_control_ping_t *mp_ping;
17918 vl_api_ip_mroute_dump_t *mp;
17923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17925 if (unformat (input, "table_id %d", &table_id))
17927 else if (unformat (input, "ip6"))
17929 else if (unformat (input, "ip4"))
17934 if (table_id == ~0)
17936 errmsg ("missing table id");
17940 M (IP_MROUTE_DUMP, mp);
17941 mp->table.table_id = table_id;
17942 mp->table.is_ip6 = is_ip6;
17945 /* Use a control ping for synchronization */
17946 MPING (CONTROL_PING, mp_ping);
17953 #define vl_api_ip_route_details_t_endian vl_noop_handler
17954 #define vl_api_ip_route_details_t_print vl_noop_handler
17957 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17959 vat_main_t *vam = &vat_main;
17960 u8 count = mp->route.n_paths;
17961 vl_api_fib_path_t *fp;
17965 "table-id %d, prefix %U/%d",
17966 ntohl (mp->route.table_id),
17967 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17968 for (i = 0; i < count; i++)
17970 fp = &mp->route.paths[i];
17972 vl_api_fib_path_print (vam, fp);
17977 static void vl_api_ip_route_details_t_handler_json
17978 (vl_api_ip_route_details_t * mp)
17980 vat_main_t *vam = &vat_main;
17981 u8 count = mp->route.n_paths;
17982 vat_json_node_t *node = NULL;
17983 struct in_addr ip4;
17984 struct in6_addr ip6;
17985 vl_api_fib_path_t *fp;
17988 if (VAT_JSON_ARRAY != vam->json_tree.type)
17990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17991 vat_json_init_array (&vam->json_tree);
17993 node = vat_json_array_add (&vam->json_tree);
17995 vat_json_init_object (node);
17996 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
17997 if (ADDRESS_IP6 == mp->route.prefix.address.af)
17999 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18000 vat_json_object_add_ip6 (node, "prefix", ip6);
18004 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18005 vat_json_object_add_ip4 (node, "prefix", ip4);
18007 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18008 vat_json_object_add_uint (node, "path_count", count);
18009 for (i = 0; i < count; i++)
18011 fp = &mp->route.paths[i];
18012 vl_api_mpls_fib_path_json_print (node, fp);
18017 api_ip_route_dump (vat_main_t * vam)
18019 unformat_input_t *input = vam->input;
18020 vl_api_ip_route_dump_t *mp;
18021 vl_api_control_ping_t *mp_ping;
18027 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18029 if (unformat (input, "table_id %d", &table_id))
18031 else if (unformat (input, "ip6"))
18033 else if (unformat (input, "ip4"))
18038 if (table_id == ~0)
18040 errmsg ("missing table id");
18044 M (IP_ROUTE_DUMP, mp);
18046 mp->table.table_id = table_id;
18047 mp->table.is_ip6 = is_ip6;
18051 /* Use a control ping for synchronization */
18052 MPING (CONTROL_PING, mp_ping);
18060 api_classify_table_ids (vat_main_t * vam)
18062 vl_api_classify_table_ids_t *mp;
18065 /* Construct the API message */
18066 M (CLASSIFY_TABLE_IDS, mp);
18075 api_classify_table_by_interface (vat_main_t * vam)
18077 unformat_input_t *input = vam->input;
18078 vl_api_classify_table_by_interface_t *mp;
18080 u32 sw_if_index = ~0;
18082 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18084 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18086 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18091 if (sw_if_index == ~0)
18093 errmsg ("missing interface name or sw_if_index");
18097 /* Construct the API message */
18098 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18100 mp->sw_if_index = ntohl (sw_if_index);
18108 api_classify_table_info (vat_main_t * vam)
18110 unformat_input_t *input = vam->input;
18111 vl_api_classify_table_info_t *mp;
18115 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18117 if (unformat (input, "table_id %d", &table_id))
18122 if (table_id == ~0)
18124 errmsg ("missing table id");
18128 /* Construct the API message */
18129 M (CLASSIFY_TABLE_INFO, mp);
18131 mp->table_id = ntohl (table_id);
18139 api_classify_session_dump (vat_main_t * vam)
18141 unformat_input_t *input = vam->input;
18142 vl_api_classify_session_dump_t *mp;
18143 vl_api_control_ping_t *mp_ping;
18147 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18149 if (unformat (input, "table_id %d", &table_id))
18154 if (table_id == ~0)
18156 errmsg ("missing table id");
18160 /* Construct the API message */
18161 M (CLASSIFY_SESSION_DUMP, mp);
18163 mp->table_id = ntohl (table_id);
18166 /* Use a control ping for synchronization */
18167 MPING (CONTROL_PING, mp_ping);
18175 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18177 vat_main_t *vam = &vat_main;
18179 print (vam->ofp, "collector_address %U, collector_port %d, "
18180 "src_address %U, vrf_id %d, path_mtu %u, "
18181 "template_interval %u, udp_checksum %d",
18182 format_ip4_address, mp->collector_address,
18183 ntohs (mp->collector_port),
18184 format_ip4_address, mp->src_address,
18185 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18186 ntohl (mp->template_interval), mp->udp_checksum);
18189 vam->result_ready = 1;
18193 vl_api_ipfix_exporter_details_t_handler_json
18194 (vl_api_ipfix_exporter_details_t * mp)
18196 vat_main_t *vam = &vat_main;
18197 vat_json_node_t node;
18198 struct in_addr collector_address;
18199 struct in_addr src_address;
18201 vat_json_init_object (&node);
18202 clib_memcpy (&collector_address, &mp->collector_address,
18203 sizeof (collector_address));
18204 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18205 vat_json_object_add_uint (&node, "collector_port",
18206 ntohs (mp->collector_port));
18207 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18208 vat_json_object_add_ip4 (&node, "src_address", src_address);
18209 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18210 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18211 vat_json_object_add_uint (&node, "template_interval",
18212 ntohl (mp->template_interval));
18213 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18215 vat_json_print (vam->ofp, &node);
18216 vat_json_free (&node);
18218 vam->result_ready = 1;
18222 api_ipfix_exporter_dump (vat_main_t * vam)
18224 vl_api_ipfix_exporter_dump_t *mp;
18227 /* Construct the API message */
18228 M (IPFIX_EXPORTER_DUMP, mp);
18237 api_ipfix_classify_stream_dump (vat_main_t * vam)
18239 vl_api_ipfix_classify_stream_dump_t *mp;
18242 /* Construct the API message */
18243 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18254 vl_api_ipfix_classify_stream_details_t_handler
18255 (vl_api_ipfix_classify_stream_details_t * mp)
18257 vat_main_t *vam = &vat_main;
18258 print (vam->ofp, "domain_id %d, src_port %d",
18259 ntohl (mp->domain_id), ntohs (mp->src_port));
18261 vam->result_ready = 1;
18265 vl_api_ipfix_classify_stream_details_t_handler_json
18266 (vl_api_ipfix_classify_stream_details_t * mp)
18268 vat_main_t *vam = &vat_main;
18269 vat_json_node_t node;
18271 vat_json_init_object (&node);
18272 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18273 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18275 vat_json_print (vam->ofp, &node);
18276 vat_json_free (&node);
18278 vam->result_ready = 1;
18282 api_ipfix_classify_table_dump (vat_main_t * vam)
18284 vl_api_ipfix_classify_table_dump_t *mp;
18285 vl_api_control_ping_t *mp_ping;
18288 if (!vam->json_output)
18290 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18291 "transport_protocol");
18294 /* Construct the API message */
18295 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18300 /* Use a control ping for synchronization */
18301 MPING (CONTROL_PING, mp_ping);
18309 vl_api_ipfix_classify_table_details_t_handler
18310 (vl_api_ipfix_classify_table_details_t * mp)
18312 vat_main_t *vam = &vat_main;
18313 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18314 mp->transport_protocol);
18318 vl_api_ipfix_classify_table_details_t_handler_json
18319 (vl_api_ipfix_classify_table_details_t * mp)
18321 vat_json_node_t *node = NULL;
18322 vat_main_t *vam = &vat_main;
18324 if (VAT_JSON_ARRAY != vam->json_tree.type)
18326 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18327 vat_json_init_array (&vam->json_tree);
18330 node = vat_json_array_add (&vam->json_tree);
18331 vat_json_init_object (node);
18333 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18334 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18335 vat_json_object_add_uint (node, "transport_protocol",
18336 mp->transport_protocol);
18340 api_sw_interface_span_enable_disable (vat_main_t * vam)
18342 unformat_input_t *i = vam->input;
18343 vl_api_sw_interface_span_enable_disable_t *mp;
18344 u32 src_sw_if_index = ~0;
18345 u32 dst_sw_if_index = ~0;
18350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18353 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18355 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18359 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18361 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18363 else if (unformat (i, "disable"))
18365 else if (unformat (i, "rx"))
18367 else if (unformat (i, "tx"))
18369 else if (unformat (i, "both"))
18371 else if (unformat (i, "l2"))
18377 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18379 mp->sw_if_index_from = htonl (src_sw_if_index);
18380 mp->sw_if_index_to = htonl (dst_sw_if_index);
18390 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18393 vat_main_t *vam = &vat_main;
18394 u8 *sw_if_from_name = 0;
18395 u8 *sw_if_to_name = 0;
18396 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18397 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18398 char *states[] = { "none", "rx", "tx", "both" };
18402 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18404 if ((u32) p->value[0] == sw_if_index_from)
18406 sw_if_from_name = (u8 *)(p->key);
18410 if ((u32) p->value[0] == sw_if_index_to)
18412 sw_if_to_name = (u8 *)(p->key);
18413 if (sw_if_from_name)
18418 print (vam->ofp, "%20s => %20s (%s) %s",
18419 sw_if_from_name, sw_if_to_name, states[mp->state],
18420 mp->is_l2 ? "l2" : "device");
18424 vl_api_sw_interface_span_details_t_handler_json
18425 (vl_api_sw_interface_span_details_t * mp)
18427 vat_main_t *vam = &vat_main;
18428 vat_json_node_t *node = NULL;
18429 u8 *sw_if_from_name = 0;
18430 u8 *sw_if_to_name = 0;
18431 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18432 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18436 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18438 if ((u32) p->value[0] == sw_if_index_from)
18440 sw_if_from_name = (u8 *)(p->key);
18444 if ((u32) p->value[0] == sw_if_index_to)
18446 sw_if_to_name = (u8 *)(p->key);
18447 if (sw_if_from_name)
18453 if (VAT_JSON_ARRAY != vam->json_tree.type)
18455 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18456 vat_json_init_array (&vam->json_tree);
18458 node = vat_json_array_add (&vam->json_tree);
18460 vat_json_init_object (node);
18461 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18462 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18463 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18464 if (0 != sw_if_to_name)
18466 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18468 vat_json_object_add_uint (node, "state", mp->state);
18469 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18473 api_sw_interface_span_dump (vat_main_t * vam)
18475 unformat_input_t *input = vam->input;
18476 vl_api_sw_interface_span_dump_t *mp;
18477 vl_api_control_ping_t *mp_ping;
18481 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18483 if (unformat (input, "l2"))
18489 M (SW_INTERFACE_SPAN_DUMP, mp);
18493 /* Use a control ping for synchronization */
18494 MPING (CONTROL_PING, mp_ping);
18502 api_pg_create_interface (vat_main_t * vam)
18504 unformat_input_t *input = vam->input;
18505 vl_api_pg_create_interface_t *mp;
18507 u32 if_id = ~0, gso_size = 0;
18508 u8 gso_enabled = 0;
18510 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18512 if (unformat (input, "if_id %d", &if_id))
18514 else if (unformat (input, "gso-enabled"))
18517 if (unformat (input, "gso-size %u", &gso_size))
18521 errmsg ("missing gso-size");
18530 errmsg ("missing pg interface index");
18534 /* Construct the API message */
18535 M (PG_CREATE_INTERFACE, mp);
18537 mp->interface_id = ntohl (if_id);
18538 mp->gso_enabled = gso_enabled;
18546 api_pg_capture (vat_main_t * vam)
18548 unformat_input_t *input = vam->input;
18549 vl_api_pg_capture_t *mp;
18554 u8 pcap_file_set = 0;
18557 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18559 if (unformat (input, "if_id %d", &if_id))
18561 else if (unformat (input, "pcap %s", &pcap_file))
18563 else if (unformat (input, "count %d", &count))
18565 else if (unformat (input, "disable"))
18572 errmsg ("missing pg interface index");
18575 if (pcap_file_set > 0)
18577 if (vec_len (pcap_file) > 255)
18579 errmsg ("pcap file name is too long");
18584 u32 name_len = vec_len (pcap_file);
18585 /* Construct the API message */
18586 M (PG_CAPTURE, mp);
18588 mp->interface_id = ntohl (if_id);
18589 mp->is_enabled = enable;
18590 mp->count = ntohl (count);
18591 mp->pcap_name_length = ntohl (name_len);
18592 if (pcap_file_set != 0)
18594 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18596 vec_free (pcap_file);
18604 api_pg_enable_disable (vat_main_t * vam)
18606 unformat_input_t *input = vam->input;
18607 vl_api_pg_enable_disable_t *mp;
18610 u8 stream_name_set = 0;
18611 u8 *stream_name = 0;
18613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18615 if (unformat (input, "stream %s", &stream_name))
18616 stream_name_set = 1;
18617 else if (unformat (input, "disable"))
18623 if (stream_name_set > 0)
18625 if (vec_len (stream_name) > 255)
18627 errmsg ("stream name too long");
18632 u32 name_len = vec_len (stream_name);
18633 /* Construct the API message */
18634 M (PG_ENABLE_DISABLE, mp);
18636 mp->is_enabled = enable;
18637 if (stream_name_set != 0)
18639 mp->stream_name_length = ntohl (name_len);
18640 clib_memcpy (mp->stream_name, stream_name, name_len);
18642 vec_free (stream_name);
18650 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18652 unformat_input_t *input = vam->input;
18653 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18655 u16 *low_ports = 0;
18656 u16 *high_ports = 0;
18659 vl_api_prefix_t prefix;
18666 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18668 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18670 else if (unformat (input, "vrf %d", &vrf_id))
18672 else if (unformat (input, "del"))
18674 else if (unformat (input, "port %d", &tmp))
18676 if (tmp == 0 || tmp > 65535)
18678 errmsg ("port %d out of range", tmp);
18682 this_hi = this_low + 1;
18683 vec_add1 (low_ports, this_low);
18684 vec_add1 (high_ports, this_hi);
18686 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18688 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18690 errmsg ("incorrect range parameters");
18694 /* Note: in debug CLI +1 is added to high before
18695 passing to real fn that does "the work"
18696 (ip_source_and_port_range_check_add_del).
18697 This fn is a wrapper around the binary API fn a
18698 control plane will call, which expects this increment
18699 to have occurred. Hence letting the binary API control
18700 plane fn do the increment for consistency between VAT
18701 and other control planes.
18704 vec_add1 (low_ports, this_low);
18705 vec_add1 (high_ports, this_hi);
18711 if (prefix_set == 0)
18713 errmsg ("<address>/<mask> not specified");
18719 errmsg ("VRF ID required, not specified");
18726 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18730 if (vec_len (low_ports) == 0)
18732 errmsg ("At least one port or port range required");
18736 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18738 mp->is_add = is_add;
18740 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18742 mp->number_of_ranges = vec_len (low_ports);
18744 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18745 vec_free (low_ports);
18747 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18748 vec_free (high_ports);
18750 mp->vrf_id = ntohl (vrf_id);
18758 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18760 unformat_input_t *input = vam->input;
18761 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18762 u32 sw_if_index = ~0;
18764 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18765 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18771 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18773 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18775 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18777 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18779 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18781 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18783 else if (unformat (input, "del"))
18789 if (sw_if_index == ~0)
18791 errmsg ("Interface required but not specified");
18797 errmsg ("VRF ID required but not specified");
18801 if (tcp_out_vrf_id == 0
18802 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18805 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18809 /* Construct the API message */
18810 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18812 mp->sw_if_index = ntohl (sw_if_index);
18813 mp->is_add = is_add;
18814 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18815 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18816 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18817 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18822 /* Wait for a reply... */
18828 api_set_punt (vat_main_t * vam)
18830 unformat_input_t *i = vam->input;
18831 vl_api_address_family_t af;
18832 vl_api_set_punt_t *mp;
18838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18840 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18842 else if (unformat (i, "protocol %d", &protocol))
18844 else if (unformat (i, "port %d", &port))
18846 else if (unformat (i, "del"))
18850 clib_warning ("parse error '%U'", format_unformat_error, i);
18857 mp->is_add = (u8) is_add;
18858 mp->punt.type = PUNT_API_TYPE_L4;
18859 mp->punt.punt.l4.af = af;
18860 mp->punt.punt.l4.protocol = (u8) protocol;
18861 mp->punt.punt.l4.port = htons ((u16) port);
18869 api_delete_subif (vat_main_t * vam)
18871 unformat_input_t *i = vam->input;
18872 vl_api_delete_subif_t *mp;
18873 u32 sw_if_index = ~0;
18876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18880 if (unformat (i, "sw_if_index %d", &sw_if_index))
18886 if (sw_if_index == ~0)
18888 errmsg ("missing sw_if_index");
18892 /* Construct the API message */
18893 M (DELETE_SUBIF, mp);
18894 mp->sw_if_index = ntohl (sw_if_index);
18901 #define foreach_pbb_vtr_op \
18902 _("disable", L2_VTR_DISABLED) \
18903 _("pop", L2_VTR_POP_2) \
18904 _("push", L2_VTR_PUSH_2)
18907 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18909 unformat_input_t *i = vam->input;
18910 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18911 u32 sw_if_index = ~0, vtr_op = ~0;
18912 u16 outer_tag = ~0;
18913 u8 dmac[6], smac[6];
18914 u8 dmac_set = 0, smac_set = 0;
18920 /* Shut up coverity */
18921 clib_memset (dmac, 0, sizeof (dmac));
18922 clib_memset (smac, 0, sizeof (smac));
18924 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18926 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18928 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18930 else if (unformat (i, "vtr_op %d", &vtr_op))
18932 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18935 else if (unformat (i, "translate_pbb_stag"))
18937 if (unformat (i, "%d", &tmp))
18939 vtr_op = L2_VTR_TRANSLATE_2_1;
18945 ("translate_pbb_stag operation requires outer tag definition");
18949 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18951 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18953 else if (unformat (i, "sid %d", &sid))
18955 else if (unformat (i, "vlanid %d", &tmp))
18959 clib_warning ("parse error '%U'", format_unformat_error, i);
18964 if ((sw_if_index == ~0) || (vtr_op == ~0))
18966 errmsg ("missing sw_if_index or vtr operation");
18969 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18970 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18973 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18977 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18978 mp->sw_if_index = ntohl (sw_if_index);
18979 mp->vtr_op = ntohl (vtr_op);
18980 mp->outer_tag = ntohs (outer_tag);
18981 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
18982 clib_memcpy (mp->b_smac, smac, sizeof (smac));
18983 mp->b_vlanid = ntohs (vlanid);
18984 mp->i_sid = ntohl (sid);
18992 api_flow_classify_set_interface (vat_main_t * vam)
18994 unformat_input_t *i = vam->input;
18995 vl_api_flow_classify_set_interface_t *mp;
18997 int sw_if_index_set;
18998 u32 ip4_table_index = ~0;
18999 u32 ip6_table_index = ~0;
19003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19005 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19006 sw_if_index_set = 1;
19007 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19008 sw_if_index_set = 1;
19009 else if (unformat (i, "del"))
19011 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19013 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19017 clib_warning ("parse error '%U'", format_unformat_error, i);
19022 if (sw_if_index_set == 0)
19024 errmsg ("missing interface name or sw_if_index");
19028 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19030 mp->sw_if_index = ntohl (sw_if_index);
19031 mp->ip4_table_index = ntohl (ip4_table_index);
19032 mp->ip6_table_index = ntohl (ip6_table_index);
19033 mp->is_add = is_add;
19041 api_flow_classify_dump (vat_main_t * vam)
19043 unformat_input_t *i = vam->input;
19044 vl_api_flow_classify_dump_t *mp;
19045 vl_api_control_ping_t *mp_ping;
19046 u8 type = FLOW_CLASSIFY_N_TABLES;
19049 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19053 errmsg ("classify table type must be specified");
19057 if (!vam->json_output)
19059 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19062 M (FLOW_CLASSIFY_DUMP, mp);
19067 /* Use a control ping for synchronization */
19068 MPING (CONTROL_PING, mp_ping);
19071 /* Wait for a reply... */
19077 api_feature_enable_disable (vat_main_t * vam)
19079 unformat_input_t *i = vam->input;
19080 vl_api_feature_enable_disable_t *mp;
19082 u8 *feature_name = 0;
19083 u32 sw_if_index = ~0;
19087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19089 if (unformat (i, "arc_name %s", &arc_name))
19091 else if (unformat (i, "feature_name %s", &feature_name))
19094 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19096 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19098 else if (unformat (i, "disable"))
19106 errmsg ("missing arc name");
19109 if (vec_len (arc_name) > 63)
19111 errmsg ("arc name too long");
19114 if (feature_name == 0)
19116 errmsg ("missing feature name");
19119 if (vec_len (feature_name) > 63)
19121 errmsg ("feature name too long");
19124 if (sw_if_index == ~0)
19126 errmsg ("missing interface name or sw_if_index");
19130 /* Construct the API message */
19131 M (FEATURE_ENABLE_DISABLE, mp);
19132 mp->sw_if_index = ntohl (sw_if_index);
19133 mp->enable = enable;
19134 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19135 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19136 vec_free (arc_name);
19137 vec_free (feature_name);
19145 api_feature_gso_enable_disable (vat_main_t * vam)
19147 unformat_input_t *i = vam->input;
19148 vl_api_feature_gso_enable_disable_t *mp;
19149 u32 sw_if_index = ~0;
19153 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19155 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19157 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19159 else if (unformat (i, "enable"))
19161 else if (unformat (i, "disable"))
19167 if (sw_if_index == ~0)
19169 errmsg ("missing interface name or sw_if_index");
19173 /* Construct the API message */
19174 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19175 mp->sw_if_index = ntohl (sw_if_index);
19176 mp->enable_disable = enable;
19184 api_sw_interface_tag_add_del (vat_main_t * vam)
19186 unformat_input_t *i = vam->input;
19187 vl_api_sw_interface_tag_add_del_t *mp;
19188 u32 sw_if_index = ~0;
19193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19195 if (unformat (i, "tag %s", &tag))
19197 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19199 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19201 else if (unformat (i, "del"))
19207 if (sw_if_index == ~0)
19209 errmsg ("missing interface name or sw_if_index");
19213 if (enable && (tag == 0))
19215 errmsg ("no tag specified");
19219 /* Construct the API message */
19220 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19221 mp->sw_if_index = ntohl (sw_if_index);
19222 mp->is_add = enable;
19224 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19233 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19235 unformat_input_t *i = vam->input;
19236 vl_api_mac_address_t mac = { 0 };
19237 vl_api_sw_interface_add_del_mac_address_t *mp;
19238 u32 sw_if_index = ~0;
19243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19245 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19247 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19249 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19251 else if (unformat (i, "del"))
19257 if (sw_if_index == ~0)
19259 errmsg ("missing interface name or sw_if_index");
19265 errmsg ("missing MAC address");
19269 /* Construct the API message */
19270 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19271 mp->sw_if_index = ntohl (sw_if_index);
19272 mp->is_add = is_add;
19273 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19280 static void vl_api_l2_xconnect_details_t_handler
19281 (vl_api_l2_xconnect_details_t * mp)
19283 vat_main_t *vam = &vat_main;
19285 print (vam->ofp, "%15d%15d",
19286 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19289 static void vl_api_l2_xconnect_details_t_handler_json
19290 (vl_api_l2_xconnect_details_t * mp)
19292 vat_main_t *vam = &vat_main;
19293 vat_json_node_t *node = NULL;
19295 if (VAT_JSON_ARRAY != vam->json_tree.type)
19297 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19298 vat_json_init_array (&vam->json_tree);
19300 node = vat_json_array_add (&vam->json_tree);
19302 vat_json_init_object (node);
19303 vat_json_object_add_uint (node, "rx_sw_if_index",
19304 ntohl (mp->rx_sw_if_index));
19305 vat_json_object_add_uint (node, "tx_sw_if_index",
19306 ntohl (mp->tx_sw_if_index));
19310 api_l2_xconnect_dump (vat_main_t * vam)
19312 vl_api_l2_xconnect_dump_t *mp;
19313 vl_api_control_ping_t *mp_ping;
19316 if (!vam->json_output)
19318 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19321 M (L2_XCONNECT_DUMP, mp);
19325 /* Use a control ping for synchronization */
19326 MPING (CONTROL_PING, mp_ping);
19334 api_hw_interface_set_mtu (vat_main_t * vam)
19336 unformat_input_t *i = vam->input;
19337 vl_api_hw_interface_set_mtu_t *mp;
19338 u32 sw_if_index = ~0;
19342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19344 if (unformat (i, "mtu %d", &mtu))
19346 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19348 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19354 if (sw_if_index == ~0)
19356 errmsg ("missing interface name or sw_if_index");
19362 errmsg ("no mtu specified");
19366 /* Construct the API message */
19367 M (HW_INTERFACE_SET_MTU, mp);
19368 mp->sw_if_index = ntohl (sw_if_index);
19369 mp->mtu = ntohs ((u16) mtu);
19377 api_p2p_ethernet_add (vat_main_t * vam)
19379 unformat_input_t *i = vam->input;
19380 vl_api_p2p_ethernet_add_t *mp;
19381 u32 parent_if_index = ~0;
19387 clib_memset (remote_mac, 0, sizeof (remote_mac));
19388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19390 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19392 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19396 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19398 else if (unformat (i, "sub_id %d", &sub_id))
19402 clib_warning ("parse error '%U'", format_unformat_error, i);
19407 if (parent_if_index == ~0)
19409 errmsg ("missing interface name or sw_if_index");
19414 errmsg ("missing remote mac address");
19419 errmsg ("missing sub-interface id");
19423 M (P2P_ETHERNET_ADD, mp);
19424 mp->parent_if_index = ntohl (parent_if_index);
19425 mp->subif_id = ntohl (sub_id);
19426 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19434 api_p2p_ethernet_del (vat_main_t * vam)
19436 unformat_input_t *i = vam->input;
19437 vl_api_p2p_ethernet_del_t *mp;
19438 u32 parent_if_index = ~0;
19443 clib_memset (remote_mac, 0, sizeof (remote_mac));
19444 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19446 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19448 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19452 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19456 clib_warning ("parse error '%U'", format_unformat_error, i);
19461 if (parent_if_index == ~0)
19463 errmsg ("missing interface name or sw_if_index");
19468 errmsg ("missing remote mac address");
19472 M (P2P_ETHERNET_DEL, mp);
19473 mp->parent_if_index = ntohl (parent_if_index);
19474 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19482 api_lldp_config (vat_main_t * vam)
19484 unformat_input_t *i = vam->input;
19485 vl_api_lldp_config_t *mp;
19487 int tx_interval = 0;
19488 u8 *sys_name = NULL;
19491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19493 if (unformat (i, "system-name %s", &sys_name))
19495 else if (unformat (i, "tx-hold %d", &tx_hold))
19497 else if (unformat (i, "tx-interval %d", &tx_interval))
19501 clib_warning ("parse error '%U'", format_unformat_error, i);
19506 vec_add1 (sys_name, 0);
19508 M (LLDP_CONFIG, mp);
19509 mp->tx_hold = htonl (tx_hold);
19510 mp->tx_interval = htonl (tx_interval);
19511 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19512 vec_free (sys_name);
19520 api_sw_interface_set_lldp (vat_main_t * vam)
19522 unformat_input_t *i = vam->input;
19523 vl_api_sw_interface_set_lldp_t *mp;
19524 u32 sw_if_index = ~0;
19526 u8 *port_desc = NULL, *mgmt_oid = NULL;
19527 ip4_address_t ip4_addr;
19528 ip6_address_t ip6_addr;
19531 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19532 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19536 if (unformat (i, "disable"))
19539 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19541 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19543 else if (unformat (i, "port-desc %s", &port_desc))
19545 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19547 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19549 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19555 if (sw_if_index == ~0)
19557 errmsg ("missing interface name or sw_if_index");
19561 /* Construct the API message */
19562 vec_add1 (port_desc, 0);
19563 vec_add1 (mgmt_oid, 0);
19564 M (SW_INTERFACE_SET_LLDP, mp);
19565 mp->sw_if_index = ntohl (sw_if_index);
19566 mp->enable = enable;
19567 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19568 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19569 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19570 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19571 vec_free (port_desc);
19572 vec_free (mgmt_oid);
19580 api_tcp_configure_src_addresses (vat_main_t * vam)
19582 vl_api_tcp_configure_src_addresses_t *mp;
19583 unformat_input_t *i = vam->input;
19584 vl_api_address_t first, last;
19589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19591 if (unformat (i, "%U - %U",
19592 unformat_vl_api_address, &first,
19593 unformat_vl_api_address, &last))
19597 errmsg ("one range per message (range already set)");
19602 else if (unformat (i, "vrf %d", &vrf_id))
19608 if (range_set == 0)
19610 errmsg ("address range not set");
19614 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19616 mp->vrf_id = ntohl (vrf_id);
19617 clib_memcpy (&mp->first_address, &first, sizeof (first));
19618 clib_memcpy (&mp->last_address, &last, sizeof (last));
19625 static void vl_api_app_namespace_add_del_reply_t_handler
19626 (vl_api_app_namespace_add_del_reply_t * mp)
19628 vat_main_t *vam = &vat_main;
19629 i32 retval = ntohl (mp->retval);
19630 if (vam->async_mode)
19632 vam->async_errors += (retval < 0);
19636 vam->retval = retval;
19638 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19639 vam->result_ready = 1;
19643 static void vl_api_app_namespace_add_del_reply_t_handler_json
19644 (vl_api_app_namespace_add_del_reply_t * mp)
19646 vat_main_t *vam = &vat_main;
19647 vat_json_node_t node;
19649 vat_json_init_object (&node);
19650 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19651 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19653 vat_json_print (vam->ofp, &node);
19654 vat_json_free (&node);
19656 vam->retval = ntohl (mp->retval);
19657 vam->result_ready = 1;
19661 api_app_namespace_add_del (vat_main_t * vam)
19663 vl_api_app_namespace_add_del_t *mp;
19664 unformat_input_t *i = vam->input;
19665 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19666 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19670 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19672 if (unformat (i, "id %_%v%_", &ns_id))
19674 else if (unformat (i, "secret %lu", &secret))
19676 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19677 sw_if_index_set = 1;
19678 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19680 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19685 if (!ns_id || !secret_set || !sw_if_index_set)
19687 errmsg ("namespace id, secret and sw_if_index must be set");
19690 if (vec_len (ns_id) > 64)
19692 errmsg ("namespace id too long");
19695 M (APP_NAMESPACE_ADD_DEL, mp);
19697 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
19698 mp->namespace_id_len = vec_len (ns_id);
19699 mp->secret = clib_host_to_net_u64 (secret);
19700 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19701 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19702 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19710 api_sock_init_shm (vat_main_t * vam)
19712 #if VPP_API_TEST_BUILTIN == 0
19713 unformat_input_t *i = vam->input;
19714 vl_api_shm_elem_config_t *config = 0;
19715 u64 size = 64 << 20;
19718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19720 if (unformat (i, "size %U", unformat_memory_size, &size))
19727 * Canned custom ring allocator config.
19728 * Should probably parse all of this
19730 vec_validate (config, 6);
19731 config[0].type = VL_API_VLIB_RING;
19732 config[0].size = 256;
19733 config[0].count = 32;
19735 config[1].type = VL_API_VLIB_RING;
19736 config[1].size = 1024;
19737 config[1].count = 16;
19739 config[2].type = VL_API_VLIB_RING;
19740 config[2].size = 4096;
19741 config[2].count = 2;
19743 config[3].type = VL_API_CLIENT_RING;
19744 config[3].size = 256;
19745 config[3].count = 32;
19747 config[4].type = VL_API_CLIENT_RING;
19748 config[4].size = 1024;
19749 config[4].count = 16;
19751 config[5].type = VL_API_CLIENT_RING;
19752 config[5].size = 4096;
19753 config[5].count = 2;
19755 config[6].type = VL_API_QUEUE;
19756 config[6].count = 128;
19757 config[6].size = sizeof (uword);
19759 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19761 vam->client_index_invalid = 1;
19769 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19771 vat_main_t *vam = &vat_main;
19776 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19777 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19778 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
19779 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19780 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19781 clib_net_to_host_u32 (mp->action_index), mp->tag);
19786 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19787 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19788 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
19789 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19790 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19791 clib_net_to_host_u32 (mp->action_index), mp->tag);
19796 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19799 vat_main_t *vam = &vat_main;
19800 vat_json_node_t *node = NULL;
19801 struct in6_addr ip6;
19802 struct in_addr ip4;
19804 if (VAT_JSON_ARRAY != vam->json_tree.type)
19806 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19807 vat_json_init_array (&vam->json_tree);
19809 node = vat_json_array_add (&vam->json_tree);
19810 vat_json_init_object (node);
19812 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
19813 vat_json_object_add_uint (node, "appns_index",
19814 clib_net_to_host_u32 (mp->appns_index));
19815 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19816 vat_json_object_add_uint (node, "scope", mp->scope);
19817 vat_json_object_add_uint (node, "action_index",
19818 clib_net_to_host_u32 (mp->action_index));
19819 vat_json_object_add_uint (node, "lcl_port",
19820 clib_net_to_host_u16 (mp->lcl_port));
19821 vat_json_object_add_uint (node, "rmt_port",
19822 clib_net_to_host_u16 (mp->rmt_port));
19823 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
19824 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
19825 vat_json_object_add_string_copy (node, "tag", mp->tag);
19828 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
19829 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19830 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
19831 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19835 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
19836 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19837 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
19838 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19843 api_session_rule_add_del (vat_main_t * vam)
19845 vl_api_session_rule_add_del_t *mp;
19846 unformat_input_t *i = vam->input;
19847 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19848 u32 appns_index = 0, scope = 0;
19849 ip4_address_t lcl_ip4, rmt_ip4;
19850 ip6_address_t lcl_ip6, rmt_ip6;
19851 u8 is_ip4 = 1, conn_set = 0;
19852 u8 is_add = 1, *tag = 0;
19855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19857 if (unformat (i, "del"))
19859 else if (unformat (i, "add"))
19861 else if (unformat (i, "proto tcp"))
19863 else if (unformat (i, "proto udp"))
19865 else if (unformat (i, "appns %d", &appns_index))
19867 else if (unformat (i, "scope %d", &scope))
19869 else if (unformat (i, "tag %_%v%_", &tag))
19873 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19874 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19882 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19883 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19889 else if (unformat (i, "action %d", &action))
19894 if (proto == ~0 || !conn_set || action == ~0)
19896 errmsg ("transport proto, connection and action must be set");
19902 errmsg ("scope should be 0-3");
19906 M (SESSION_RULE_ADD_DEL, mp);
19908 mp->is_ip4 = is_ip4;
19909 mp->transport_proto = proto;
19910 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19911 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19912 mp->lcl_plen = lcl_plen;
19913 mp->rmt_plen = rmt_plen;
19914 mp->action_index = clib_host_to_net_u32 (action);
19915 mp->appns_index = clib_host_to_net_u32 (appns_index);
19917 mp->is_add = is_add;
19920 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
19921 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
19925 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
19926 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
19930 clib_memcpy (mp->tag, tag, vec_len (tag));
19940 api_session_rules_dump (vat_main_t * vam)
19942 vl_api_session_rules_dump_t *mp;
19943 vl_api_control_ping_t *mp_ping;
19946 if (!vam->json_output)
19948 print (vam->ofp, "%=20s", "Session Rules");
19951 M (SESSION_RULES_DUMP, mp);
19955 /* Use a control ping for synchronization */
19956 MPING (CONTROL_PING, mp_ping);
19959 /* Wait for a reply... */
19965 api_ip_container_proxy_add_del (vat_main_t * vam)
19967 vl_api_ip_container_proxy_add_del_t *mp;
19968 unformat_input_t *i = vam->input;
19969 u32 sw_if_index = ~0;
19970 vl_api_prefix_t pfx = { };
19974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19976 if (unformat (i, "del"))
19978 else if (unformat (i, "add"))
19980 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
19982 else if (unformat (i, "sw_if_index %u", &sw_if_index))
19987 if (sw_if_index == ~0 || pfx.len == 0)
19989 errmsg ("address and sw_if_index must be set");
19993 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
19995 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19996 mp->is_add = is_add;
19997 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20005 api_qos_record_enable_disable (vat_main_t * vam)
20007 unformat_input_t *i = vam->input;
20008 vl_api_qos_record_enable_disable_t *mp;
20009 u32 sw_if_index, qs = 0xff;
20010 u8 sw_if_index_set = 0;
20014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20016 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20017 sw_if_index_set = 1;
20018 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20019 sw_if_index_set = 1;
20020 else if (unformat (i, "%U", unformat_qos_source, &qs))
20022 else if (unformat (i, "disable"))
20026 clib_warning ("parse error '%U'", format_unformat_error, i);
20031 if (sw_if_index_set == 0)
20033 errmsg ("missing interface name or sw_if_index");
20038 errmsg ("input location must be specified");
20042 M (QOS_RECORD_ENABLE_DISABLE, mp);
20044 mp->record.sw_if_index = ntohl (sw_if_index);
20045 mp->record.input_source = qs;
20046 mp->enable = enable;
20055 q_or_quit (vat_main_t * vam)
20057 #if VPP_API_TEST_BUILTIN == 0
20058 longjmp (vam->jump_buf, 1);
20060 return 0; /* not so much */
20064 q (vat_main_t * vam)
20066 return q_or_quit (vam);
20070 quit (vat_main_t * vam)
20072 return q_or_quit (vam);
20076 comment (vat_main_t * vam)
20082 elog_save (vat_main_t * vam)
20084 #if VPP_API_TEST_BUILTIN == 0
20085 elog_main_t *em = &vam->elog_main;
20086 unformat_input_t *i = vam->input;
20087 char *file, *chroot_file;
20088 clib_error_t *error;
20090 if (!unformat (i, "%s", &file))
20092 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20096 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20097 if (strstr (file, "..") || index (file, '/'))
20099 errmsg ("illegal characters in filename '%s'", file);
20103 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20107 errmsg ("Saving %wd of %wd events to %s",
20108 elog_n_events_in_buffer (em),
20109 elog_buffer_capacity (em), chroot_file);
20111 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20112 vec_free (chroot_file);
20115 clib_error_report (error);
20117 errmsg ("Use the vpp event loger...");
20124 elog_setup (vat_main_t * vam)
20126 #if VPP_API_TEST_BUILTIN == 0
20127 elog_main_t *em = &vam->elog_main;
20128 unformat_input_t *i = vam->input;
20129 u32 nevents = 128 << 10;
20131 (void) unformat (i, "nevents %d", &nevents);
20133 elog_init (em, nevents);
20134 vl_api_set_elog_main (em);
20135 vl_api_set_elog_trace_api_messages (1);
20136 errmsg ("Event logger initialized with %u events", nevents);
20138 errmsg ("Use the vpp event loger...");
20144 elog_enable (vat_main_t * vam)
20146 #if VPP_API_TEST_BUILTIN == 0
20147 elog_main_t *em = &vam->elog_main;
20149 elog_enable_disable (em, 1 /* enable */ );
20150 vl_api_set_elog_trace_api_messages (1);
20151 errmsg ("Event logger enabled...");
20153 errmsg ("Use the vpp event loger...");
20159 elog_disable (vat_main_t * vam)
20161 #if VPP_API_TEST_BUILTIN == 0
20162 elog_main_t *em = &vam->elog_main;
20164 elog_enable_disable (em, 0 /* enable */ );
20165 vl_api_set_elog_trace_api_messages (1);
20166 errmsg ("Event logger disabled...");
20168 errmsg ("Use the vpp event loger...");
20174 statseg (vat_main_t * vam)
20176 ssvm_private_t *ssvmp = &vam->stat_segment;
20177 ssvm_shared_header_t *shared_header = ssvmp->sh;
20178 vlib_counter_t **counters;
20179 u64 thread0_index1_packets;
20180 u64 thread0_index1_bytes;
20181 f64 vector_rate, input_rate;
20184 uword *counter_vector_by_name;
20185 if (vam->stat_segment_lockp == 0)
20187 errmsg ("Stat segment not mapped...");
20191 /* look up "/if/rx for sw_if_index 1 as a test */
20193 clib_spinlock_lock (vam->stat_segment_lockp);
20195 counter_vector_by_name = (uword *) shared_header->opaque[1];
20197 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20200 clib_spinlock_unlock (vam->stat_segment_lockp);
20201 errmsg ("/if/tx not found?");
20205 /* Fish per-thread vector of combined counters from shared memory */
20206 counters = (vlib_counter_t **) p[0];
20208 if (vec_len (counters[0]) < 2)
20210 clib_spinlock_unlock (vam->stat_segment_lockp);
20211 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20215 /* Read thread 0 sw_if_index 1 counter */
20216 thread0_index1_packets = counters[0][1].packets;
20217 thread0_index1_bytes = counters[0][1].bytes;
20219 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20222 clib_spinlock_unlock (vam->stat_segment_lockp);
20223 errmsg ("vector_rate not found?");
20227 vector_rate = *(f64 *) (p[0]);
20228 p = hash_get_mem (counter_vector_by_name, "input_rate");
20231 clib_spinlock_unlock (vam->stat_segment_lockp);
20232 errmsg ("input_rate not found?");
20235 input_rate = *(f64 *) (p[0]);
20237 clib_spinlock_unlock (vam->stat_segment_lockp);
20239 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20240 vector_rate, input_rate);
20241 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20242 thread0_index1_packets, thread0_index1_bytes);
20248 cmd_cmp (void *a1, void *a2)
20253 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20257 help (vat_main_t * vam)
20262 unformat_input_t *i = vam->input;
20265 if (unformat (i, "%s", &name))
20269 vec_add1 (name, 0);
20271 hs = hash_get_mem (vam->help_by_name, name);
20273 print (vam->ofp, "usage: %s %s", name, hs[0]);
20275 print (vam->ofp, "No such msg / command '%s'", name);
20280 print (vam->ofp, "Help is available for the following:");
20283 hash_foreach_pair (p, vam->function_by_name,
20285 vec_add1 (cmds, (u8 *)(p->key));
20289 vec_sort_with_function (cmds, cmd_cmp);
20291 for (j = 0; j < vec_len (cmds); j++)
20292 print (vam->ofp, "%s", cmds[j]);
20299 set (vat_main_t * vam)
20301 u8 *name = 0, *value = 0;
20302 unformat_input_t *i = vam->input;
20304 if (unformat (i, "%s", &name))
20306 /* The input buffer is a vector, not a string. */
20307 value = vec_dup (i->buffer);
20308 vec_delete (value, i->index, 0);
20309 /* Almost certainly has a trailing newline */
20310 if (value[vec_len (value) - 1] == '\n')
20311 value[vec_len (value) - 1] = 0;
20312 /* Make sure it's a proper string, one way or the other */
20313 vec_add1 (value, 0);
20314 (void) clib_macro_set_value (&vam->macro_main,
20315 (char *) name, (char *) value);
20318 errmsg ("usage: set <name> <value>");
20326 unset (vat_main_t * vam)
20330 if (unformat (vam->input, "%s", &name))
20331 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20332 errmsg ("unset: %s wasn't set", name);
20345 macro_sort_cmp (void *a1, void *a2)
20347 macro_sort_t *s1 = a1;
20348 macro_sort_t *s2 = a2;
20350 return strcmp ((char *) (s1->name), (char *) (s2->name));
20354 dump_macro_table (vat_main_t * vam)
20356 macro_sort_t *sort_me = 0, *sm;
20361 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20363 vec_add2 (sort_me, sm, 1);
20364 sm->name = (u8 *)(p->key);
20365 sm->value = (u8 *) (p->value[0]);
20369 vec_sort_with_function (sort_me, macro_sort_cmp);
20371 if (vec_len (sort_me))
20372 print (vam->ofp, "%-15s%s", "Name", "Value");
20374 print (vam->ofp, "The macro table is empty...");
20376 for (i = 0; i < vec_len (sort_me); i++)
20377 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20382 dump_node_table (vat_main_t * vam)
20385 vlib_node_t *node, *next_node;
20387 if (vec_len (vam->graph_nodes) == 0)
20389 print (vam->ofp, "Node table empty, issue get_node_graph...");
20393 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20395 node = vam->graph_nodes[0][i];
20396 print (vam->ofp, "[%d] %s", i, node->name);
20397 for (j = 0; j < vec_len (node->next_nodes); j++)
20399 if (node->next_nodes[j] != ~0)
20401 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20402 print (vam->ofp, " [%d] %s", j, next_node->name);
20410 value_sort_cmp (void *a1, void *a2)
20412 name_sort_t *n1 = a1;
20413 name_sort_t *n2 = a2;
20415 if (n1->value < n2->value)
20417 if (n1->value > n2->value)
20424 dump_msg_api_table (vat_main_t * vam)
20426 api_main_t *am = vlibapi_get_main ();
20427 name_sort_t *nses = 0, *ns;
20432 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20434 vec_add2 (nses, ns, 1);
20435 ns->name = (u8 *)(hp->key);
20436 ns->value = (u32) hp->value[0];
20440 vec_sort_with_function (nses, value_sort_cmp);
20442 for (i = 0; i < vec_len (nses); i++)
20443 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20449 get_msg_id (vat_main_t * vam)
20454 if (unformat (vam->input, "%s", &name_and_crc))
20456 message_index = vl_msg_api_get_msg_index (name_and_crc);
20457 if (message_index == ~0)
20459 print (vam->ofp, " '%s' not found", name_and_crc);
20462 print (vam->ofp, " '%s' has message index %d",
20463 name_and_crc, message_index);
20466 errmsg ("name_and_crc required...");
20471 search_node_table (vat_main_t * vam)
20473 unformat_input_t *line_input = vam->input;
20476 vlib_node_t *node, *next_node;
20479 if (vam->graph_node_index_by_name == 0)
20481 print (vam->ofp, "Node table empty, issue get_node_graph...");
20485 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20487 if (unformat (line_input, "%s", &node_to_find))
20489 vec_add1 (node_to_find, 0);
20490 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20493 print (vam->ofp, "%s not found...", node_to_find);
20496 node = vam->graph_nodes[0][p[0]];
20497 print (vam->ofp, "[%d] %s", p[0], node->name);
20498 for (j = 0; j < vec_len (node->next_nodes); j++)
20500 if (node->next_nodes[j] != ~0)
20502 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20503 print (vam->ofp, " [%d] %s", j, next_node->name);
20510 clib_warning ("parse error '%U'", format_unformat_error,
20516 vec_free (node_to_find);
20525 script (vat_main_t * vam)
20527 #if (VPP_API_TEST_BUILTIN==0)
20529 char *save_current_file;
20530 unformat_input_t save_input;
20531 jmp_buf save_jump_buf;
20532 u32 save_line_number;
20534 FILE *new_fp, *save_ifp;
20536 if (unformat (vam->input, "%s", &s))
20538 new_fp = fopen ((char *) s, "r");
20541 errmsg ("Couldn't open script file %s", s);
20548 errmsg ("Missing script name");
20552 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20553 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20554 save_ifp = vam->ifp;
20555 save_line_number = vam->input_line_number;
20556 save_current_file = (char *) vam->current_file;
20558 vam->input_line_number = 0;
20560 vam->current_file = s;
20563 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20564 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20565 vam->ifp = save_ifp;
20566 vam->input_line_number = save_line_number;
20567 vam->current_file = (u8 *) save_current_file;
20572 clib_warning ("use the exec command...");
20578 echo (vat_main_t * vam)
20580 print (vam->ofp, "%v", vam->input->buffer);
20584 /* List of API message constructors, CLI names map to api_xxx */
20585 #define foreach_vpe_api_msg \
20586 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20587 _(sw_interface_dump,"") \
20588 _(sw_interface_set_flags, \
20589 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20590 _(sw_interface_add_del_address, \
20591 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20592 _(sw_interface_set_rx_mode, \
20593 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20594 _(sw_interface_set_rx_placement, \
20595 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20596 _(sw_interface_rx_placement_dump, \
20597 "[<intfc> | sw_if_index <id>]") \
20598 _(sw_interface_set_table, \
20599 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20600 _(sw_interface_set_mpls_enable, \
20601 "<intfc> | sw_if_index [disable | dis]") \
20602 _(sw_interface_set_vpath, \
20603 "<intfc> | sw_if_index <id> enable | disable") \
20604 _(sw_interface_set_vxlan_bypass, \
20605 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20606 _(sw_interface_set_geneve_bypass, \
20607 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20608 _(sw_interface_set_l2_xconnect, \
20609 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20610 "enable | disable") \
20611 _(sw_interface_set_l2_bridge, \
20612 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20613 "[shg <split-horizon-group>] [bvi]\n" \
20614 "enable | disable") \
20615 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20616 _(bridge_domain_add_del, \
20617 "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") \
20618 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20620 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20621 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20622 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20624 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20626 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20628 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
20630 "<vpp-if-name> | sw_if_index <id>") \
20631 _(sw_interface_tap_v2_dump, "") \
20632 _(virtio_pci_create, \
20633 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20634 _(virtio_pci_delete, \
20635 "<vpp-if-name> | sw_if_index <id>") \
20636 _(sw_interface_virtio_pci_dump, "") \
20638 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20639 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20642 "<vpp-if-name> | sw_if_index <id>") \
20644 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20645 _(bond_detach_slave, \
20646 "sw_if_index <n>") \
20647 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20648 _(sw_interface_bond_dump, "") \
20649 _(sw_interface_slave_dump, \
20650 "<vpp-if-name> | sw_if_index <id>") \
20651 _(ip_table_add_del, \
20652 "table <n> [ipv6] [add | del]\n") \
20653 _(ip_route_add_del, \
20654 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20655 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20656 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20657 "[multipath] [count <n>] [del]") \
20658 _(ip_mroute_add_del, \
20659 "<src> <grp>/<mask> [table-id <n>]\n" \
20660 "[<intfc> | sw_if_index <id>] [local] [del]") \
20661 _(mpls_table_add_del, \
20662 "table <n> [add | del]\n") \
20663 _(mpls_route_add_del, \
20664 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20665 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20666 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20667 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20668 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20669 "[count <n>] [del]") \
20670 _(mpls_ip_bind_unbind, \
20671 "<label> <addr/len>") \
20672 _(mpls_tunnel_add_del, \
20673 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20674 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20675 "[l2-only] [out-label <n>]") \
20676 _(sr_mpls_policy_add, \
20677 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20678 _(sr_mpls_policy_del, \
20680 _(bier_table_add_del, \
20681 "<label> <sub-domain> <set> <bsl> [del]") \
20682 _(bier_route_add_del, \
20683 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20684 "[<intfc> | sw_if_index <id>]" \
20685 "[weight <n>] [del] [multipath]") \
20686 _(sw_interface_set_unnumbered, \
20687 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20688 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20689 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20690 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20691 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20692 "[outer_vlan_id_any][inner_vlan_id_any]") \
20693 _(ip_table_replace_begin, "table <n> [ipv6]") \
20694 _(ip_table_flush, "table <n> [ipv6]") \
20695 _(ip_table_replace_end, "table <n> [ipv6]") \
20696 _(set_ip_flow_hash, \
20697 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20698 _(sw_interface_ip6_enable_disable, \
20699 "<intfc> | sw_if_index <id> enable | disable") \
20700 _(l2_patch_add_del, \
20701 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20702 "enable | disable") \
20703 _(sr_localsid_add_del, \
20704 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20705 "fib-table <num> (end.psp) sw_if_index <num>") \
20706 _(classify_add_del_table, \
20707 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20708 " [del] [del-chain] mask <mask-value>\n" \
20709 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20710 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20711 _(classify_add_del_session, \
20712 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20713 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20714 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20715 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20716 _(classify_set_interface_ip_table, \
20717 "<intfc> | sw_if_index <nn> table <nn>") \
20718 _(classify_set_interface_l2_tables, \
20719 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20720 " [other-table <nn>]") \
20721 _(get_node_index, "node <node-name") \
20722 _(add_node_next, "node <node-name> next <next-node-name>") \
20723 _(l2tpv3_create_tunnel, \
20724 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20725 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20726 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20727 _(l2tpv3_set_tunnel_cookies, \
20728 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20729 "[new_remote_cookie <nn>]\n") \
20730 _(l2tpv3_interface_enable_disable, \
20731 "<intfc> | sw_if_index <nn> enable | disable") \
20732 _(l2tpv3_set_lookup_key, \
20733 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20734 _(sw_if_l2tpv3_tunnel_dump, "") \
20735 _(vxlan_offload_rx, \
20736 "hw { <interface name> | hw_if_index <nn>} " \
20737 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20738 _(vxlan_add_del_tunnel, \
20739 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20740 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20741 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20742 _(geneve_add_del_tunnel, \
20743 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20744 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20745 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20746 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20747 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20748 _(gre_tunnel_add_del, \
20749 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20750 "[teb | erspan <session-id>] [del]") \
20751 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20752 _(l2_fib_clear_table, "") \
20753 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20754 _(l2_interface_vlan_tag_rewrite, \
20755 "<intfc> | sw_if_index <nn> \n" \
20756 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20757 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20758 _(create_vhost_user_if, \
20759 "socket <filename> [server] [renumber <dev_instance>] " \
20760 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20761 "[mac <mac_address>]") \
20762 _(modify_vhost_user_if, \
20763 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20764 "[server] [renumber <dev_instance>] [gso]") \
20765 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20766 _(sw_interface_vhost_user_dump, "") \
20767 _(show_version, "") \
20768 _(show_threads, "") \
20769 _(vxlan_gpe_add_del_tunnel, \
20770 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20771 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20772 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20773 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20774 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20775 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20776 _(interface_name_renumber, \
20777 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20778 _(input_acl_set_interface, \
20779 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20780 " [l2-table <nn>] [del]") \
20781 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20782 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20783 _(ip_dump, "ipv4 | ipv6") \
20784 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20785 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20787 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20788 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20789 " integ_alg <alg> integ_key <hex>") \
20790 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20791 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20792 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20793 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20794 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20795 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20796 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20797 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20798 " [instance <n>]") \
20799 _(ipsec_sa_dump, "[sa_id <n>]") \
20800 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20801 _(delete_loopback,"sw_if_index <nn>") \
20802 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20803 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20804 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20805 _(want_interface_events, "enable|disable") \
20806 _(get_first_msg_id, "client <name>") \
20807 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20808 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20809 "fib-id <nn> [ip4][ip6][default]") \
20810 _(get_node_graph, " ") \
20811 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20812 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20813 _(ioam_disable, "") \
20814 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20815 " sw_if_index <sw_if_index> p <priority> " \
20816 "w <weight>] [del]") \
20817 _(one_add_del_locator, "locator-set <locator_name> " \
20818 "iface <intf> | sw_if_index <sw_if_index> " \
20819 "p <priority> w <weight> [del]") \
20820 _(one_add_del_local_eid,"vni <vni> eid " \
20821 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20822 "locator-set <locator_name> [del]" \
20823 "[key-id sha1|sha256 secret-key <secret-key>]")\
20824 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20825 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20826 _(one_enable_disable, "enable|disable") \
20827 _(one_map_register_enable_disable, "enable|disable") \
20828 _(one_map_register_fallback_threshold, "<value>") \
20829 _(one_rloc_probe_enable_disable, "enable|disable") \
20830 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20832 "rloc <locator> p <prio> " \
20833 "w <weight> [rloc <loc> ... ] " \
20834 "action <action> [del-all]") \
20835 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20837 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20838 _(one_use_petr, "ip-address> | disable") \
20839 _(one_map_request_mode, "src-dst|dst-only") \
20840 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20841 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20842 _(one_locator_set_dump, "[local | remote]") \
20843 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20844 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20845 "[local] | [remote]") \
20846 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20847 _(one_ndp_bd_get, "") \
20848 _(one_ndp_entries_get, "bd <bridge-domain>") \
20849 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20850 _(one_l2_arp_bd_get, "") \
20851 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20852 _(one_stats_enable_disable, "enable|disable") \
20853 _(show_one_stats_enable_disable, "") \
20854 _(one_eid_table_vni_dump, "") \
20855 _(one_eid_table_map_dump, "l2|l3") \
20856 _(one_map_resolver_dump, "") \
20857 _(one_map_server_dump, "") \
20858 _(one_adjacencies_get, "vni <vni>") \
20859 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20860 _(show_one_rloc_probe_state, "") \
20861 _(show_one_map_register_state, "") \
20862 _(show_one_status, "") \
20863 _(one_stats_dump, "") \
20864 _(one_stats_flush, "") \
20865 _(one_get_map_request_itr_rlocs, "") \
20866 _(one_map_register_set_ttl, "<ttl>") \
20867 _(one_set_transport_protocol, "udp|api") \
20868 _(one_get_transport_protocol, "") \
20869 _(one_enable_disable_xtr_mode, "enable|disable") \
20870 _(one_show_xtr_mode, "") \
20871 _(one_enable_disable_pitr_mode, "enable|disable") \
20872 _(one_show_pitr_mode, "") \
20873 _(one_enable_disable_petr_mode, "enable|disable") \
20874 _(one_show_petr_mode, "") \
20875 _(show_one_nsh_mapping, "") \
20876 _(show_one_pitr, "") \
20877 _(show_one_use_petr, "") \
20878 _(show_one_map_request_mode, "") \
20879 _(show_one_map_register_ttl, "") \
20880 _(show_one_map_register_fallback_threshold, "") \
20881 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20882 " sw_if_index <sw_if_index> p <priority> " \
20883 "w <weight>] [del]") \
20884 _(lisp_add_del_locator, "locator-set <locator_name> " \
20885 "iface <intf> | sw_if_index <sw_if_index> " \
20886 "p <priority> w <weight> [del]") \
20887 _(lisp_add_del_local_eid,"vni <vni> eid " \
20888 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20889 "locator-set <locator_name> [del]" \
20890 "[key-id sha1|sha256 secret-key <secret-key>]") \
20891 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20892 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20893 _(lisp_enable_disable, "enable|disable") \
20894 _(lisp_map_register_enable_disable, "enable|disable") \
20895 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20896 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20898 "rloc <locator> p <prio> " \
20899 "w <weight> [rloc <loc> ... ] " \
20900 "action <action> [del-all]") \
20901 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20903 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20904 _(lisp_use_petr, "<ip-address> | disable") \
20905 _(lisp_map_request_mode, "src-dst|dst-only") \
20906 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20907 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20908 _(lisp_locator_set_dump, "[local | remote]") \
20909 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20910 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20911 "[local] | [remote]") \
20912 _(lisp_eid_table_vni_dump, "") \
20913 _(lisp_eid_table_map_dump, "l2|l3") \
20914 _(lisp_map_resolver_dump, "") \
20915 _(lisp_map_server_dump, "") \
20916 _(lisp_adjacencies_get, "vni <vni>") \
20917 _(gpe_fwd_entry_vnis_get, "") \
20918 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20919 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20920 "[table <table-id>]") \
20921 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20922 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20923 _(gpe_set_encap_mode, "lisp|vxlan") \
20924 _(gpe_get_encap_mode, "") \
20925 _(lisp_gpe_add_del_iface, "up|down") \
20926 _(lisp_gpe_enable_disable, "enable|disable") \
20927 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20928 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20929 _(show_lisp_rloc_probe_state, "") \
20930 _(show_lisp_map_register_state, "") \
20931 _(show_lisp_status, "") \
20932 _(lisp_get_map_request_itr_rlocs, "") \
20933 _(show_lisp_pitr, "") \
20934 _(show_lisp_use_petr, "") \
20935 _(show_lisp_map_request_mode, "") \
20936 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20937 _(af_packet_delete, "name <host interface name>") \
20938 _(af_packet_dump, "") \
20939 _(policer_add_del, "name <policer name> <params> [del]") \
20940 _(policer_dump, "[name <policer name>]") \
20941 _(policer_classify_set_interface, \
20942 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20943 " [l2-table <nn>] [del]") \
20944 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20945 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20946 _(mpls_table_dump, "") \
20947 _(mpls_route_dump, "table-id <ID>") \
20948 _(classify_table_ids, "") \
20949 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20950 _(classify_table_info, "table_id <nn>") \
20951 _(classify_session_dump, "table_id <nn>") \
20952 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20953 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20954 "[template_interval <nn>] [udp_checksum]") \
20955 _(ipfix_exporter_dump, "") \
20956 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20957 _(ipfix_classify_stream_dump, "") \
20958 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20959 _(ipfix_classify_table_dump, "") \
20960 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20961 _(sw_interface_span_dump, "[l2]") \
20962 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20963 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
20964 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20965 _(pg_enable_disable, "[stream <id>] disable") \
20966 _(ip_source_and_port_range_check_add_del, \
20967 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20968 _(ip_source_and_port_range_check_interface_add_del, \
20969 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20970 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20971 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20972 _(l2_interface_pbb_tag_rewrite, \
20973 "<intfc> | sw_if_index <nn> \n" \
20974 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
20975 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
20976 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
20977 _(flow_classify_set_interface, \
20978 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
20979 _(flow_classify_dump, "type [ip4|ip6]") \
20980 _(ip_table_dump, "") \
20981 _(ip_route_dump, "table-id [ip4|ip6]") \
20982 _(ip_mtable_dump, "") \
20983 _(ip_mroute_dump, "table-id [ip4|ip6]") \
20984 _(feature_enable_disable, "arc_name <arc_name> " \
20985 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
20986 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
20987 "[enable | disable] ") \
20988 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
20990 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
20991 "mac <mac-address> [del]") \
20992 _(l2_xconnect_dump, "") \
20993 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
20994 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
20995 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
20996 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
20997 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
20998 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
20999 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21000 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21001 _(sock_init_shm, "size <nnn>") \
21002 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21003 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21004 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21005 _(session_rules_dump, "") \
21006 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21007 _(output_acl_set_interface, \
21008 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21009 " [l2-table <nn>] [del]") \
21010 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21012 /* List of command functions, CLI names map directly to functions */
21013 #define foreach_cli_function \
21014 _(comment, "usage: comment <ignore-rest-of-line>") \
21015 _(dump_interface_table, "usage: dump_interface_table") \
21016 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21017 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21018 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21019 _(dump_macro_table, "usage: dump_macro_table ") \
21020 _(dump_node_table, "usage: dump_node_table") \
21021 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21022 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21023 _(elog_disable, "usage: elog_disable") \
21024 _(elog_enable, "usage: elog_enable") \
21025 _(elog_save, "usage: elog_save <filename>") \
21026 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21027 _(echo, "usage: echo <message>") \
21028 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21029 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21030 _(help, "usage: help") \
21031 _(q, "usage: quit") \
21032 _(quit, "usage: quit") \
21033 _(search_node_table, "usage: search_node_table <name>...") \
21034 _(set, "usage: set <variable-name> <value>") \
21035 _(script, "usage: script <file-name>") \
21036 _(statseg, "usage: statseg") \
21037 _(unset, "usage: unset <variable-name>")
21040 static void vl_api_##n##_t_handler_uni \
21041 (vl_api_##n##_t * mp) \
21043 vat_main_t * vam = &vat_main; \
21044 if (vam->json_output) { \
21045 vl_api_##n##_t_handler_json(mp); \
21047 vl_api_##n##_t_handler(mp); \
21050 foreach_vpe_api_reply_msg;
21051 #if VPP_API_TEST_BUILTIN == 0
21052 foreach_standalone_reply_msg;
21057 vat_api_hookup (vat_main_t * vam)
21060 vl_msg_api_set_handlers(VL_API_##N, #n, \
21061 vl_api_##n##_t_handler_uni, \
21063 vl_api_##n##_t_endian, \
21064 vl_api_##n##_t_print, \
21065 sizeof(vl_api_##n##_t), 1);
21066 foreach_vpe_api_reply_msg;
21067 #if VPP_API_TEST_BUILTIN == 0
21068 foreach_standalone_reply_msg;
21072 #if (VPP_API_TEST_BUILTIN==0)
21073 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21075 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21077 vam->function_by_name = hash_create_string (0, sizeof (uword));
21079 vam->help_by_name = hash_create_string (0, sizeof (uword));
21082 /* API messages we can send */
21083 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21084 foreach_vpe_api_msg;
21088 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21089 foreach_vpe_api_msg;
21092 /* CLI functions */
21093 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21094 foreach_cli_function;
21098 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21099 foreach_cli_function;
21103 #if VPP_API_TEST_BUILTIN
21104 static clib_error_t *
21105 vat_api_hookup_shim (vlib_main_t * vm)
21107 vat_api_hookup (&vat_main);
21111 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21115 * fd.io coding-style-patch-verification: ON
21118 * eval: (c-set-style "gnu")