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/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_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1434 u32 sw_if_index = ntohl (mp->sw_if_index);
1435 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1436 mp->mac_ip ? "mac/ip binding" : "address resolution",
1437 ntohl (mp->pid), format_ip4_address, mp->ip,
1438 format_vl_api_mac_address, &mp->mac, sw_if_index);
1442 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1444 /* JSON output not supported */
1448 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1450 u32 sw_if_index = ntohl (mp->sw_if_index);
1451 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1452 mp->mac_ip ? "mac/ip binding" : "address resolution",
1453 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1454 format_vl_api_mac_address, mp->mac, sw_if_index);
1458 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1460 /* JSON output not supported */
1464 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1466 u32 n_macs = ntohl (mp->n_macs);
1467 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1468 ntohl (mp->pid), mp->client_index, n_macs);
1470 for (i = 0; i < n_macs; i++)
1472 vl_api_mac_entry_t *mac = &mp->mac[i];
1473 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1474 i + 1, ntohl (mac->sw_if_index),
1475 format_ethernet_address, mac->mac_addr, mac->action);
1482 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1484 /* JSON output not supported */
1487 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1488 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1491 * Special-case: build the bridge domain table, maintain
1492 * the next bd id vbl.
1494 static void vl_api_bridge_domain_details_t_handler
1495 (vl_api_bridge_domain_details_t * mp)
1497 vat_main_t *vam = &vat_main;
1498 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1501 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1502 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1504 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1505 ntohl (mp->bd_id), mp->learn, mp->forward,
1506 mp->flood, ntohl (mp->bvi_sw_if_index),
1507 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1511 vl_api_bridge_domain_sw_if_t *sw_ifs;
1512 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1515 sw_ifs = mp->sw_if_details;
1516 for (i = 0; i < n_sw_ifs; i++)
1522 sw_if_index = ntohl (sw_ifs->sw_if_index);
1525 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1527 if ((u32) p->value[0] == sw_if_index)
1529 sw_if_name = (u8 *)(p->key);
1534 print (vam->ofp, "%7d %3d %s", sw_if_index,
1535 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1536 "sw_if_index not found!");
1543 static void vl_api_bridge_domain_details_t_handler_json
1544 (vl_api_bridge_domain_details_t * mp)
1546 vat_main_t *vam = &vat_main;
1547 vat_json_node_t *node, *array = NULL;
1548 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1550 if (VAT_JSON_ARRAY != vam->json_tree.type)
1552 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1553 vat_json_init_array (&vam->json_tree);
1555 node = vat_json_array_add (&vam->json_tree);
1557 vat_json_init_object (node);
1558 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1559 vat_json_object_add_uint (node, "flood", mp->flood);
1560 vat_json_object_add_uint (node, "forward", mp->forward);
1561 vat_json_object_add_uint (node, "learn", mp->learn);
1562 vat_json_object_add_uint (node, "bvi_sw_if_index",
1563 ntohl (mp->bvi_sw_if_index));
1564 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1565 array = vat_json_object_add (node, "sw_if");
1566 vat_json_init_array (array);
1572 vl_api_bridge_domain_sw_if_t *sw_ifs;
1575 sw_ifs = mp->sw_if_details;
1576 for (i = 0; i < n_sw_ifs; i++)
1578 node = vat_json_array_add (array);
1579 vat_json_init_object (node);
1580 vat_json_object_add_uint (node, "sw_if_index",
1581 ntohl (sw_ifs->sw_if_index));
1582 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1588 static void vl_api_control_ping_reply_t_handler
1589 (vl_api_control_ping_reply_t * mp)
1591 vat_main_t *vam = &vat_main;
1592 i32 retval = ntohl (mp->retval);
1593 if (vam->async_mode)
1595 vam->async_errors += (retval < 0);
1599 vam->retval = retval;
1600 vam->result_ready = 1;
1602 if (vam->socket_client_main)
1603 vam->socket_client_main->control_pings_outstanding--;
1606 static void vl_api_control_ping_reply_t_handler_json
1607 (vl_api_control_ping_reply_t * mp)
1609 vat_main_t *vam = &vat_main;
1610 i32 retval = ntohl (mp->retval);
1612 if (VAT_JSON_NONE != vam->json_tree.type)
1614 vat_json_print (vam->ofp, &vam->json_tree);
1615 vat_json_free (&vam->json_tree);
1616 vam->json_tree.type = VAT_JSON_NONE;
1621 vat_json_init_array (&vam->json_tree);
1622 vat_json_print (vam->ofp, &vam->json_tree);
1623 vam->json_tree.type = VAT_JSON_NONE;
1626 vam->retval = retval;
1627 vam->result_ready = 1;
1631 vl_api_bridge_domain_set_mac_age_reply_t_handler
1632 (vl_api_bridge_domain_set_mac_age_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_bridge_domain_set_mac_age_reply_t_handler_json
1648 (vl_api_bridge_domain_set_mac_age_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));
1656 vat_json_print (vam->ofp, &node);
1657 vat_json_free (&node);
1659 vam->retval = ntohl (mp->retval);
1660 vam->result_ready = 1;
1664 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1666 vat_main_t *vam = &vat_main;
1667 i32 retval = ntohl (mp->retval);
1668 if (vam->async_mode)
1670 vam->async_errors += (retval < 0);
1674 vam->retval = retval;
1675 vam->result_ready = 1;
1679 static void vl_api_l2_flags_reply_t_handler_json
1680 (vl_api_l2_flags_reply_t * mp)
1682 vat_main_t *vam = &vat_main;
1683 vat_json_node_t node;
1685 vat_json_init_object (&node);
1686 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1687 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1688 ntohl (mp->resulting_feature_bitmap));
1690 vat_json_print (vam->ofp, &node);
1691 vat_json_free (&node);
1693 vam->retval = ntohl (mp->retval);
1694 vam->result_ready = 1;
1697 static void vl_api_bridge_flags_reply_t_handler
1698 (vl_api_bridge_flags_reply_t * mp)
1700 vat_main_t *vam = &vat_main;
1701 i32 retval = ntohl (mp->retval);
1702 if (vam->async_mode)
1704 vam->async_errors += (retval < 0);
1708 vam->retval = retval;
1709 vam->result_ready = 1;
1713 static void vl_api_bridge_flags_reply_t_handler_json
1714 (vl_api_bridge_flags_reply_t * mp)
1716 vat_main_t *vam = &vat_main;
1717 vat_json_node_t node;
1719 vat_json_init_object (&node);
1720 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1721 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1722 ntohl (mp->resulting_feature_bitmap));
1724 vat_json_print (vam->ofp, &node);
1725 vat_json_free (&node);
1727 vam->retval = ntohl (mp->retval);
1728 vam->result_ready = 1;
1732 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1734 vat_main_t *vam = &vat_main;
1735 i32 retval = ntohl (mp->retval);
1736 if (vam->async_mode)
1738 vam->async_errors += (retval < 0);
1742 vam->retval = retval;
1743 vam->sw_if_index = ntohl (mp->sw_if_index);
1744 vam->result_ready = 1;
1749 static void vl_api_tap_create_v2_reply_t_handler_json
1750 (vl_api_tap_create_v2_reply_t * mp)
1752 vat_main_t *vam = &vat_main;
1753 vat_json_node_t node;
1755 vat_json_init_object (&node);
1756 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1757 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1759 vat_json_print (vam->ofp, &node);
1760 vat_json_free (&node);
1762 vam->retval = ntohl (mp->retval);
1763 vam->result_ready = 1;
1768 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1770 vat_main_t *vam = &vat_main;
1771 i32 retval = ntohl (mp->retval);
1772 if (vam->async_mode)
1774 vam->async_errors += (retval < 0);
1778 vam->retval = retval;
1779 vam->result_ready = 1;
1783 static void vl_api_tap_delete_v2_reply_t_handler_json
1784 (vl_api_tap_delete_v2_reply_t * mp)
1786 vat_main_t *vam = &vat_main;
1787 vat_json_node_t node;
1789 vat_json_init_object (&node);
1790 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1792 vat_json_print (vam->ofp, &node);
1793 vat_json_free (&node);
1795 vam->retval = ntohl (mp->retval);
1796 vam->result_ready = 1;
1800 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1803 vat_main_t *vam = &vat_main;
1804 i32 retval = ntohl (mp->retval);
1805 if (vam->async_mode)
1807 vam->async_errors += (retval < 0);
1811 vam->retval = retval;
1812 vam->sw_if_index = ntohl (mp->sw_if_index);
1813 vam->result_ready = 1;
1817 static void vl_api_virtio_pci_create_reply_t_handler_json
1818 (vl_api_virtio_pci_create_reply_t * mp)
1820 vat_main_t *vam = &vat_main;
1821 vat_json_node_t node;
1823 vat_json_init_object (&node);
1824 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1825 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1827 vat_json_print (vam->ofp, &node);
1828 vat_json_free (&node);
1830 vam->retval = ntohl (mp->retval);
1831 vam->result_ready = 1;
1836 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1839 vat_main_t *vam = &vat_main;
1840 i32 retval = ntohl (mp->retval);
1841 if (vam->async_mode)
1843 vam->async_errors += (retval < 0);
1847 vam->retval = retval;
1848 vam->result_ready = 1;
1852 static void vl_api_virtio_pci_delete_reply_t_handler_json
1853 (vl_api_virtio_pci_delete_reply_t * mp)
1855 vat_main_t *vam = &vat_main;
1856 vat_json_node_t node;
1858 vat_json_init_object (&node);
1859 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1861 vat_json_print (vam->ofp, &node);
1862 vat_json_free (&node);
1864 vam->retval = ntohl (mp->retval);
1865 vam->result_ready = 1;
1869 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1871 vat_main_t *vam = &vat_main;
1872 i32 retval = ntohl (mp->retval);
1874 if (vam->async_mode)
1876 vam->async_errors += (retval < 0);
1880 vam->retval = retval;
1881 vam->sw_if_index = ntohl (mp->sw_if_index);
1882 vam->result_ready = 1;
1886 static void vl_api_bond_create_reply_t_handler_json
1887 (vl_api_bond_create_reply_t * mp)
1889 vat_main_t *vam = &vat_main;
1890 vat_json_node_t node;
1892 vat_json_init_object (&node);
1893 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1894 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1896 vat_json_print (vam->ofp, &node);
1897 vat_json_free (&node);
1899 vam->retval = ntohl (mp->retval);
1900 vam->result_ready = 1;
1904 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1906 vat_main_t *vam = &vat_main;
1907 i32 retval = ntohl (mp->retval);
1909 if (vam->async_mode)
1911 vam->async_errors += (retval < 0);
1915 vam->retval = retval;
1916 vam->result_ready = 1;
1920 static void vl_api_bond_delete_reply_t_handler_json
1921 (vl_api_bond_delete_reply_t * mp)
1923 vat_main_t *vam = &vat_main;
1924 vat_json_node_t node;
1926 vat_json_init_object (&node);
1927 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1929 vat_json_print (vam->ofp, &node);
1930 vat_json_free (&node);
1932 vam->retval = ntohl (mp->retval);
1933 vam->result_ready = 1;
1937 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1939 vat_main_t *vam = &vat_main;
1940 i32 retval = ntohl (mp->retval);
1942 if (vam->async_mode)
1944 vam->async_errors += (retval < 0);
1948 vam->retval = retval;
1949 vam->result_ready = 1;
1953 static void vl_api_bond_enslave_reply_t_handler_json
1954 (vl_api_bond_enslave_reply_t * mp)
1956 vat_main_t *vam = &vat_main;
1957 vat_json_node_t node;
1959 vat_json_init_object (&node);
1960 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1962 vat_json_print (vam->ofp, &node);
1963 vat_json_free (&node);
1965 vam->retval = ntohl (mp->retval);
1966 vam->result_ready = 1;
1970 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1973 vat_main_t *vam = &vat_main;
1974 i32 retval = ntohl (mp->retval);
1976 if (vam->async_mode)
1978 vam->async_errors += (retval < 0);
1982 vam->retval = retval;
1983 vam->result_ready = 1;
1987 static void vl_api_bond_detach_slave_reply_t_handler_json
1988 (vl_api_bond_detach_slave_reply_t * mp)
1990 vat_main_t *vam = &vat_main;
1991 vat_json_node_t node;
1993 vat_json_init_object (&node);
1994 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1996 vat_json_print (vam->ofp, &node);
1997 vat_json_free (&node);
1999 vam->retval = ntohl (mp->retval);
2000 vam->result_ready = 1;
2004 api_sw_interface_set_bond_weight (vat_main_t * vam)
2006 unformat_input_t *i = vam->input;
2007 vl_api_sw_interface_set_bond_weight_t *mp;
2008 u32 sw_if_index = ~0;
2010 u8 weight_enter = 0;
2013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2015 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2017 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2019 else if (unformat (i, "weight %u", &weight))
2025 if (sw_if_index == ~0)
2027 errmsg ("missing interface name or sw_if_index");
2030 if (weight_enter == 0)
2032 errmsg ("missing valid weight");
2036 /* Construct the API message */
2037 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2038 mp->sw_if_index = ntohl (sw_if_index);
2039 mp->weight = ntohl (weight);
2046 static void vl_api_sw_interface_bond_details_t_handler
2047 (vl_api_sw_interface_bond_details_t * mp)
2049 vat_main_t *vam = &vat_main;
2052 "%-16s %-12d %-12U %-13U %-14u %-14u",
2053 mp->interface_name, ntohl (mp->sw_if_index),
2054 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2055 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2058 static void vl_api_sw_interface_bond_details_t_handler_json
2059 (vl_api_sw_interface_bond_details_t * mp)
2061 vat_main_t *vam = &vat_main;
2062 vat_json_node_t *node = NULL;
2064 if (VAT_JSON_ARRAY != vam->json_tree.type)
2066 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2067 vat_json_init_array (&vam->json_tree);
2069 node = vat_json_array_add (&vam->json_tree);
2071 vat_json_init_object (node);
2072 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2073 vat_json_object_add_string_copy (node, "interface_name",
2074 mp->interface_name);
2075 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2076 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2077 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2078 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2082 api_sw_interface_bond_dump (vat_main_t * vam)
2084 vl_api_sw_interface_bond_dump_t *mp;
2085 vl_api_control_ping_t *mp_ping;
2089 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2090 "interface name", "sw_if_index", "mode", "load balance",
2091 "active slaves", "slaves");
2093 /* Get list of bond interfaces */
2094 M (SW_INTERFACE_BOND_DUMP, mp);
2097 /* Use a control ping for synchronization */
2098 MPING (CONTROL_PING, mp_ping);
2105 static void vl_api_sw_interface_slave_details_t_handler
2106 (vl_api_sw_interface_slave_details_t * mp)
2108 vat_main_t *vam = &vat_main;
2111 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2112 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2113 ntohl (mp->weight), mp->is_local_numa);
2116 static void vl_api_sw_interface_slave_details_t_handler_json
2117 (vl_api_sw_interface_slave_details_t * mp)
2119 vat_main_t *vam = &vat_main;
2120 vat_json_node_t *node = NULL;
2122 if (VAT_JSON_ARRAY != vam->json_tree.type)
2124 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2125 vat_json_init_array (&vam->json_tree);
2127 node = vat_json_array_add (&vam->json_tree);
2129 vat_json_init_object (node);
2130 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2131 vat_json_object_add_string_copy (node, "interface_name",
2132 mp->interface_name);
2133 vat_json_object_add_uint (node, "passive", mp->is_passive);
2134 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2135 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2136 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2140 api_sw_interface_slave_dump (vat_main_t * vam)
2142 unformat_input_t *i = vam->input;
2143 vl_api_sw_interface_slave_dump_t *mp;
2144 vl_api_control_ping_t *mp_ping;
2145 u32 sw_if_index = ~0;
2146 u8 sw_if_index_set = 0;
2149 /* Parse args required to build the message */
2150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2152 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2153 sw_if_index_set = 1;
2154 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2155 sw_if_index_set = 1;
2160 if (sw_if_index_set == 0)
2162 errmsg ("missing vpp interface name. ");
2167 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2168 "slave interface name", "sw_if_index", "passive", "long_timeout",
2169 "weight", "local numa");
2171 /* Get list of bond interfaces */
2172 M (SW_INTERFACE_SLAVE_DUMP, mp);
2173 mp->sw_if_index = ntohl (sw_if_index);
2176 /* Use a control ping for synchronization */
2177 MPING (CONTROL_PING, mp_ping);
2184 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2185 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2187 vat_main_t *vam = &vat_main;
2188 i32 retval = ntohl (mp->retval);
2189 if (vam->async_mode)
2191 vam->async_errors += (retval < 0);
2195 vam->retval = retval;
2196 vam->sw_if_index = ntohl (mp->sw_if_index);
2197 vam->result_ready = 1;
2199 vam->regenerate_interface_table = 1;
2202 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2203 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2205 vat_main_t *vam = &vat_main;
2206 vat_json_node_t node;
2208 vat_json_init_object (&node);
2209 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2210 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2211 ntohl (mp->sw_if_index));
2213 vat_json_print (vam->ofp, &node);
2214 vat_json_free (&node);
2216 vam->retval = ntohl (mp->retval);
2217 vam->result_ready = 1;
2220 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2221 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2223 vat_main_t *vam = &vat_main;
2224 i32 retval = ntohl (mp->retval);
2225 if (vam->async_mode)
2227 vam->async_errors += (retval < 0);
2231 vam->retval = retval;
2232 vam->sw_if_index = ntohl (mp->sw_if_index);
2233 vam->result_ready = 1;
2237 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2238 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2240 vat_main_t *vam = &vat_main;
2241 vat_json_node_t node;
2243 vat_json_init_object (&node);
2244 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2245 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2247 vat_json_print (vam->ofp, &node);
2248 vat_json_free (&node);
2250 vam->retval = ntohl (mp->retval);
2251 vam->result_ready = 1;
2254 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2255 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2257 vat_main_t *vam = &vat_main;
2258 i32 retval = ntohl (mp->retval);
2259 if (vam->async_mode)
2261 vam->async_errors += (retval < 0);
2265 vam->retval = retval;
2266 vam->result_ready = 1;
2270 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2271 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2273 vat_main_t *vam = &vat_main;
2274 vat_json_node_t node;
2276 vat_json_init_object (&node);
2277 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2278 vat_json_object_add_uint (&node, "fwd_entry_index",
2279 clib_net_to_host_u32 (mp->fwd_entry_index));
2281 vat_json_print (vam->ofp, &node);
2282 vat_json_free (&node);
2284 vam->retval = ntohl (mp->retval);
2285 vam->result_ready = 1;
2289 format_lisp_transport_protocol (u8 * s, va_list * args)
2291 u32 proto = va_arg (*args, u32);
2296 return format (s, "udp");
2298 return format (s, "api");
2305 static void vl_api_one_get_transport_protocol_reply_t_handler
2306 (vl_api_one_get_transport_protocol_reply_t * mp)
2308 vat_main_t *vam = &vat_main;
2309 i32 retval = ntohl (mp->retval);
2310 if (vam->async_mode)
2312 vam->async_errors += (retval < 0);
2316 u32 proto = mp->protocol;
2317 print (vam->ofp, "Transport protocol: %U",
2318 format_lisp_transport_protocol, proto);
2319 vam->retval = retval;
2320 vam->result_ready = 1;
2324 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2325 (vl_api_one_get_transport_protocol_reply_t * mp)
2327 vat_main_t *vam = &vat_main;
2328 vat_json_node_t node;
2331 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2334 vat_json_init_object (&node);
2335 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2336 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2339 vat_json_print (vam->ofp, &node);
2340 vat_json_free (&node);
2342 vam->retval = ntohl (mp->retval);
2343 vam->result_ready = 1;
2346 static void vl_api_one_add_del_locator_set_reply_t_handler
2347 (vl_api_one_add_del_locator_set_reply_t * mp)
2349 vat_main_t *vam = &vat_main;
2350 i32 retval = ntohl (mp->retval);
2351 if (vam->async_mode)
2353 vam->async_errors += (retval < 0);
2357 vam->retval = retval;
2358 vam->result_ready = 1;
2362 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2363 (vl_api_one_add_del_locator_set_reply_t * mp)
2365 vat_main_t *vam = &vat_main;
2366 vat_json_node_t node;
2368 vat_json_init_object (&node);
2369 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2370 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2372 vat_json_print (vam->ofp, &node);
2373 vat_json_free (&node);
2375 vam->retval = ntohl (mp->retval);
2376 vam->result_ready = 1;
2379 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2380 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2382 vat_main_t *vam = &vat_main;
2383 i32 retval = ntohl (mp->retval);
2384 if (vam->async_mode)
2386 vam->async_errors += (retval < 0);
2390 vam->retval = retval;
2391 vam->sw_if_index = ntohl (mp->sw_if_index);
2392 vam->result_ready = 1;
2394 vam->regenerate_interface_table = 1;
2397 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2398 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2400 vat_main_t *vam = &vat_main;
2401 vat_json_node_t node;
2403 vat_json_init_object (&node);
2404 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2405 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
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_vxlan_offload_rx_reply_t_handler
2415 (vl_api_vxlan_offload_rx_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->result_ready = 1;
2430 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2431 (vl_api_vxlan_offload_rx_reply_t * mp)
2433 vat_main_t *vam = &vat_main;
2434 vat_json_node_t node;
2436 vat_json_init_object (&node);
2437 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2439 vat_json_print (vam->ofp, &node);
2440 vat_json_free (&node);
2442 vam->retval = ntohl (mp->retval);
2443 vam->result_ready = 1;
2446 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2447 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2449 vat_main_t *vam = &vat_main;
2450 i32 retval = ntohl (mp->retval);
2451 if (vam->async_mode)
2453 vam->async_errors += (retval < 0);
2457 vam->retval = retval;
2458 vam->sw_if_index = ntohl (mp->sw_if_index);
2459 vam->result_ready = 1;
2463 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2464 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2466 vat_main_t *vam = &vat_main;
2467 vat_json_node_t node;
2469 vat_json_init_object (&node);
2470 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2471 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2473 vat_json_print (vam->ofp, &node);
2474 vat_json_free (&node);
2476 vam->retval = ntohl (mp->retval);
2477 vam->result_ready = 1;
2480 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2481 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2483 vat_main_t *vam = &vat_main;
2484 i32 retval = ntohl (mp->retval);
2485 if (vam->async_mode)
2487 vam->async_errors += (retval < 0);
2491 vam->retval = retval;
2492 vam->sw_if_index = ntohl (mp->sw_if_index);
2493 vam->result_ready = 1;
2495 vam->regenerate_interface_table = 1;
2498 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2499 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2501 vat_main_t *vam = &vat_main;
2502 vat_json_node_t node;
2504 vat_json_init_object (&node);
2505 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2506 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2508 vat_json_print (vam->ofp, &node);
2509 vat_json_free (&node);
2511 vam->retval = ntohl (mp->retval);
2512 vam->result_ready = 1;
2515 static void vl_api_gre_tunnel_add_del_reply_t_handler
2516 (vl_api_gre_tunnel_add_del_reply_t * mp)
2518 vat_main_t *vam = &vat_main;
2519 i32 retval = ntohl (mp->retval);
2520 if (vam->async_mode)
2522 vam->async_errors += (retval < 0);
2526 vam->retval = retval;
2527 vam->sw_if_index = ntohl (mp->sw_if_index);
2528 vam->result_ready = 1;
2532 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2533 (vl_api_gre_tunnel_add_del_reply_t * mp)
2535 vat_main_t *vam = &vat_main;
2536 vat_json_node_t node;
2538 vat_json_init_object (&node);
2539 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2540 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2542 vat_json_print (vam->ofp, &node);
2543 vat_json_free (&node);
2545 vam->retval = ntohl (mp->retval);
2546 vam->result_ready = 1;
2549 static void vl_api_create_vhost_user_if_reply_t_handler
2550 (vl_api_create_vhost_user_if_reply_t * mp)
2552 vat_main_t *vam = &vat_main;
2553 i32 retval = ntohl (mp->retval);
2554 if (vam->async_mode)
2556 vam->async_errors += (retval < 0);
2560 vam->retval = retval;
2561 vam->sw_if_index = ntohl (mp->sw_if_index);
2562 vam->result_ready = 1;
2564 vam->regenerate_interface_table = 1;
2567 static void vl_api_create_vhost_user_if_reply_t_handler_json
2568 (vl_api_create_vhost_user_if_reply_t * mp)
2570 vat_main_t *vam = &vat_main;
2571 vat_json_node_t node;
2573 vat_json_init_object (&node);
2574 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2575 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2577 vat_json_print (vam->ofp, &node);
2578 vat_json_free (&node);
2580 vam->retval = ntohl (mp->retval);
2581 vam->result_ready = 1;
2584 static void vl_api_ip_address_details_t_handler
2585 (vl_api_ip_address_details_t * mp)
2587 vat_main_t *vam = &vat_main;
2588 static ip_address_details_t empty_ip_address_details = { {0} };
2589 ip_address_details_t *address = NULL;
2590 ip_details_t *current_ip_details = NULL;
2591 ip_details_t *details = NULL;
2593 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2595 if (!details || vam->current_sw_if_index >= vec_len (details)
2596 || !details[vam->current_sw_if_index].present)
2598 errmsg ("ip address details arrived but not stored");
2599 errmsg ("ip_dump should be called first");
2603 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2605 #define addresses (current_ip_details->addr)
2607 vec_validate_init_empty (addresses, vec_len (addresses),
2608 empty_ip_address_details);
2610 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2612 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2613 address->prefix_length = mp->prefix.len;
2617 static void vl_api_ip_address_details_t_handler_json
2618 (vl_api_ip_address_details_t * mp)
2620 vat_main_t *vam = &vat_main;
2621 vat_json_node_t *node = NULL;
2623 if (VAT_JSON_ARRAY != vam->json_tree.type)
2625 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2626 vat_json_init_array (&vam->json_tree);
2628 node = vat_json_array_add (&vam->json_tree);
2630 vat_json_init_object (node);
2631 vat_json_object_add_prefix (node, &mp->prefix);
2635 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2637 vat_main_t *vam = &vat_main;
2638 static ip_details_t empty_ip_details = { 0 };
2639 ip_details_t *ip = NULL;
2640 u32 sw_if_index = ~0;
2642 sw_if_index = ntohl (mp->sw_if_index);
2644 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2645 sw_if_index, empty_ip_details);
2647 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2654 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2656 vat_main_t *vam = &vat_main;
2658 if (VAT_JSON_ARRAY != vam->json_tree.type)
2660 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2661 vat_json_init_array (&vam->json_tree);
2663 vat_json_array_add_uint (&vam->json_tree,
2664 clib_net_to_host_u32 (mp->sw_if_index));
2667 static void vl_api_get_first_msg_id_reply_t_handler
2668 (vl_api_get_first_msg_id_reply_t * mp)
2670 vat_main_t *vam = &vat_main;
2671 i32 retval = ntohl (mp->retval);
2673 if (vam->async_mode)
2675 vam->async_errors += (retval < 0);
2679 vam->retval = retval;
2680 vam->result_ready = 1;
2684 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2688 static void vl_api_get_first_msg_id_reply_t_handler_json
2689 (vl_api_get_first_msg_id_reply_t * mp)
2691 vat_main_t *vam = &vat_main;
2692 vat_json_node_t node;
2694 vat_json_init_object (&node);
2695 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2696 vat_json_object_add_uint (&node, "first_msg_id",
2697 (uint) ntohs (mp->first_msg_id));
2699 vat_json_print (vam->ofp, &node);
2700 vat_json_free (&node);
2702 vam->retval = ntohl (mp->retval);
2703 vam->result_ready = 1;
2706 static void vl_api_get_node_graph_reply_t_handler
2707 (vl_api_get_node_graph_reply_t * mp)
2709 vat_main_t *vam = &vat_main;
2710 i32 retval = ntohl (mp->retval);
2711 u8 *pvt_copy, *reply;
2716 if (vam->async_mode)
2718 vam->async_errors += (retval < 0);
2722 vam->retval = retval;
2723 vam->result_ready = 1;
2726 /* "Should never happen..." */
2730 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2731 pvt_copy = vec_dup (reply);
2733 /* Toss the shared-memory original... */
2734 oldheap = vl_msg_push_heap ();
2738 vl_msg_pop_heap (oldheap);
2740 if (vam->graph_nodes)
2742 hash_free (vam->graph_node_index_by_name);
2744 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2746 node = vam->graph_nodes[0][i];
2747 vec_free (node->name);
2748 vec_free (node->next_nodes);
2751 vec_free (vam->graph_nodes[0]);
2752 vec_free (vam->graph_nodes);
2755 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2756 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2757 vec_free (pvt_copy);
2759 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2761 node = vam->graph_nodes[0][i];
2762 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2766 static void vl_api_get_node_graph_reply_t_handler_json
2767 (vl_api_get_node_graph_reply_t * mp)
2769 vat_main_t *vam = &vat_main;
2771 vat_json_node_t node;
2774 /* $$$$ make this real? */
2775 vat_json_init_object (&node);
2776 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2777 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2779 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2781 /* Toss the shared-memory original... */
2782 oldheap = vl_msg_push_heap ();
2786 vl_msg_pop_heap (oldheap);
2788 vat_json_print (vam->ofp, &node);
2789 vat_json_free (&node);
2791 vam->retval = ntohl (mp->retval);
2792 vam->result_ready = 1;
2796 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2798 vat_main_t *vam = &vat_main;
2803 s = format (s, "%=16d%=16d%=16d",
2804 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2808 s = format (s, "%=16U%=16d%=16d",
2809 mp->is_ipv6 ? format_ip6_address :
2811 mp->ip_address, mp->priority, mp->weight);
2814 print (vam->ofp, "%v", s);
2819 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2821 vat_main_t *vam = &vat_main;
2822 vat_json_node_t *node = NULL;
2823 struct in6_addr ip6;
2826 if (VAT_JSON_ARRAY != vam->json_tree.type)
2828 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2829 vat_json_init_array (&vam->json_tree);
2831 node = vat_json_array_add (&vam->json_tree);
2832 vat_json_init_object (node);
2834 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2835 vat_json_object_add_uint (node, "priority", mp->priority);
2836 vat_json_object_add_uint (node, "weight", mp->weight);
2839 vat_json_object_add_uint (node, "sw_if_index",
2840 clib_net_to_host_u32 (mp->sw_if_index));
2845 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2846 vat_json_object_add_ip6 (node, "address", ip6);
2850 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2851 vat_json_object_add_ip4 (node, "address", ip4);
2857 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2860 vat_main_t *vam = &vat_main;
2863 ls_name = format (0, "%s", mp->ls_name);
2865 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2871 vl_api_one_locator_set_details_t_handler_json
2872 (vl_api_one_locator_set_details_t * mp)
2874 vat_main_t *vam = &vat_main;
2875 vat_json_node_t *node = 0;
2878 ls_name = format (0, "%s", mp->ls_name);
2879 vec_add1 (ls_name, 0);
2881 if (VAT_JSON_ARRAY != vam->json_tree.type)
2883 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2884 vat_json_init_array (&vam->json_tree);
2886 node = vat_json_array_add (&vam->json_tree);
2888 vat_json_init_object (node);
2889 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2890 vat_json_object_add_uint (node, "ls_index",
2891 clib_net_to_host_u32 (mp->ls_index));
2899 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2902 unformat_nsh_address (unformat_input_t * input, va_list * args)
2904 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2905 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2909 format_nsh_address_vat (u8 * s, va_list * args)
2911 nsh_t *a = va_arg (*args, nsh_t *);
2912 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2916 format_lisp_flat_eid (u8 * s, va_list * args)
2918 u32 type = va_arg (*args, u32);
2919 u8 *eid = va_arg (*args, u8 *);
2920 u32 eid_len = va_arg (*args, u32);
2925 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2927 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2929 return format (s, "%U", format_ethernet_address, eid);
2931 return format (s, "%U", format_nsh_address_vat, eid);
2937 format_lisp_eid_vat (u8 * s, va_list * args)
2939 u32 type = va_arg (*args, u32);
2940 u8 *eid = va_arg (*args, u8 *);
2941 u32 eid_len = va_arg (*args, u32);
2942 u8 *seid = va_arg (*args, u8 *);
2943 u32 seid_len = va_arg (*args, u32);
2944 u32 is_src_dst = va_arg (*args, u32);
2947 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2949 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2955 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2957 vat_main_t *vam = &vat_main;
2958 u8 *s = 0, *eid = 0;
2960 if (~0 == mp->locator_set_index)
2961 s = format (0, "action: %d", mp->action);
2963 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2965 eid = format (0, "%U", format_lisp_eid_vat,
2969 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2972 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2973 clib_net_to_host_u32 (mp->vni),
2975 mp->is_local ? "local" : "remote",
2976 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2977 clib_net_to_host_u16 (mp->key_id), mp->key);
2984 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2987 vat_main_t *vam = &vat_main;
2988 vat_json_node_t *node = 0;
2991 if (VAT_JSON_ARRAY != vam->json_tree.type)
2993 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2994 vat_json_init_array (&vam->json_tree);
2996 node = vat_json_array_add (&vam->json_tree);
2998 vat_json_init_object (node);
2999 if (~0 == mp->locator_set_index)
3000 vat_json_object_add_uint (node, "action", mp->action);
3002 vat_json_object_add_uint (node, "locator_set_index",
3003 clib_net_to_host_u32 (mp->locator_set_index));
3005 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3006 if (mp->eid_type == 3)
3008 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3009 vat_json_init_object (nsh_json);
3010 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3011 vat_json_object_add_uint (nsh_json, "spi",
3012 clib_net_to_host_u32 (nsh->spi));
3013 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3017 eid = format (0, "%U", format_lisp_eid_vat,
3021 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3023 vat_json_object_add_string_copy (node, "eid", eid);
3026 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3027 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3028 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3032 vat_json_object_add_uint (node, "key_id",
3033 clib_net_to_host_u16 (mp->key_id));
3034 vat_json_object_add_string_copy (node, "key", mp->key);
3039 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3041 vat_main_t *vam = &vat_main;
3042 u8 *seid = 0, *deid = 0;
3043 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3045 deid = format (0, "%U", format_lisp_eid_vat,
3046 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3048 seid = format (0, "%U", format_lisp_eid_vat,
3049 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3055 format_ip_address_fcn = format_ip4_address;
3057 format_ip_address_fcn = format_ip6_address;
3060 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3061 clib_net_to_host_u32 (mp->vni),
3063 format_ip_address_fcn, mp->lloc,
3064 format_ip_address_fcn, mp->rloc,
3065 clib_net_to_host_u32 (mp->pkt_count),
3066 clib_net_to_host_u32 (mp->bytes));
3073 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3075 struct in6_addr ip6;
3077 vat_main_t *vam = &vat_main;
3078 vat_json_node_t *node = 0;
3079 u8 *deid = 0, *seid = 0;
3081 if (VAT_JSON_ARRAY != vam->json_tree.type)
3083 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3084 vat_json_init_array (&vam->json_tree);
3086 node = vat_json_array_add (&vam->json_tree);
3088 vat_json_init_object (node);
3089 deid = format (0, "%U", format_lisp_eid_vat,
3090 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3092 seid = format (0, "%U", format_lisp_eid_vat,
3093 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3098 vat_json_object_add_string_copy (node, "seid", seid);
3099 vat_json_object_add_string_copy (node, "deid", deid);
3100 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3104 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3105 vat_json_object_add_ip4 (node, "lloc", ip4);
3106 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3107 vat_json_object_add_ip4 (node, "rloc", ip4);
3111 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3112 vat_json_object_add_ip6 (node, "lloc", ip6);
3113 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3114 vat_json_object_add_ip6 (node, "rloc", ip6);
3116 vat_json_object_add_uint (node, "pkt_count",
3117 clib_net_to_host_u32 (mp->pkt_count));
3118 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3125 vl_api_one_eid_table_map_details_t_handler
3126 (vl_api_one_eid_table_map_details_t * mp)
3128 vat_main_t *vam = &vat_main;
3130 u8 *line = format (0, "%=10d%=10d",
3131 clib_net_to_host_u32 (mp->vni),
3132 clib_net_to_host_u32 (mp->dp_table));
3133 print (vam->ofp, "%v", line);
3138 vl_api_one_eid_table_map_details_t_handler_json
3139 (vl_api_one_eid_table_map_details_t * mp)
3141 vat_main_t *vam = &vat_main;
3142 vat_json_node_t *node = NULL;
3144 if (VAT_JSON_ARRAY != vam->json_tree.type)
3146 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3147 vat_json_init_array (&vam->json_tree);
3149 node = vat_json_array_add (&vam->json_tree);
3150 vat_json_init_object (node);
3151 vat_json_object_add_uint (node, "dp_table",
3152 clib_net_to_host_u32 (mp->dp_table));
3153 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3157 vl_api_one_eid_table_vni_details_t_handler
3158 (vl_api_one_eid_table_vni_details_t * mp)
3160 vat_main_t *vam = &vat_main;
3162 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3163 print (vam->ofp, "%v", line);
3168 vl_api_one_eid_table_vni_details_t_handler_json
3169 (vl_api_one_eid_table_vni_details_t * mp)
3171 vat_main_t *vam = &vat_main;
3172 vat_json_node_t *node = NULL;
3174 if (VAT_JSON_ARRAY != vam->json_tree.type)
3176 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3177 vat_json_init_array (&vam->json_tree);
3179 node = vat_json_array_add (&vam->json_tree);
3180 vat_json_init_object (node);
3181 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3185 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3186 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3188 vat_main_t *vam = &vat_main;
3189 int retval = clib_net_to_host_u32 (mp->retval);
3191 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3192 print (vam->ofp, "fallback threshold value: %d", mp->value);
3194 vam->retval = retval;
3195 vam->result_ready = 1;
3199 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3200 (vl_api_show_one_map_register_fallback_threshold_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 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3207 vat_json_init_object (node);
3208 vat_json_object_add_uint (node, "value", mp->value);
3210 vat_json_print (vam->ofp, node);
3211 vat_json_free (node);
3213 vam->retval = retval;
3214 vam->result_ready = 1;
3218 vl_api_show_one_map_register_state_reply_t_handler
3219 (vl_api_show_one_map_register_state_reply_t * mp)
3221 vat_main_t *vam = &vat_main;
3222 int retval = clib_net_to_host_u32 (mp->retval);
3224 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3226 vam->retval = retval;
3227 vam->result_ready = 1;
3231 vl_api_show_one_map_register_state_reply_t_handler_json
3232 (vl_api_show_one_map_register_state_reply_t * mp)
3234 vat_main_t *vam = &vat_main;
3235 vat_json_node_t _node, *node = &_node;
3236 int retval = clib_net_to_host_u32 (mp->retval);
3238 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3240 vat_json_init_object (node);
3241 vat_json_object_add_string_copy (node, "state", s);
3243 vat_json_print (vam->ofp, node);
3244 vat_json_free (node);
3246 vam->retval = retval;
3247 vam->result_ready = 1;
3252 vl_api_show_one_rloc_probe_state_reply_t_handler
3253 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3255 vat_main_t *vam = &vat_main;
3256 int retval = clib_net_to_host_u32 (mp->retval);
3261 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3263 vam->retval = retval;
3264 vam->result_ready = 1;
3268 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3269 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3271 vat_main_t *vam = &vat_main;
3272 vat_json_node_t _node, *node = &_node;
3273 int retval = clib_net_to_host_u32 (mp->retval);
3275 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3276 vat_json_init_object (node);
3277 vat_json_object_add_string_copy (node, "state", s);
3279 vat_json_print (vam->ofp, node);
3280 vat_json_free (node);
3282 vam->retval = retval;
3283 vam->result_ready = 1;
3288 vl_api_show_one_stats_enable_disable_reply_t_handler
3289 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3291 vat_main_t *vam = &vat_main;
3292 int retval = clib_net_to_host_u32 (mp->retval);
3297 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3299 vam->retval = retval;
3300 vam->result_ready = 1;
3304 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3305 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3307 vat_main_t *vam = &vat_main;
3308 vat_json_node_t _node, *node = &_node;
3309 int retval = clib_net_to_host_u32 (mp->retval);
3311 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3312 vat_json_init_object (node);
3313 vat_json_object_add_string_copy (node, "state", s);
3315 vat_json_print (vam->ofp, node);
3316 vat_json_free (node);
3318 vam->retval = retval;
3319 vam->result_ready = 1;
3324 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3326 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3327 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3328 e->vni = clib_net_to_host_u32 (e->vni);
3332 gpe_fwd_entries_get_reply_t_net_to_host
3333 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3337 mp->count = clib_net_to_host_u32 (mp->count);
3338 for (i = 0; i < mp->count; i++)
3340 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3345 format_gpe_encap_mode (u8 * s, va_list * args)
3347 u32 mode = va_arg (*args, u32);
3352 return format (s, "lisp");
3354 return format (s, "vxlan");
3360 vl_api_gpe_get_encap_mode_reply_t_handler
3361 (vl_api_gpe_get_encap_mode_reply_t * mp)
3363 vat_main_t *vam = &vat_main;
3365 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3366 vam->retval = ntohl (mp->retval);
3367 vam->result_ready = 1;
3371 vl_api_gpe_get_encap_mode_reply_t_handler_json
3372 (vl_api_gpe_get_encap_mode_reply_t * mp)
3374 vat_main_t *vam = &vat_main;
3375 vat_json_node_t node;
3377 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3378 vec_add1 (encap_mode, 0);
3380 vat_json_init_object (&node);
3381 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3383 vec_free (encap_mode);
3384 vat_json_print (vam->ofp, &node);
3385 vat_json_free (&node);
3387 vam->retval = ntohl (mp->retval);
3388 vam->result_ready = 1;
3392 vl_api_gpe_fwd_entry_path_details_t_handler
3393 (vl_api_gpe_fwd_entry_path_details_t * mp)
3395 vat_main_t *vam = &vat_main;
3396 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3398 if (mp->lcl_loc.is_ip4)
3399 format_ip_address_fcn = format_ip4_address;
3401 format_ip_address_fcn = format_ip6_address;
3403 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3404 format_ip_address_fcn, &mp->lcl_loc,
3405 format_ip_address_fcn, &mp->rmt_loc);
3409 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3411 struct in6_addr ip6;
3416 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3417 vat_json_object_add_ip4 (n, "address", ip4);
3421 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3422 vat_json_object_add_ip6 (n, "address", ip6);
3424 vat_json_object_add_uint (n, "weight", loc->weight);
3428 vl_api_gpe_fwd_entry_path_details_t_handler_json
3429 (vl_api_gpe_fwd_entry_path_details_t * mp)
3431 vat_main_t *vam = &vat_main;
3432 vat_json_node_t *node = NULL;
3433 vat_json_node_t *loc_node;
3435 if (VAT_JSON_ARRAY != vam->json_tree.type)
3437 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3438 vat_json_init_array (&vam->json_tree);
3440 node = vat_json_array_add (&vam->json_tree);
3441 vat_json_init_object (node);
3443 loc_node = vat_json_object_add (node, "local_locator");
3444 vat_json_init_object (loc_node);
3445 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3447 loc_node = vat_json_object_add (node, "remote_locator");
3448 vat_json_init_object (loc_node);
3449 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3453 vl_api_gpe_fwd_entries_get_reply_t_handler
3454 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3456 vat_main_t *vam = &vat_main;
3458 int retval = clib_net_to_host_u32 (mp->retval);
3459 vl_api_gpe_fwd_entry_t *e;
3464 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3466 for (i = 0; i < mp->count; i++)
3468 e = &mp->entries[i];
3469 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3470 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3471 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3475 vam->retval = retval;
3476 vam->result_ready = 1;
3480 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3481 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3484 vat_main_t *vam = &vat_main;
3485 vat_json_node_t *e = 0, root;
3487 int retval = clib_net_to_host_u32 (mp->retval);
3488 vl_api_gpe_fwd_entry_t *fwd;
3493 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3494 vat_json_init_array (&root);
3496 for (i = 0; i < mp->count; i++)
3498 e = vat_json_array_add (&root);
3499 fwd = &mp->entries[i];
3501 vat_json_init_object (e);
3502 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3503 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3504 vat_json_object_add_int (e, "vni", fwd->vni);
3505 vat_json_object_add_int (e, "action", fwd->action);
3507 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3508 fwd->leid_prefix_len);
3510 vat_json_object_add_string_copy (e, "leid", s);
3513 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3514 fwd->reid_prefix_len);
3516 vat_json_object_add_string_copy (e, "reid", s);
3520 vat_json_print (vam->ofp, &root);
3521 vat_json_free (&root);
3524 vam->retval = retval;
3525 vam->result_ready = 1;
3529 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3530 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3532 vat_main_t *vam = &vat_main;
3534 int retval = clib_net_to_host_u32 (mp->retval);
3535 vl_api_gpe_native_fwd_rpath_t *r;
3540 n = clib_net_to_host_u32 (mp->count);
3542 for (i = 0; i < n; i++)
3544 r = &mp->entries[i];
3545 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3546 clib_net_to_host_u32 (r->fib_index),
3547 clib_net_to_host_u32 (r->nh_sw_if_index),
3548 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3552 vam->retval = retval;
3553 vam->result_ready = 1;
3557 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3558 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3560 vat_main_t *vam = &vat_main;
3561 vat_json_node_t root, *e;
3563 int retval = clib_net_to_host_u32 (mp->retval);
3564 vl_api_gpe_native_fwd_rpath_t *r;
3570 n = clib_net_to_host_u32 (mp->count);
3571 vat_json_init_array (&root);
3573 for (i = 0; i < n; i++)
3575 e = vat_json_array_add (&root);
3576 vat_json_init_object (e);
3577 r = &mp->entries[i];
3579 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3582 vat_json_object_add_string_copy (e, "ip4", s);
3585 vat_json_object_add_uint (e, "fib_index",
3586 clib_net_to_host_u32 (r->fib_index));
3587 vat_json_object_add_uint (e, "nh_sw_if_index",
3588 clib_net_to_host_u32 (r->nh_sw_if_index));
3591 vat_json_print (vam->ofp, &root);
3592 vat_json_free (&root);
3595 vam->retval = retval;
3596 vam->result_ready = 1;
3600 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3601 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3603 vat_main_t *vam = &vat_main;
3605 int retval = clib_net_to_host_u32 (mp->retval);
3610 n = clib_net_to_host_u32 (mp->count);
3612 for (i = 0; i < n; i++)
3613 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3616 vam->retval = retval;
3617 vam->result_ready = 1;
3621 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3622 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3624 vat_main_t *vam = &vat_main;
3625 vat_json_node_t root;
3627 int retval = clib_net_to_host_u32 (mp->retval);
3632 n = clib_net_to_host_u32 (mp->count);
3633 vat_json_init_array (&root);
3635 for (i = 0; i < n; i++)
3636 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3638 vat_json_print (vam->ofp, &root);
3639 vat_json_free (&root);
3642 vam->retval = retval;
3643 vam->result_ready = 1;
3647 vl_api_one_ndp_entries_get_reply_t_handler
3648 (vl_api_one_ndp_entries_get_reply_t * mp)
3650 vat_main_t *vam = &vat_main;
3652 int retval = clib_net_to_host_u32 (mp->retval);
3657 n = clib_net_to_host_u32 (mp->count);
3659 for (i = 0; i < n; i++)
3660 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3661 format_ethernet_address, mp->entries[i].mac);
3664 vam->retval = retval;
3665 vam->result_ready = 1;
3669 vl_api_one_ndp_entries_get_reply_t_handler_json
3670 (vl_api_one_ndp_entries_get_reply_t * mp)
3673 vat_main_t *vam = &vat_main;
3674 vat_json_node_t *e = 0, root;
3676 int retval = clib_net_to_host_u32 (mp->retval);
3677 vl_api_one_ndp_entry_t *arp_entry;
3682 n = clib_net_to_host_u32 (mp->count);
3683 vat_json_init_array (&root);
3685 for (i = 0; i < n; i++)
3687 e = vat_json_array_add (&root);
3688 arp_entry = &mp->entries[i];
3690 vat_json_init_object (e);
3691 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3694 vat_json_object_add_string_copy (e, "mac", s);
3697 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3699 vat_json_object_add_string_copy (e, "ip6", s);
3703 vat_json_print (vam->ofp, &root);
3704 vat_json_free (&root);
3707 vam->retval = retval;
3708 vam->result_ready = 1;
3712 vl_api_one_l2_arp_entries_get_reply_t_handler
3713 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3715 vat_main_t *vam = &vat_main;
3717 int retval = clib_net_to_host_u32 (mp->retval);
3722 n = clib_net_to_host_u32 (mp->count);
3724 for (i = 0; i < n; i++)
3725 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3726 format_ethernet_address, mp->entries[i].mac);
3729 vam->retval = retval;
3730 vam->result_ready = 1;
3734 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3735 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3738 vat_main_t *vam = &vat_main;
3739 vat_json_node_t *e = 0, root;
3741 int retval = clib_net_to_host_u32 (mp->retval);
3742 vl_api_one_l2_arp_entry_t *arp_entry;
3747 n = clib_net_to_host_u32 (mp->count);
3748 vat_json_init_array (&root);
3750 for (i = 0; i < n; i++)
3752 e = vat_json_array_add (&root);
3753 arp_entry = &mp->entries[i];
3755 vat_json_init_object (e);
3756 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3759 vat_json_object_add_string_copy (e, "mac", s);
3762 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3764 vat_json_object_add_string_copy (e, "ip4", s);
3768 vat_json_print (vam->ofp, &root);
3769 vat_json_free (&root);
3772 vam->retval = retval;
3773 vam->result_ready = 1;
3777 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3779 vat_main_t *vam = &vat_main;
3781 int retval = clib_net_to_host_u32 (mp->retval);
3786 n = clib_net_to_host_u32 (mp->count);
3788 for (i = 0; i < n; i++)
3790 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3794 vam->retval = retval;
3795 vam->result_ready = 1;
3799 vl_api_one_ndp_bd_get_reply_t_handler_json
3800 (vl_api_one_ndp_bd_get_reply_t * mp)
3802 vat_main_t *vam = &vat_main;
3803 vat_json_node_t root;
3805 int retval = clib_net_to_host_u32 (mp->retval);
3810 n = clib_net_to_host_u32 (mp->count);
3811 vat_json_init_array (&root);
3813 for (i = 0; i < n; i++)
3815 vat_json_array_add_uint (&root,
3816 clib_net_to_host_u32 (mp->bridge_domains[i]));
3819 vat_json_print (vam->ofp, &root);
3820 vat_json_free (&root);
3823 vam->retval = retval;
3824 vam->result_ready = 1;
3828 vl_api_one_l2_arp_bd_get_reply_t_handler
3829 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3831 vat_main_t *vam = &vat_main;
3833 int retval = clib_net_to_host_u32 (mp->retval);
3838 n = clib_net_to_host_u32 (mp->count);
3840 for (i = 0; i < n; i++)
3842 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3846 vam->retval = retval;
3847 vam->result_ready = 1;
3851 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3852 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3854 vat_main_t *vam = &vat_main;
3855 vat_json_node_t root;
3857 int retval = clib_net_to_host_u32 (mp->retval);
3862 n = clib_net_to_host_u32 (mp->count);
3863 vat_json_init_array (&root);
3865 for (i = 0; i < n; i++)
3867 vat_json_array_add_uint (&root,
3868 clib_net_to_host_u32 (mp->bridge_domains[i]));
3871 vat_json_print (vam->ofp, &root);
3872 vat_json_free (&root);
3875 vam->retval = retval;
3876 vam->result_ready = 1;
3880 vl_api_one_adjacencies_get_reply_t_handler
3881 (vl_api_one_adjacencies_get_reply_t * mp)
3883 vat_main_t *vam = &vat_main;
3885 int retval = clib_net_to_host_u32 (mp->retval);
3886 vl_api_one_adjacency_t *a;
3891 n = clib_net_to_host_u32 (mp->count);
3893 for (i = 0; i < n; i++)
3895 a = &mp->adjacencies[i];
3896 print (vam->ofp, "%U %40U",
3897 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3898 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3902 vam->retval = retval;
3903 vam->result_ready = 1;
3907 vl_api_one_adjacencies_get_reply_t_handler_json
3908 (vl_api_one_adjacencies_get_reply_t * mp)
3911 vat_main_t *vam = &vat_main;
3912 vat_json_node_t *e = 0, root;
3914 int retval = clib_net_to_host_u32 (mp->retval);
3915 vl_api_one_adjacency_t *a;
3920 n = clib_net_to_host_u32 (mp->count);
3921 vat_json_init_array (&root);
3923 for (i = 0; i < n; i++)
3925 e = vat_json_array_add (&root);
3926 a = &mp->adjacencies[i];
3928 vat_json_init_object (e);
3929 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3930 a->leid_prefix_len);
3932 vat_json_object_add_string_copy (e, "leid", s);
3935 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3936 a->reid_prefix_len);
3938 vat_json_object_add_string_copy (e, "reid", s);
3942 vat_json_print (vam->ofp, &root);
3943 vat_json_free (&root);
3946 vam->retval = retval;
3947 vam->result_ready = 1;
3951 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3953 vat_main_t *vam = &vat_main;
3955 print (vam->ofp, "%=20U",
3956 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3961 vl_api_one_map_server_details_t_handler_json
3962 (vl_api_one_map_server_details_t * mp)
3964 vat_main_t *vam = &vat_main;
3965 vat_json_node_t *node = NULL;
3966 struct in6_addr ip6;
3969 if (VAT_JSON_ARRAY != vam->json_tree.type)
3971 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3972 vat_json_init_array (&vam->json_tree);
3974 node = vat_json_array_add (&vam->json_tree);
3976 vat_json_init_object (node);
3979 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3980 vat_json_object_add_ip6 (node, "map-server", ip6);
3984 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3985 vat_json_object_add_ip4 (node, "map-server", ip4);
3990 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3993 vat_main_t *vam = &vat_main;
3995 print (vam->ofp, "%=20U",
3996 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4001 vl_api_one_map_resolver_details_t_handler_json
4002 (vl_api_one_map_resolver_details_t * mp)
4004 vat_main_t *vam = &vat_main;
4005 vat_json_node_t *node = NULL;
4006 struct in6_addr ip6;
4009 if (VAT_JSON_ARRAY != vam->json_tree.type)
4011 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4012 vat_json_init_array (&vam->json_tree);
4014 node = vat_json_array_add (&vam->json_tree);
4016 vat_json_init_object (node);
4019 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4020 vat_json_object_add_ip6 (node, "map resolver", ip6);
4024 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4025 vat_json_object_add_ip4 (node, "map resolver", ip4);
4030 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4032 vat_main_t *vam = &vat_main;
4033 i32 retval = ntohl (mp->retval);
4037 print (vam->ofp, "feature: %s\ngpe: %s",
4038 mp->feature_status ? "enabled" : "disabled",
4039 mp->gpe_status ? "enabled" : "disabled");
4042 vam->retval = retval;
4043 vam->result_ready = 1;
4047 vl_api_show_one_status_reply_t_handler_json
4048 (vl_api_show_one_status_reply_t * mp)
4050 vat_main_t *vam = &vat_main;
4051 vat_json_node_t node;
4052 u8 *gpe_status = NULL;
4053 u8 *feature_status = NULL;
4055 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4056 feature_status = format (0, "%s",
4057 mp->feature_status ? "enabled" : "disabled");
4058 vec_add1 (gpe_status, 0);
4059 vec_add1 (feature_status, 0);
4061 vat_json_init_object (&node);
4062 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4063 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4065 vec_free (gpe_status);
4066 vec_free (feature_status);
4068 vat_json_print (vam->ofp, &node);
4069 vat_json_free (&node);
4071 vam->retval = ntohl (mp->retval);
4072 vam->result_ready = 1;
4076 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4077 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4079 vat_main_t *vam = &vat_main;
4080 i32 retval = ntohl (mp->retval);
4084 print (vam->ofp, "%=20s", mp->locator_set_name);
4087 vam->retval = retval;
4088 vam->result_ready = 1;
4092 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4093 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4095 vat_main_t *vam = &vat_main;
4096 vat_json_node_t *node = NULL;
4098 if (VAT_JSON_ARRAY != vam->json_tree.type)
4100 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4101 vat_json_init_array (&vam->json_tree);
4103 node = vat_json_array_add (&vam->json_tree);
4105 vat_json_init_object (node);
4106 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4108 vat_json_print (vam->ofp, node);
4109 vat_json_free (node);
4111 vam->retval = ntohl (mp->retval);
4112 vam->result_ready = 1;
4116 format_lisp_map_request_mode (u8 * s, va_list * args)
4118 u32 mode = va_arg (*args, u32);
4123 return format (0, "dst-only");
4125 return format (0, "src-dst");
4131 vl_api_show_one_map_request_mode_reply_t_handler
4132 (vl_api_show_one_map_request_mode_reply_t * mp)
4134 vat_main_t *vam = &vat_main;
4135 i32 retval = ntohl (mp->retval);
4139 u32 mode = mp->mode;
4140 print (vam->ofp, "map_request_mode: %U",
4141 format_lisp_map_request_mode, mode);
4144 vam->retval = retval;
4145 vam->result_ready = 1;
4149 vl_api_show_one_map_request_mode_reply_t_handler_json
4150 (vl_api_show_one_map_request_mode_reply_t * mp)
4152 vat_main_t *vam = &vat_main;
4153 vat_json_node_t node;
4158 s = format (0, "%U", format_lisp_map_request_mode, mode);
4161 vat_json_init_object (&node);
4162 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4163 vat_json_print (vam->ofp, &node);
4164 vat_json_free (&node);
4167 vam->retval = ntohl (mp->retval);
4168 vam->result_ready = 1;
4172 vl_api_one_show_xtr_mode_reply_t_handler
4173 (vl_api_one_show_xtr_mode_reply_t * mp)
4175 vat_main_t *vam = &vat_main;
4176 i32 retval = ntohl (mp->retval);
4180 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4183 vam->retval = retval;
4184 vam->result_ready = 1;
4188 vl_api_one_show_xtr_mode_reply_t_handler_json
4189 (vl_api_one_show_xtr_mode_reply_t * mp)
4191 vat_main_t *vam = &vat_main;
4192 vat_json_node_t node;
4195 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4196 vec_add1 (status, 0);
4198 vat_json_init_object (&node);
4199 vat_json_object_add_string_copy (&node, "status", status);
4203 vat_json_print (vam->ofp, &node);
4204 vat_json_free (&node);
4206 vam->retval = ntohl (mp->retval);
4207 vam->result_ready = 1;
4211 vl_api_one_show_pitr_mode_reply_t_handler
4212 (vl_api_one_show_pitr_mode_reply_t * mp)
4214 vat_main_t *vam = &vat_main;
4215 i32 retval = ntohl (mp->retval);
4219 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4222 vam->retval = retval;
4223 vam->result_ready = 1;
4227 vl_api_one_show_pitr_mode_reply_t_handler_json
4228 (vl_api_one_show_pitr_mode_reply_t * mp)
4230 vat_main_t *vam = &vat_main;
4231 vat_json_node_t node;
4234 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4235 vec_add1 (status, 0);
4237 vat_json_init_object (&node);
4238 vat_json_object_add_string_copy (&node, "status", status);
4242 vat_json_print (vam->ofp, &node);
4243 vat_json_free (&node);
4245 vam->retval = ntohl (mp->retval);
4246 vam->result_ready = 1;
4250 vl_api_one_show_petr_mode_reply_t_handler
4251 (vl_api_one_show_petr_mode_reply_t * mp)
4253 vat_main_t *vam = &vat_main;
4254 i32 retval = ntohl (mp->retval);
4258 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4261 vam->retval = retval;
4262 vam->result_ready = 1;
4266 vl_api_one_show_petr_mode_reply_t_handler_json
4267 (vl_api_one_show_petr_mode_reply_t * mp)
4269 vat_main_t *vam = &vat_main;
4270 vat_json_node_t node;
4273 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4274 vec_add1 (status, 0);
4276 vat_json_init_object (&node);
4277 vat_json_object_add_string_copy (&node, "status", status);
4281 vat_json_print (vam->ofp, &node);
4282 vat_json_free (&node);
4284 vam->retval = ntohl (mp->retval);
4285 vam->result_ready = 1;
4289 vl_api_show_one_use_petr_reply_t_handler
4290 (vl_api_show_one_use_petr_reply_t * mp)
4292 vat_main_t *vam = &vat_main;
4293 i32 retval = ntohl (mp->retval);
4297 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4300 print (vam->ofp, "Proxy-ETR address; %U",
4301 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4306 vam->retval = retval;
4307 vam->result_ready = 1;
4311 vl_api_show_one_use_petr_reply_t_handler_json
4312 (vl_api_show_one_use_petr_reply_t * mp)
4314 vat_main_t *vam = &vat_main;
4315 vat_json_node_t node;
4318 struct in6_addr ip6;
4320 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4321 vec_add1 (status, 0);
4323 vat_json_init_object (&node);
4324 vat_json_object_add_string_copy (&node, "status", status);
4329 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4330 vat_json_object_add_ip6 (&node, "address", ip6);
4334 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4335 vat_json_object_add_ip4 (&node, "address", ip4);
4341 vat_json_print (vam->ofp, &node);
4342 vat_json_free (&node);
4344 vam->retval = ntohl (mp->retval);
4345 vam->result_ready = 1;
4349 vl_api_show_one_nsh_mapping_reply_t_handler
4350 (vl_api_show_one_nsh_mapping_reply_t * mp)
4352 vat_main_t *vam = &vat_main;
4353 i32 retval = ntohl (mp->retval);
4357 print (vam->ofp, "%-20s%-16s",
4358 mp->is_set ? "set" : "not-set",
4359 mp->is_set ? (char *) mp->locator_set_name : "");
4362 vam->retval = retval;
4363 vam->result_ready = 1;
4367 vl_api_show_one_nsh_mapping_reply_t_handler_json
4368 (vl_api_show_one_nsh_mapping_reply_t * mp)
4370 vat_main_t *vam = &vat_main;
4371 vat_json_node_t node;
4374 status = format (0, "%s", mp->is_set ? "yes" : "no");
4375 vec_add1 (status, 0);
4377 vat_json_init_object (&node);
4378 vat_json_object_add_string_copy (&node, "is_set", status);
4381 vat_json_object_add_string_copy (&node, "locator_set",
4382 mp->locator_set_name);
4387 vat_json_print (vam->ofp, &node);
4388 vat_json_free (&node);
4390 vam->retval = ntohl (mp->retval);
4391 vam->result_ready = 1;
4395 vl_api_show_one_map_register_ttl_reply_t_handler
4396 (vl_api_show_one_map_register_ttl_reply_t * mp)
4398 vat_main_t *vam = &vat_main;
4399 i32 retval = ntohl (mp->retval);
4401 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4405 print (vam->ofp, "ttl: %u", mp->ttl);
4408 vam->retval = retval;
4409 vam->result_ready = 1;
4413 vl_api_show_one_map_register_ttl_reply_t_handler_json
4414 (vl_api_show_one_map_register_ttl_reply_t * mp)
4416 vat_main_t *vam = &vat_main;
4417 vat_json_node_t node;
4419 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4420 vat_json_init_object (&node);
4421 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4423 vat_json_print (vam->ofp, &node);
4424 vat_json_free (&node);
4426 vam->retval = ntohl (mp->retval);
4427 vam->result_ready = 1;
4431 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4433 vat_main_t *vam = &vat_main;
4434 i32 retval = ntohl (mp->retval);
4438 print (vam->ofp, "%-20s%-16s",
4439 mp->status ? "enabled" : "disabled",
4440 mp->status ? (char *) mp->locator_set_name : "");
4443 vam->retval = retval;
4444 vam->result_ready = 1;
4448 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4450 vat_main_t *vam = &vat_main;
4451 vat_json_node_t node;
4454 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4455 vec_add1 (status, 0);
4457 vat_json_init_object (&node);
4458 vat_json_object_add_string_copy (&node, "status", status);
4461 vat_json_object_add_string_copy (&node, "locator_set",
4462 mp->locator_set_name);
4467 vat_json_print (vam->ofp, &node);
4468 vat_json_free (&node);
4470 vam->retval = ntohl (mp->retval);
4471 vam->result_ready = 1;
4475 format_policer_type (u8 * s, va_list * va)
4477 u32 i = va_arg (*va, u32);
4479 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4480 s = format (s, "1r2c");
4481 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4482 s = format (s, "1r3c");
4483 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4484 s = format (s, "2r3c-2698");
4485 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4486 s = format (s, "2r3c-4115");
4487 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4488 s = format (s, "2r3c-mef5cf1");
4490 s = format (s, "ILLEGAL");
4495 format_policer_rate_type (u8 * s, va_list * va)
4497 u32 i = va_arg (*va, u32);
4499 if (i == SSE2_QOS_RATE_KBPS)
4500 s = format (s, "kbps");
4501 else if (i == SSE2_QOS_RATE_PPS)
4502 s = format (s, "pps");
4504 s = format (s, "ILLEGAL");
4509 format_policer_round_type (u8 * s, va_list * va)
4511 u32 i = va_arg (*va, u32);
4513 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4514 s = format (s, "closest");
4515 else if (i == SSE2_QOS_ROUND_TO_UP)
4516 s = format (s, "up");
4517 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4518 s = format (s, "down");
4520 s = format (s, "ILLEGAL");
4525 format_policer_action_type (u8 * s, va_list * va)
4527 u32 i = va_arg (*va, u32);
4529 if (i == SSE2_QOS_ACTION_DROP)
4530 s = format (s, "drop");
4531 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4532 s = format (s, "transmit");
4533 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4534 s = format (s, "mark-and-transmit");
4536 s = format (s, "ILLEGAL");
4541 format_dscp (u8 * s, va_list * va)
4543 u32 i = va_arg (*va, u32);
4548 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4552 return format (s, "ILLEGAL");
4554 s = format (s, "%s", t);
4559 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4561 vat_main_t *vam = &vat_main;
4562 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4564 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4565 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4567 conform_dscp_str = format (0, "");
4569 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4570 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4572 exceed_dscp_str = format (0, "");
4574 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4575 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4577 violate_dscp_str = format (0, "");
4579 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4580 "rate type %U, round type %U, %s rate, %s color-aware, "
4581 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4582 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4583 "conform action %U%s, exceed action %U%s, violate action %U%s",
4585 format_policer_type, mp->type,
4588 clib_net_to_host_u64 (mp->cb),
4589 clib_net_to_host_u64 (mp->eb),
4590 format_policer_rate_type, mp->rate_type,
4591 format_policer_round_type, mp->round_type,
4592 mp->single_rate ? "single" : "dual",
4593 mp->color_aware ? "is" : "not",
4594 ntohl (mp->cir_tokens_per_period),
4595 ntohl (mp->pir_tokens_per_period),
4597 ntohl (mp->current_limit),
4598 ntohl (mp->current_bucket),
4599 ntohl (mp->extended_limit),
4600 ntohl (mp->extended_bucket),
4601 clib_net_to_host_u64 (mp->last_update_time),
4602 format_policer_action_type, mp->conform_action_type,
4604 format_policer_action_type, mp->exceed_action_type,
4606 format_policer_action_type, mp->violate_action_type,
4609 vec_free (conform_dscp_str);
4610 vec_free (exceed_dscp_str);
4611 vec_free (violate_dscp_str);
4614 static void vl_api_policer_details_t_handler_json
4615 (vl_api_policer_details_t * mp)
4617 vat_main_t *vam = &vat_main;
4618 vat_json_node_t *node;
4619 u8 *rate_type_str, *round_type_str, *type_str;
4620 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4622 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4624 format (0, "%U", format_policer_round_type, mp->round_type);
4625 type_str = format (0, "%U", format_policer_type, mp->type);
4626 conform_action_str = format (0, "%U", format_policer_action_type,
4627 mp->conform_action_type);
4628 exceed_action_str = format (0, "%U", format_policer_action_type,
4629 mp->exceed_action_type);
4630 violate_action_str = format (0, "%U", format_policer_action_type,
4631 mp->violate_action_type);
4633 if (VAT_JSON_ARRAY != vam->json_tree.type)
4635 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4636 vat_json_init_array (&vam->json_tree);
4638 node = vat_json_array_add (&vam->json_tree);
4640 vat_json_init_object (node);
4641 vat_json_object_add_string_copy (node, "name", mp->name);
4642 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4643 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4644 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4645 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4646 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4647 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4648 vat_json_object_add_string_copy (node, "type", type_str);
4649 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4650 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4651 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4652 vat_json_object_add_uint (node, "cir_tokens_per_period",
4653 ntohl (mp->cir_tokens_per_period));
4654 vat_json_object_add_uint (node, "eir_tokens_per_period",
4655 ntohl (mp->pir_tokens_per_period));
4656 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4657 vat_json_object_add_uint (node, "current_bucket",
4658 ntohl (mp->current_bucket));
4659 vat_json_object_add_uint (node, "extended_limit",
4660 ntohl (mp->extended_limit));
4661 vat_json_object_add_uint (node, "extended_bucket",
4662 ntohl (mp->extended_bucket));
4663 vat_json_object_add_uint (node, "last_update_time",
4664 ntohl (mp->last_update_time));
4665 vat_json_object_add_string_copy (node, "conform_action",
4666 conform_action_str);
4667 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4669 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4670 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4671 vec_free (dscp_str);
4673 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4674 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4676 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4677 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4678 vec_free (dscp_str);
4680 vat_json_object_add_string_copy (node, "violate_action",
4681 violate_action_str);
4682 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4684 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4685 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4686 vec_free (dscp_str);
4689 vec_free (rate_type_str);
4690 vec_free (round_type_str);
4691 vec_free (type_str);
4692 vec_free (conform_action_str);
4693 vec_free (exceed_action_str);
4694 vec_free (violate_action_str);
4698 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4701 vat_main_t *vam = &vat_main;
4702 int i, count = ntohl (mp->count);
4705 print (vam->ofp, "classify table ids (%d) : ", count);
4706 for (i = 0; i < count; i++)
4708 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4709 print (vam->ofp, (i < count - 1) ? "," : "");
4711 vam->retval = ntohl (mp->retval);
4712 vam->result_ready = 1;
4716 vl_api_classify_table_ids_reply_t_handler_json
4717 (vl_api_classify_table_ids_reply_t * mp)
4719 vat_main_t *vam = &vat_main;
4720 int i, count = ntohl (mp->count);
4724 vat_json_node_t node;
4726 vat_json_init_object (&node);
4727 for (i = 0; i < count; i++)
4729 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4731 vat_json_print (vam->ofp, &node);
4732 vat_json_free (&node);
4734 vam->retval = ntohl (mp->retval);
4735 vam->result_ready = 1;
4739 vl_api_classify_table_by_interface_reply_t_handler
4740 (vl_api_classify_table_by_interface_reply_t * mp)
4742 vat_main_t *vam = &vat_main;
4745 table_id = ntohl (mp->l2_table_id);
4747 print (vam->ofp, "l2 table id : %d", table_id);
4749 print (vam->ofp, "l2 table id : No input ACL tables configured");
4750 table_id = ntohl (mp->ip4_table_id);
4752 print (vam->ofp, "ip4 table id : %d", table_id);
4754 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4755 table_id = ntohl (mp->ip6_table_id);
4757 print (vam->ofp, "ip6 table id : %d", table_id);
4759 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4760 vam->retval = ntohl (mp->retval);
4761 vam->result_ready = 1;
4765 vl_api_classify_table_by_interface_reply_t_handler_json
4766 (vl_api_classify_table_by_interface_reply_t * mp)
4768 vat_main_t *vam = &vat_main;
4769 vat_json_node_t node;
4771 vat_json_init_object (&node);
4773 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4774 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4775 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4777 vat_json_print (vam->ofp, &node);
4778 vat_json_free (&node);
4780 vam->retval = ntohl (mp->retval);
4781 vam->result_ready = 1;
4784 static void vl_api_policer_add_del_reply_t_handler
4785 (vl_api_policer_add_del_reply_t * mp)
4787 vat_main_t *vam = &vat_main;
4788 i32 retval = ntohl (mp->retval);
4789 if (vam->async_mode)
4791 vam->async_errors += (retval < 0);
4795 vam->retval = retval;
4796 vam->result_ready = 1;
4797 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4799 * Note: this is just barely thread-safe, depends on
4800 * the main thread spinning waiting for an answer...
4802 errmsg ("policer index %d", ntohl (mp->policer_index));
4806 static void vl_api_policer_add_del_reply_t_handler_json
4807 (vl_api_policer_add_del_reply_t * mp)
4809 vat_main_t *vam = &vat_main;
4810 vat_json_node_t node;
4812 vat_json_init_object (&node);
4813 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4814 vat_json_object_add_uint (&node, "policer_index",
4815 ntohl (mp->policer_index));
4817 vat_json_print (vam->ofp, &node);
4818 vat_json_free (&node);
4820 vam->retval = ntohl (mp->retval);
4821 vam->result_ready = 1;
4824 /* Format hex dump. */
4826 format_hex_bytes (u8 * s, va_list * va)
4828 u8 *bytes = va_arg (*va, u8 *);
4829 int n_bytes = va_arg (*va, int);
4832 /* Print short or long form depending on byte count. */
4833 uword short_form = n_bytes <= 32;
4834 u32 indent = format_get_indent (s);
4839 for (i = 0; i < n_bytes; i++)
4841 if (!short_form && (i % 32) == 0)
4842 s = format (s, "%08x: ", i);
4843 s = format (s, "%02x", bytes[i]);
4844 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4845 s = format (s, "\n%U", format_white_space, indent);
4852 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4855 vat_main_t *vam = &vat_main;
4856 i32 retval = ntohl (mp->retval);
4859 print (vam->ofp, "classify table info :");
4860 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4861 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4862 ntohl (mp->miss_next_index));
4863 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4864 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4865 ntohl (mp->match_n_vectors));
4866 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4867 ntohl (mp->mask_length));
4869 vam->retval = retval;
4870 vam->result_ready = 1;
4874 vl_api_classify_table_info_reply_t_handler_json
4875 (vl_api_classify_table_info_reply_t * mp)
4877 vat_main_t *vam = &vat_main;
4878 vat_json_node_t node;
4880 i32 retval = ntohl (mp->retval);
4883 vat_json_init_object (&node);
4885 vat_json_object_add_int (&node, "sessions",
4886 ntohl (mp->active_sessions));
4887 vat_json_object_add_int (&node, "nexttbl",
4888 ntohl (mp->next_table_index));
4889 vat_json_object_add_int (&node, "nextnode",
4890 ntohl (mp->miss_next_index));
4891 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4892 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4893 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4894 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4895 ntohl (mp->mask_length), 0);
4896 vat_json_object_add_string_copy (&node, "mask", s);
4898 vat_json_print (vam->ofp, &node);
4899 vat_json_free (&node);
4901 vam->retval = ntohl (mp->retval);
4902 vam->result_ready = 1;
4906 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4909 vat_main_t *vam = &vat_main;
4911 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4912 ntohl (mp->hit_next_index), ntohl (mp->advance),
4913 ntohl (mp->opaque_index));
4914 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4915 ntohl (mp->match_length));
4919 vl_api_classify_session_details_t_handler_json
4920 (vl_api_classify_session_details_t * mp)
4922 vat_main_t *vam = &vat_main;
4923 vat_json_node_t *node = NULL;
4925 if (VAT_JSON_ARRAY != vam->json_tree.type)
4927 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4928 vat_json_init_array (&vam->json_tree);
4930 node = vat_json_array_add (&vam->json_tree);
4932 vat_json_init_object (node);
4933 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4934 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4935 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4937 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4939 vat_json_object_add_string_copy (node, "match", s);
4942 static void vl_api_pg_create_interface_reply_t_handler
4943 (vl_api_pg_create_interface_reply_t * mp)
4945 vat_main_t *vam = &vat_main;
4947 vam->retval = ntohl (mp->retval);
4948 vam->result_ready = 1;
4951 static void vl_api_pg_create_interface_reply_t_handler_json
4952 (vl_api_pg_create_interface_reply_t * mp)
4954 vat_main_t *vam = &vat_main;
4955 vat_json_node_t node;
4957 i32 retval = ntohl (mp->retval);
4960 vat_json_init_object (&node);
4962 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4964 vat_json_print (vam->ofp, &node);
4965 vat_json_free (&node);
4967 vam->retval = ntohl (mp->retval);
4968 vam->result_ready = 1;
4971 static void vl_api_policer_classify_details_t_handler
4972 (vl_api_policer_classify_details_t * mp)
4974 vat_main_t *vam = &vat_main;
4976 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4977 ntohl (mp->table_index));
4980 static void vl_api_policer_classify_details_t_handler_json
4981 (vl_api_policer_classify_details_t * mp)
4983 vat_main_t *vam = &vat_main;
4984 vat_json_node_t *node;
4986 if (VAT_JSON_ARRAY != vam->json_tree.type)
4988 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4989 vat_json_init_array (&vam->json_tree);
4991 node = vat_json_array_add (&vam->json_tree);
4993 vat_json_init_object (node);
4994 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4995 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4998 static void vl_api_flow_classify_details_t_handler
4999 (vl_api_flow_classify_details_t * mp)
5001 vat_main_t *vam = &vat_main;
5003 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5004 ntohl (mp->table_index));
5007 static void vl_api_flow_classify_details_t_handler_json
5008 (vl_api_flow_classify_details_t * mp)
5010 vat_main_t *vam = &vat_main;
5011 vat_json_node_t *node;
5013 if (VAT_JSON_ARRAY != vam->json_tree.type)
5015 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5016 vat_json_init_array (&vam->json_tree);
5018 node = vat_json_array_add (&vam->json_tree);
5020 vat_json_init_object (node);
5021 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5022 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5025 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5026 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5027 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5028 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5029 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5030 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5031 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5032 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5033 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5034 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5037 * Generate boilerplate reply handlers, which
5038 * dig the return value out of the xxx_reply_t API message,
5039 * stick it into vam->retval, and set vam->result_ready
5041 * Could also do this by pointing N message decode slots at
5042 * a single function, but that could break in subtle ways.
5045 #define foreach_standard_reply_retval_handler \
5046 _(sw_interface_set_flags_reply) \
5047 _(sw_interface_add_del_address_reply) \
5048 _(sw_interface_set_rx_mode_reply) \
5049 _(sw_interface_set_rx_placement_reply) \
5050 _(sw_interface_set_table_reply) \
5051 _(sw_interface_set_mpls_enable_reply) \
5052 _(sw_interface_set_vpath_reply) \
5053 _(sw_interface_set_vxlan_bypass_reply) \
5054 _(sw_interface_set_geneve_bypass_reply) \
5055 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5056 _(sw_interface_set_l2_bridge_reply) \
5057 _(sw_interface_set_bond_weight_reply) \
5058 _(bridge_domain_add_del_reply) \
5059 _(sw_interface_set_l2_xconnect_reply) \
5060 _(l2fib_add_del_reply) \
5061 _(l2fib_flush_int_reply) \
5062 _(l2fib_flush_bd_reply) \
5063 _(ip_route_add_del_reply) \
5064 _(ip_table_add_del_reply) \
5065 _(ip_table_replace_begin_reply) \
5066 _(ip_table_flush_reply) \
5067 _(ip_table_replace_end_reply) \
5068 _(ip_mroute_add_del_reply) \
5069 _(mpls_route_add_del_reply) \
5070 _(mpls_table_add_del_reply) \
5071 _(mpls_ip_bind_unbind_reply) \
5072 _(bier_route_add_del_reply) \
5073 _(bier_table_add_del_reply) \
5074 _(proxy_arp_add_del_reply) \
5075 _(proxy_arp_intfc_enable_disable_reply) \
5076 _(sw_interface_set_unnumbered_reply) \
5077 _(ip_neighbor_add_del_reply) \
5078 _(set_ip_flow_hash_reply) \
5079 _(sw_interface_ip6_enable_disable_reply) \
5080 _(ip6nd_proxy_add_del_reply) \
5081 _(sw_interface_ip6nd_ra_prefix_reply) \
5082 _(sw_interface_ip6nd_ra_config_reply) \
5083 _(set_arp_neighbor_limit_reply) \
5084 _(l2_patch_add_del_reply) \
5085 _(sr_mpls_policy_add_reply) \
5086 _(sr_mpls_policy_mod_reply) \
5087 _(sr_mpls_policy_del_reply) \
5088 _(sr_policy_add_reply) \
5089 _(sr_policy_mod_reply) \
5090 _(sr_policy_del_reply) \
5091 _(sr_localsid_add_del_reply) \
5092 _(sr_steering_add_del_reply) \
5093 _(classify_add_del_session_reply) \
5094 _(classify_set_interface_ip_table_reply) \
5095 _(classify_set_interface_l2_tables_reply) \
5096 _(l2tpv3_set_tunnel_cookies_reply) \
5097 _(l2tpv3_interface_enable_disable_reply) \
5098 _(l2tpv3_set_lookup_key_reply) \
5099 _(l2_fib_clear_table_reply) \
5100 _(l2_interface_efp_filter_reply) \
5101 _(l2_interface_vlan_tag_rewrite_reply) \
5102 _(modify_vhost_user_if_reply) \
5103 _(delete_vhost_user_if_reply) \
5104 _(ip_probe_neighbor_reply) \
5105 _(ip_scan_neighbor_enable_disable_reply) \
5106 _(want_ip4_arp_events_reply) \
5107 _(want_ip6_nd_events_reply) \
5108 _(want_l2_macs_events_reply) \
5109 _(input_acl_set_interface_reply) \
5110 _(ipsec_spd_add_del_reply) \
5111 _(ipsec_interface_add_del_spd_reply) \
5112 _(ipsec_spd_entry_add_del_reply) \
5113 _(ipsec_sad_entry_add_del_reply) \
5114 _(ipsec_tunnel_if_add_del_reply) \
5115 _(ipsec_tunnel_if_set_sa_reply) \
5116 _(delete_loopback_reply) \
5117 _(bd_ip_mac_add_del_reply) \
5118 _(bd_ip_mac_flush_reply) \
5119 _(want_interface_events_reply) \
5120 _(cop_interface_enable_disable_reply) \
5121 _(cop_whitelist_enable_disable_reply) \
5122 _(sw_interface_clear_stats_reply) \
5123 _(ioam_enable_reply) \
5124 _(ioam_disable_reply) \
5125 _(one_add_del_locator_reply) \
5126 _(one_add_del_local_eid_reply) \
5127 _(one_add_del_remote_mapping_reply) \
5128 _(one_add_del_adjacency_reply) \
5129 _(one_add_del_map_resolver_reply) \
5130 _(one_add_del_map_server_reply) \
5131 _(one_enable_disable_reply) \
5132 _(one_rloc_probe_enable_disable_reply) \
5133 _(one_map_register_enable_disable_reply) \
5134 _(one_map_register_set_ttl_reply) \
5135 _(one_set_transport_protocol_reply) \
5136 _(one_map_register_fallback_threshold_reply) \
5137 _(one_pitr_set_locator_set_reply) \
5138 _(one_map_request_mode_reply) \
5139 _(one_add_del_map_request_itr_rlocs_reply) \
5140 _(one_eid_table_add_del_map_reply) \
5141 _(one_use_petr_reply) \
5142 _(one_stats_enable_disable_reply) \
5143 _(one_add_del_l2_arp_entry_reply) \
5144 _(one_add_del_ndp_entry_reply) \
5145 _(one_stats_flush_reply) \
5146 _(one_enable_disable_xtr_mode_reply) \
5147 _(one_enable_disable_pitr_mode_reply) \
5148 _(one_enable_disable_petr_mode_reply) \
5149 _(gpe_enable_disable_reply) \
5150 _(gpe_set_encap_mode_reply) \
5151 _(gpe_add_del_iface_reply) \
5152 _(gpe_add_del_native_fwd_rpath_reply) \
5153 _(af_packet_delete_reply) \
5154 _(policer_classify_set_interface_reply) \
5155 _(netmap_create_reply) \
5156 _(netmap_delete_reply) \
5157 _(set_ipfix_exporter_reply) \
5158 _(set_ipfix_classify_stream_reply) \
5159 _(ipfix_classify_table_add_del_reply) \
5160 _(flow_classify_set_interface_reply) \
5161 _(sw_interface_span_enable_disable_reply) \
5162 _(pg_capture_reply) \
5163 _(pg_enable_disable_reply) \
5164 _(ip_source_and_port_range_check_add_del_reply) \
5165 _(ip_source_and_port_range_check_interface_add_del_reply)\
5166 _(delete_subif_reply) \
5167 _(l2_interface_pbb_tag_rewrite_reply) \
5169 _(feature_enable_disable_reply) \
5170 _(feature_gso_enable_disable_reply) \
5171 _(sw_interface_tag_add_del_reply) \
5172 _(sw_interface_add_del_mac_address_reply) \
5173 _(hw_interface_set_mtu_reply) \
5174 _(p2p_ethernet_add_reply) \
5175 _(p2p_ethernet_del_reply) \
5176 _(lldp_config_reply) \
5177 _(sw_interface_set_lldp_reply) \
5178 _(tcp_configure_src_addresses_reply) \
5179 _(session_rule_add_del_reply) \
5180 _(ip_container_proxy_add_del_reply) \
5181 _(output_acl_set_interface_reply) \
5182 _(qos_record_enable_disable_reply)
5185 static void vl_api_##n##_t_handler \
5186 (vl_api_##n##_t * mp) \
5188 vat_main_t * vam = &vat_main; \
5189 i32 retval = ntohl(mp->retval); \
5190 if (vam->async_mode) { \
5191 vam->async_errors += (retval < 0); \
5193 vam->retval = retval; \
5194 vam->result_ready = 1; \
5197 foreach_standard_reply_retval_handler;
5201 static void vl_api_##n##_t_handler_json \
5202 (vl_api_##n##_t * mp) \
5204 vat_main_t * vam = &vat_main; \
5205 vat_json_node_t node; \
5206 vat_json_init_object(&node); \
5207 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5208 vat_json_print(vam->ofp, &node); \
5209 vam->retval = ntohl(mp->retval); \
5210 vam->result_ready = 1; \
5212 foreach_standard_reply_retval_handler;
5216 * Table of message reply handlers, must include boilerplate handlers
5220 #define foreach_vpe_api_reply_msg \
5221 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5222 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5223 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5224 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5225 _(CONTROL_PING_REPLY, control_ping_reply) \
5226 _(CLI_REPLY, cli_reply) \
5227 _(CLI_INBAND_REPLY, cli_inband_reply) \
5228 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5229 sw_interface_add_del_address_reply) \
5230 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5231 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5232 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5233 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5234 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5235 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5236 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5237 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5238 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5239 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5240 sw_interface_set_l2_xconnect_reply) \
5241 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5242 sw_interface_set_l2_bridge_reply) \
5243 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5244 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5245 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5246 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5247 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5248 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5249 _(L2_FLAGS_REPLY, l2_flags_reply) \
5250 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5251 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5252 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5253 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5254 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5255 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5256 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5257 _(BOND_CREATE_REPLY, bond_create_reply) \
5258 _(BOND_DELETE_REPLY, bond_delete_reply) \
5259 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5260 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5261 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5262 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5263 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5264 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5265 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5266 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5267 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5268 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5269 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5270 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5271 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5272 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5273 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5274 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5275 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5276 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5277 proxy_arp_intfc_enable_disable_reply) \
5278 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5279 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5280 sw_interface_set_unnumbered_reply) \
5281 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5282 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5283 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5284 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5285 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5286 sw_interface_ip6_enable_disable_reply) \
5287 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5288 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5289 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5290 sw_interface_ip6nd_ra_prefix_reply) \
5291 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5292 sw_interface_ip6nd_ra_config_reply) \
5293 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5294 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5295 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5296 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5297 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5298 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5299 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5300 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5301 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5302 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5303 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5304 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5305 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5306 classify_set_interface_ip_table_reply) \
5307 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5308 classify_set_interface_l2_tables_reply) \
5309 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5310 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5311 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5312 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5313 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5314 l2tpv3_interface_enable_disable_reply) \
5315 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5316 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5317 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5318 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5319 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5320 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5321 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5322 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5323 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5324 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5325 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5326 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5327 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5328 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5329 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5330 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5331 _(SHOW_VERSION_REPLY, show_version_reply) \
5332 _(SHOW_THREADS_REPLY, show_threads_reply) \
5333 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5334 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5335 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5336 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5337 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5338 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5339 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5340 _(IP4_ARP_EVENT, ip4_arp_event) \
5341 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5342 _(IP6_ND_EVENT, ip6_nd_event) \
5343 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5344 _(L2_MACS_EVENT, l2_macs_event) \
5345 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5346 _(IP_ADDRESS_DETAILS, ip_address_details) \
5347 _(IP_DETAILS, ip_details) \
5348 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5349 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5350 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5351 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5352 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5353 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5354 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5355 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5356 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5357 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5358 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5359 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5360 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5361 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5362 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5363 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5364 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5365 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5366 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5367 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5368 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5369 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5370 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5371 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5372 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5373 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5374 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5375 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5376 one_map_register_enable_disable_reply) \
5377 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5378 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5379 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5380 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5381 one_map_register_fallback_threshold_reply) \
5382 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5383 one_rloc_probe_enable_disable_reply) \
5384 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5385 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5386 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5387 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5388 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5389 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5390 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5391 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5392 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5393 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5394 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5395 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5396 _(ONE_STATS_DETAILS, one_stats_details) \
5397 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5398 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5399 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5400 show_one_stats_enable_disable_reply) \
5401 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5402 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5403 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5404 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5405 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5406 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5407 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5408 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5409 one_enable_disable_pitr_mode_reply) \
5410 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5411 one_enable_disable_petr_mode_reply) \
5412 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5413 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5414 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5415 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5416 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5417 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5418 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5419 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5420 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5421 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5422 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5423 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5424 gpe_add_del_native_fwd_rpath_reply) \
5425 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5426 gpe_fwd_entry_path_details) \
5427 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5428 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5429 one_add_del_map_request_itr_rlocs_reply) \
5430 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5431 one_get_map_request_itr_rlocs_reply) \
5432 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5433 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5434 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5435 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5436 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5437 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5438 show_one_map_register_state_reply) \
5439 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5440 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5441 show_one_map_register_fallback_threshold_reply) \
5442 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5443 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5444 _(AF_PACKET_DETAILS, af_packet_details) \
5445 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5446 _(POLICER_DETAILS, policer_details) \
5447 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5448 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5449 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5450 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5451 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5452 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5453 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5454 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5455 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5456 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5457 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5458 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5459 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5460 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5461 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5462 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5463 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5464 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5465 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5466 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5467 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5468 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5469 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5470 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5471 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5472 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5473 ip_source_and_port_range_check_add_del_reply) \
5474 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5475 ip_source_and_port_range_check_interface_add_del_reply) \
5476 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5477 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5478 _(SET_PUNT_REPLY, set_punt_reply) \
5479 _(IP_TABLE_DETAILS, ip_table_details) \
5480 _(IP_ROUTE_DETAILS, ip_route_details) \
5481 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5482 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5483 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5484 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5485 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5486 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5487 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5488 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5489 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5490 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5491 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5492 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5493 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5494 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5495 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5496 _(SESSION_RULES_DETAILS, session_rules_details) \
5497 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5498 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5499 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5501 #define foreach_standalone_reply_msg \
5502 _(SW_INTERFACE_EVENT, sw_interface_event)
5510 #define STR_VTR_OP_CASE(op) \
5511 case L2_VTR_ ## op: \
5515 str_vtr_op (u32 vtr_op)
5519 STR_VTR_OP_CASE (DISABLED);
5520 STR_VTR_OP_CASE (PUSH_1);
5521 STR_VTR_OP_CASE (PUSH_2);
5522 STR_VTR_OP_CASE (POP_1);
5523 STR_VTR_OP_CASE (POP_2);
5524 STR_VTR_OP_CASE (TRANSLATE_1_1);
5525 STR_VTR_OP_CASE (TRANSLATE_1_2);
5526 STR_VTR_OP_CASE (TRANSLATE_2_1);
5527 STR_VTR_OP_CASE (TRANSLATE_2_2);
5534 dump_sub_interface_table (vat_main_t * vam)
5536 const sw_interface_subif_t *sub = NULL;
5538 if (vam->json_output)
5541 ("JSON output supported only for VPE API calls and dump_stats_table");
5546 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5547 "Interface", "sw_if_index",
5548 "sub id", "dot1ad", "tags", "outer id",
5549 "inner id", "exact", "default", "outer any", "inner any");
5551 vec_foreach (sub, vam->sw_if_subif_table)
5554 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5555 sub->interface_name,
5557 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5558 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5559 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5560 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5561 if (sub->vtr_op != L2_VTR_DISABLED)
5564 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5565 "tag1: %d tag2: %d ]",
5566 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5567 sub->vtr_tag1, sub->vtr_tag2);
5575 name_sort_cmp (void *a1, void *a2)
5577 name_sort_t *n1 = a1;
5578 name_sort_t *n2 = a2;
5580 return strcmp ((char *) n1->name, (char *) n2->name);
5584 dump_interface_table (vat_main_t * vam)
5587 name_sort_t *nses = 0, *ns;
5589 if (vam->json_output)
5592 ("JSON output supported only for VPE API calls and dump_stats_table");
5597 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5599 vec_add2 (nses, ns, 1);
5600 ns->name = (u8 *)(p->key);
5601 ns->value = (u32) p->value[0];
5605 vec_sort_with_function (nses, name_sort_cmp);
5607 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5608 vec_foreach (ns, nses)
5610 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5617 dump_ip_table (vat_main_t * vam, int is_ipv6)
5619 const ip_details_t *det = NULL;
5620 const ip_address_details_t *address = NULL;
5623 print (vam->ofp, "%-12s", "sw_if_index");
5625 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5632 print (vam->ofp, "%-12d", i);
5633 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5638 vec_foreach (address, det->addr)
5642 is_ipv6 ? format_ip6_address : format_ip4_address,
5643 address->ip, address->prefix_length);
5651 dump_ipv4_table (vat_main_t * vam)
5653 if (vam->json_output)
5656 ("JSON output supported only for VPE API calls and dump_stats_table");
5660 return dump_ip_table (vam, 0);
5664 dump_ipv6_table (vat_main_t * vam)
5666 if (vam->json_output)
5669 ("JSON output supported only for VPE API calls and dump_stats_table");
5673 return dump_ip_table (vam, 1);
5677 * Pass CLI buffers directly in the CLI_INBAND API message,
5678 * instead of an additional shared memory area.
5681 exec_inband (vat_main_t * vam)
5683 vl_api_cli_inband_t *mp;
5684 unformat_input_t *i = vam->input;
5687 if (vec_len (i->buffer) == 0)
5690 if (vam->exec_mode == 0 && unformat (i, "mode"))
5695 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5702 * In order for the CLI command to work, it
5703 * must be a vector ending in \n, not a C-string ending
5706 u32 len = vec_len (vam->input->buffer);
5707 M2 (CLI_INBAND, mp, len);
5708 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5712 /* json responses may or may not include a useful reply... */
5713 if (vec_len (vam->cmd_reply))
5714 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5719 exec (vat_main_t * vam)
5721 return exec_inband (vam);
5725 api_create_loopback (vat_main_t * vam)
5727 unformat_input_t *i = vam->input;
5728 vl_api_create_loopback_t *mp;
5729 vl_api_create_loopback_instance_t *mp_lbi;
5732 u8 is_specified = 0;
5733 u32 user_instance = 0;
5736 clib_memset (mac_address, 0, sizeof (mac_address));
5738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5740 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5742 if (unformat (i, "instance %d", &user_instance))
5750 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5751 mp_lbi->is_specified = is_specified;
5753 mp_lbi->user_instance = htonl (user_instance);
5755 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5760 /* Construct the API message */
5761 M (CREATE_LOOPBACK, mp);
5763 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5772 api_delete_loopback (vat_main_t * vam)
5774 unformat_input_t *i = vam->input;
5775 vl_api_delete_loopback_t *mp;
5776 u32 sw_if_index = ~0;
5779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5781 if (unformat (i, "sw_if_index %d", &sw_if_index))
5787 if (sw_if_index == ~0)
5789 errmsg ("missing sw_if_index");
5793 /* Construct the API message */
5794 M (DELETE_LOOPBACK, mp);
5795 mp->sw_if_index = ntohl (sw_if_index);
5803 api_want_interface_events (vat_main_t * vam)
5805 unformat_input_t *i = vam->input;
5806 vl_api_want_interface_events_t *mp;
5810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5812 if (unformat (i, "enable"))
5814 else if (unformat (i, "disable"))
5822 errmsg ("missing enable|disable");
5826 M (WANT_INTERFACE_EVENTS, mp);
5827 mp->enable_disable = enable;
5829 vam->interface_event_display = enable;
5837 /* Note: non-static, called once to set up the initial intfc table */
5839 api_sw_interface_dump (vat_main_t * vam)
5841 vl_api_sw_interface_dump_t *mp;
5842 vl_api_control_ping_t *mp_ping;
5844 name_sort_t *nses = 0, *ns;
5845 sw_interface_subif_t *sub = NULL;
5848 /* Toss the old name table */
5850 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5852 vec_add2 (nses, ns, 1);
5853 ns->name = (u8 *)(p->key);
5854 ns->value = (u32) p->value[0];
5858 hash_free (vam->sw_if_index_by_interface_name);
5860 vec_foreach (ns, nses) vec_free (ns->name);
5864 vec_foreach (sub, vam->sw_if_subif_table)
5866 vec_free (sub->interface_name);
5868 vec_free (vam->sw_if_subif_table);
5870 /* recreate the interface name hash table */
5871 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5874 * Ask for all interface names. Otherwise, the epic catalog of
5875 * name filters becomes ridiculously long, and vat ends up needing
5876 * to be taught about new interface types.
5878 M (SW_INTERFACE_DUMP, mp);
5881 /* Use a control ping for synchronization */
5882 MPING (CONTROL_PING, mp_ping);
5890 api_sw_interface_set_flags (vat_main_t * vam)
5892 unformat_input_t *i = vam->input;
5893 vl_api_sw_interface_set_flags_t *mp;
5895 u8 sw_if_index_set = 0;
5899 /* Parse args required to build the message */
5900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5902 if (unformat (i, "admin-up"))
5904 else if (unformat (i, "admin-down"))
5907 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5908 sw_if_index_set = 1;
5909 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5910 sw_if_index_set = 1;
5915 if (sw_if_index_set == 0)
5917 errmsg ("missing interface name or sw_if_index");
5921 /* Construct the API message */
5922 M (SW_INTERFACE_SET_FLAGS, mp);
5923 mp->sw_if_index = ntohl (sw_if_index);
5924 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5929 /* Wait for a reply, return the good/bad news... */
5935 api_sw_interface_set_rx_mode (vat_main_t * vam)
5937 unformat_input_t *i = vam->input;
5938 vl_api_sw_interface_set_rx_mode_t *mp;
5940 u8 sw_if_index_set = 0;
5942 u8 queue_id_valid = 0;
5944 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5946 /* Parse args required to build the message */
5947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5949 if (unformat (i, "queue %d", &queue_id))
5951 else if (unformat (i, "polling"))
5952 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5953 else if (unformat (i, "interrupt"))
5954 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5955 else if (unformat (i, "adaptive"))
5956 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5958 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5959 sw_if_index_set = 1;
5960 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5961 sw_if_index_set = 1;
5966 if (sw_if_index_set == 0)
5968 errmsg ("missing interface name or sw_if_index");
5971 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5973 errmsg ("missing rx-mode");
5977 /* Construct the API message */
5978 M (SW_INTERFACE_SET_RX_MODE, mp);
5979 mp->sw_if_index = ntohl (sw_if_index);
5980 mp->mode = (vl_api_rx_mode_t) mode;
5981 mp->queue_id_valid = queue_id_valid;
5982 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5987 /* Wait for a reply, return the good/bad news... */
5993 api_sw_interface_set_rx_placement (vat_main_t * vam)
5995 unformat_input_t *i = vam->input;
5996 vl_api_sw_interface_set_rx_placement_t *mp;
5998 u8 sw_if_index_set = 0;
6001 u32 queue_id, thread_index;
6003 /* Parse args required to build the message */
6004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6006 if (unformat (i, "queue %d", &queue_id))
6008 else if (unformat (i, "main"))
6010 else if (unformat (i, "worker %d", &thread_index))
6013 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6014 sw_if_index_set = 1;
6015 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6016 sw_if_index_set = 1;
6021 if (sw_if_index_set == 0)
6023 errmsg ("missing interface name or sw_if_index");
6029 /* Construct the API message */
6030 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6031 mp->sw_if_index = ntohl (sw_if_index);
6032 mp->worker_id = ntohl (thread_index);
6033 mp->queue_id = ntohl (queue_id);
6034 mp->is_main = is_main;
6038 /* Wait for a reply, return the good/bad news... */
6043 static void vl_api_sw_interface_rx_placement_details_t_handler
6044 (vl_api_sw_interface_rx_placement_details_t * mp)
6046 vat_main_t *vam = &vat_main;
6047 u32 worker_id = ntohl (mp->worker_id);
6050 "\n%-11d %-11s %-6d %-5d %-9s",
6051 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6052 worker_id, ntohl (mp->queue_id),
6054 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6057 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6058 (vl_api_sw_interface_rx_placement_details_t * mp)
6060 vat_main_t *vam = &vat_main;
6061 vat_json_node_t *node = NULL;
6063 if (VAT_JSON_ARRAY != vam->json_tree.type)
6065 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6066 vat_json_init_array (&vam->json_tree);
6068 node = vat_json_array_add (&vam->json_tree);
6070 vat_json_init_object (node);
6071 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6072 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6073 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6074 vat_json_object_add_uint (node, "mode", mp->mode);
6078 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6080 unformat_input_t *i = vam->input;
6081 vl_api_sw_interface_rx_placement_dump_t *mp;
6082 vl_api_control_ping_t *mp_ping;
6085 u8 sw_if_index_set = 0;
6087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6089 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6091 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6098 "\n%-11s %-11s %-6s %-5s %-4s",
6099 "sw_if_index", "main/worker", "thread", "queue", "mode");
6101 /* Dump Interface rx placement */
6102 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6104 if (sw_if_index_set)
6105 mp->sw_if_index = htonl (sw_if_index);
6107 mp->sw_if_index = ~0;
6111 /* Use a control ping for synchronization */
6112 MPING (CONTROL_PING, mp_ping);
6120 api_sw_interface_clear_stats (vat_main_t * vam)
6122 unformat_input_t *i = vam->input;
6123 vl_api_sw_interface_clear_stats_t *mp;
6125 u8 sw_if_index_set = 0;
6128 /* Parse args required to build the message */
6129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6131 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6132 sw_if_index_set = 1;
6133 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6134 sw_if_index_set = 1;
6139 /* Construct the API message */
6140 M (SW_INTERFACE_CLEAR_STATS, mp);
6142 if (sw_if_index_set == 1)
6143 mp->sw_if_index = ntohl (sw_if_index);
6145 mp->sw_if_index = ~0;
6150 /* Wait for a reply, return the good/bad news... */
6156 api_sw_interface_add_del_address (vat_main_t * vam)
6158 unformat_input_t *i = vam->input;
6159 vl_api_sw_interface_add_del_address_t *mp;
6161 u8 sw_if_index_set = 0;
6162 u8 is_add = 1, del_all = 0;
6163 u32 address_length = 0;
6164 u8 v4_address_set = 0;
6165 u8 v6_address_set = 0;
6166 ip4_address_t v4address;
6167 ip6_address_t v6address;
6170 /* Parse args required to build the message */
6171 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6173 if (unformat (i, "del-all"))
6175 else if (unformat (i, "del"))
6178 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6179 sw_if_index_set = 1;
6180 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6181 sw_if_index_set = 1;
6182 else if (unformat (i, "%U/%d",
6183 unformat_ip4_address, &v4address, &address_length))
6185 else if (unformat (i, "%U/%d",
6186 unformat_ip6_address, &v6address, &address_length))
6192 if (sw_if_index_set == 0)
6194 errmsg ("missing interface name or sw_if_index");
6197 if (v4_address_set && v6_address_set)
6199 errmsg ("both v4 and v6 addresses set");
6202 if (!v4_address_set && !v6_address_set && !del_all)
6204 errmsg ("no addresses set");
6208 /* Construct the API message */
6209 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6211 mp->sw_if_index = ntohl (sw_if_index);
6212 mp->is_add = is_add;
6213 mp->del_all = del_all;
6216 mp->prefix.address.af = ADDRESS_IP6;
6217 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6221 mp->prefix.address.af = ADDRESS_IP4;
6222 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6224 mp->prefix.len = address_length;
6229 /* Wait for a reply, return good/bad news */
6235 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6237 unformat_input_t *i = vam->input;
6238 vl_api_sw_interface_set_mpls_enable_t *mp;
6240 u8 sw_if_index_set = 0;
6244 /* Parse args required to build the message */
6245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6247 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6248 sw_if_index_set = 1;
6249 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6250 sw_if_index_set = 1;
6251 else if (unformat (i, "disable"))
6253 else if (unformat (i, "dis"))
6259 if (sw_if_index_set == 0)
6261 errmsg ("missing interface name or sw_if_index");
6265 /* Construct the API message */
6266 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6268 mp->sw_if_index = ntohl (sw_if_index);
6269 mp->enable = enable;
6274 /* Wait for a reply... */
6280 api_sw_interface_set_table (vat_main_t * vam)
6282 unformat_input_t *i = vam->input;
6283 vl_api_sw_interface_set_table_t *mp;
6284 u32 sw_if_index, vrf_id = 0;
6285 u8 sw_if_index_set = 0;
6289 /* Parse args required to build the message */
6290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6292 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6293 sw_if_index_set = 1;
6294 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6295 sw_if_index_set = 1;
6296 else if (unformat (i, "vrf %d", &vrf_id))
6298 else if (unformat (i, "ipv6"))
6304 if (sw_if_index_set == 0)
6306 errmsg ("missing interface name or sw_if_index");
6310 /* Construct the API message */
6311 M (SW_INTERFACE_SET_TABLE, mp);
6313 mp->sw_if_index = ntohl (sw_if_index);
6314 mp->is_ipv6 = is_ipv6;
6315 mp->vrf_id = ntohl (vrf_id);
6320 /* Wait for a reply... */
6325 static void vl_api_sw_interface_get_table_reply_t_handler
6326 (vl_api_sw_interface_get_table_reply_t * mp)
6328 vat_main_t *vam = &vat_main;
6330 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6332 vam->retval = ntohl (mp->retval);
6333 vam->result_ready = 1;
6337 static void vl_api_sw_interface_get_table_reply_t_handler_json
6338 (vl_api_sw_interface_get_table_reply_t * mp)
6340 vat_main_t *vam = &vat_main;
6341 vat_json_node_t node;
6343 vat_json_init_object (&node);
6344 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6345 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6347 vat_json_print (vam->ofp, &node);
6348 vat_json_free (&node);
6350 vam->retval = ntohl (mp->retval);
6351 vam->result_ready = 1;
6355 api_sw_interface_get_table (vat_main_t * vam)
6357 unformat_input_t *i = vam->input;
6358 vl_api_sw_interface_get_table_t *mp;
6360 u8 sw_if_index_set = 0;
6364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6366 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6367 sw_if_index_set = 1;
6368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6369 sw_if_index_set = 1;
6370 else if (unformat (i, "ipv6"))
6376 if (sw_if_index_set == 0)
6378 errmsg ("missing interface name or sw_if_index");
6382 M (SW_INTERFACE_GET_TABLE, mp);
6383 mp->sw_if_index = htonl (sw_if_index);
6384 mp->is_ipv6 = is_ipv6;
6392 api_sw_interface_set_vpath (vat_main_t * vam)
6394 unformat_input_t *i = vam->input;
6395 vl_api_sw_interface_set_vpath_t *mp;
6396 u32 sw_if_index = 0;
6397 u8 sw_if_index_set = 0;
6401 /* Parse args required to build the message */
6402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6404 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6405 sw_if_index_set = 1;
6406 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6407 sw_if_index_set = 1;
6408 else if (unformat (i, "enable"))
6410 else if (unformat (i, "disable"))
6416 if (sw_if_index_set == 0)
6418 errmsg ("missing interface name or sw_if_index");
6422 /* Construct the API message */
6423 M (SW_INTERFACE_SET_VPATH, mp);
6425 mp->sw_if_index = ntohl (sw_if_index);
6426 mp->enable = is_enable;
6431 /* Wait for a reply... */
6437 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6439 unformat_input_t *i = vam->input;
6440 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6441 u32 sw_if_index = 0;
6442 u8 sw_if_index_set = 0;
6447 /* Parse args required to build the message */
6448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6450 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6451 sw_if_index_set = 1;
6452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6453 sw_if_index_set = 1;
6454 else if (unformat (i, "enable"))
6456 else if (unformat (i, "disable"))
6458 else if (unformat (i, "ip4"))
6460 else if (unformat (i, "ip6"))
6466 if (sw_if_index_set == 0)
6468 errmsg ("missing interface name or sw_if_index");
6472 /* Construct the API message */
6473 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6475 mp->sw_if_index = ntohl (sw_if_index);
6476 mp->enable = is_enable;
6477 mp->is_ipv6 = is_ipv6;
6482 /* Wait for a reply... */
6488 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6490 unformat_input_t *i = vam->input;
6491 vl_api_sw_interface_set_geneve_bypass_t *mp;
6492 u32 sw_if_index = 0;
6493 u8 sw_if_index_set = 0;
6498 /* Parse args required to build the message */
6499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6501 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6502 sw_if_index_set = 1;
6503 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6504 sw_if_index_set = 1;
6505 else if (unformat (i, "enable"))
6507 else if (unformat (i, "disable"))
6509 else if (unformat (i, "ip4"))
6511 else if (unformat (i, "ip6"))
6517 if (sw_if_index_set == 0)
6519 errmsg ("missing interface name or sw_if_index");
6523 /* Construct the API message */
6524 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6526 mp->sw_if_index = ntohl (sw_if_index);
6527 mp->enable = is_enable;
6528 mp->is_ipv6 = is_ipv6;
6533 /* Wait for a reply... */
6539 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6541 unformat_input_t *i = vam->input;
6542 vl_api_sw_interface_set_l2_xconnect_t *mp;
6544 u8 rx_sw_if_index_set = 0;
6546 u8 tx_sw_if_index_set = 0;
6550 /* Parse args required to build the message */
6551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6553 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6554 rx_sw_if_index_set = 1;
6555 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6556 tx_sw_if_index_set = 1;
6557 else if (unformat (i, "rx"))
6559 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6561 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6563 rx_sw_if_index_set = 1;
6568 else if (unformat (i, "tx"))
6570 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6572 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6574 tx_sw_if_index_set = 1;
6579 else if (unformat (i, "enable"))
6581 else if (unformat (i, "disable"))
6587 if (rx_sw_if_index_set == 0)
6589 errmsg ("missing rx interface name or rx_sw_if_index");
6593 if (enable && (tx_sw_if_index_set == 0))
6595 errmsg ("missing tx interface name or tx_sw_if_index");
6599 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6601 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6602 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6603 mp->enable = enable;
6611 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6613 unformat_input_t *i = vam->input;
6614 vl_api_sw_interface_set_l2_bridge_t *mp;
6615 vl_api_l2_port_type_t port_type;
6617 u8 rx_sw_if_index_set = 0;
6624 port_type = L2_API_PORT_TYPE_NORMAL;
6626 /* Parse args required to build the message */
6627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6629 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6630 rx_sw_if_index_set = 1;
6631 else if (unformat (i, "bd_id %d", &bd_id))
6635 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6636 rx_sw_if_index_set = 1;
6637 else if (unformat (i, "shg %d", &shg))
6639 else if (unformat (i, "bvi"))
6640 port_type = L2_API_PORT_TYPE_BVI;
6641 else if (unformat (i, "uu-fwd"))
6642 port_type = L2_API_PORT_TYPE_UU_FWD;
6643 else if (unformat (i, "enable"))
6645 else if (unformat (i, "disable"))
6651 if (rx_sw_if_index_set == 0)
6653 errmsg ("missing rx interface name or sw_if_index");
6657 if (enable && (bd_id_set == 0))
6659 errmsg ("missing bridge domain");
6663 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6665 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6666 mp->bd_id = ntohl (bd_id);
6668 mp->port_type = ntohl (port_type);
6669 mp->enable = enable;
6677 api_bridge_domain_dump (vat_main_t * vam)
6679 unformat_input_t *i = vam->input;
6680 vl_api_bridge_domain_dump_t *mp;
6681 vl_api_control_ping_t *mp_ping;
6685 /* Parse args required to build the message */
6686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6688 if (unformat (i, "bd_id %d", &bd_id))
6694 M (BRIDGE_DOMAIN_DUMP, mp);
6695 mp->bd_id = ntohl (bd_id);
6698 /* Use a control ping for synchronization */
6699 MPING (CONTROL_PING, mp_ping);
6707 api_bridge_domain_add_del (vat_main_t * vam)
6709 unformat_input_t *i = vam->input;
6710 vl_api_bridge_domain_add_del_t *mp;
6713 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6718 /* Parse args required to build the message */
6719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6721 if (unformat (i, "bd_id %d", &bd_id))
6723 else if (unformat (i, "flood %d", &flood))
6725 else if (unformat (i, "uu-flood %d", &uu_flood))
6727 else if (unformat (i, "forward %d", &forward))
6729 else if (unformat (i, "learn %d", &learn))
6731 else if (unformat (i, "arp-term %d", &arp_term))
6733 else if (unformat (i, "mac-age %d", &mac_age))
6735 else if (unformat (i, "bd-tag %s", &bd_tag))
6737 else if (unformat (i, "del"))
6740 flood = uu_flood = forward = learn = 0;
6748 errmsg ("missing bridge domain");
6755 errmsg ("mac age must be less than 256 ");
6760 if ((bd_tag) && (vec_len (bd_tag) > 63))
6762 errmsg ("bd-tag cannot be longer than 63");
6767 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6769 mp->bd_id = ntohl (bd_id);
6771 mp->uu_flood = uu_flood;
6772 mp->forward = forward;
6774 mp->arp_term = arp_term;
6775 mp->is_add = is_add;
6776 mp->mac_age = (u8) mac_age;
6779 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6780 mp->bd_tag[vec_len (bd_tag)] = 0;
6791 api_l2fib_flush_bd (vat_main_t * vam)
6793 unformat_input_t *i = vam->input;
6794 vl_api_l2fib_flush_bd_t *mp;
6798 /* Parse args required to build the message */
6799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6801 if (unformat (i, "bd_id %d", &bd_id));
6808 errmsg ("missing bridge domain");
6812 M (L2FIB_FLUSH_BD, mp);
6814 mp->bd_id = htonl (bd_id);
6822 api_l2fib_flush_int (vat_main_t * vam)
6824 unformat_input_t *i = vam->input;
6825 vl_api_l2fib_flush_int_t *mp;
6826 u32 sw_if_index = ~0;
6829 /* Parse args required to build the message */
6830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6832 if (unformat (i, "sw_if_index %d", &sw_if_index));
6834 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6839 if (sw_if_index == ~0)
6841 errmsg ("missing interface name or sw_if_index");
6845 M (L2FIB_FLUSH_INT, mp);
6847 mp->sw_if_index = ntohl (sw_if_index);
6855 api_l2fib_add_del (vat_main_t * vam)
6857 unformat_input_t *i = vam->input;
6858 vl_api_l2fib_add_del_t *mp;
6864 u32 sw_if_index = 0;
6865 u8 sw_if_index_set = 0;
6874 /* Parse args required to build the message */
6875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6877 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6879 else if (unformat (i, "bd_id %d", &bd_id))
6881 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6882 sw_if_index_set = 1;
6883 else if (unformat (i, "sw_if"))
6885 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6888 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6889 sw_if_index_set = 1;
6894 else if (unformat (i, "static"))
6896 else if (unformat (i, "filter"))
6901 else if (unformat (i, "bvi"))
6906 else if (unformat (i, "del"))
6908 else if (unformat (i, "count %d", &count))
6916 errmsg ("missing mac address");
6922 errmsg ("missing bridge domain");
6926 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6928 errmsg ("missing interface name or sw_if_index");
6934 /* Turn on async mode */
6935 vam->async_mode = 1;
6936 vam->async_errors = 0;
6937 before = vat_time_now (vam);
6940 for (j = 0; j < count; j++)
6942 M (L2FIB_ADD_DEL, mp);
6944 clib_memcpy (mp->mac, mac, 6);
6945 mp->bd_id = ntohl (bd_id);
6946 mp->is_add = is_add;
6947 mp->sw_if_index = ntohl (sw_if_index);
6951 mp->static_mac = static_mac;
6952 mp->filter_mac = filter_mac;
6953 mp->bvi_mac = bvi_mac;
6955 increment_mac_address (mac);
6962 vl_api_control_ping_t *mp_ping;
6965 /* Shut off async mode */
6966 vam->async_mode = 0;
6968 MPING (CONTROL_PING, mp_ping);
6971 timeout = vat_time_now (vam) + 1.0;
6972 while (vat_time_now (vam) < timeout)
6973 if (vam->result_ready == 1)
6978 if (vam->retval == -99)
6981 if (vam->async_errors > 0)
6983 errmsg ("%d asynchronous errors", vam->async_errors);
6986 vam->async_errors = 0;
6987 after = vat_time_now (vam);
6989 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6990 count, after - before, count / (after - before));
6996 /* Wait for a reply... */
7000 /* Return the good/bad news */
7001 return (vam->retval);
7005 api_bridge_domain_set_mac_age (vat_main_t * vam)
7007 unformat_input_t *i = vam->input;
7008 vl_api_bridge_domain_set_mac_age_t *mp;
7013 /* Parse args required to build the message */
7014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7016 if (unformat (i, "bd_id %d", &bd_id));
7017 else if (unformat (i, "mac-age %d", &mac_age));
7024 errmsg ("missing bridge domain");
7030 errmsg ("mac age must be less than 256 ");
7034 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7036 mp->bd_id = htonl (bd_id);
7037 mp->mac_age = (u8) mac_age;
7045 api_l2_flags (vat_main_t * vam)
7047 unformat_input_t *i = vam->input;
7048 vl_api_l2_flags_t *mp;
7051 u8 sw_if_index_set = 0;
7055 /* Parse args required to build the message */
7056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7058 if (unformat (i, "sw_if_index %d", &sw_if_index))
7059 sw_if_index_set = 1;
7060 else if (unformat (i, "sw_if"))
7062 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7065 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7066 sw_if_index_set = 1;
7071 else if (unformat (i, "learn"))
7073 else if (unformat (i, "forward"))
7075 else if (unformat (i, "flood"))
7077 else if (unformat (i, "uu-flood"))
7078 flags |= L2_UU_FLOOD;
7079 else if (unformat (i, "arp-term"))
7080 flags |= L2_ARP_TERM;
7081 else if (unformat (i, "off"))
7083 else if (unformat (i, "disable"))
7089 if (sw_if_index_set == 0)
7091 errmsg ("missing interface name or sw_if_index");
7097 mp->sw_if_index = ntohl (sw_if_index);
7098 mp->feature_bitmap = ntohl (flags);
7099 mp->is_set = is_set;
7107 api_bridge_flags (vat_main_t * vam)
7109 unformat_input_t *i = vam->input;
7110 vl_api_bridge_flags_t *mp;
7114 bd_flags_t flags = 0;
7117 /* Parse args required to build the message */
7118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7120 if (unformat (i, "bd_id %d", &bd_id))
7122 else if (unformat (i, "learn"))
7123 flags |= BRIDGE_API_FLAG_LEARN;
7124 else if (unformat (i, "forward"))
7125 flags |= BRIDGE_API_FLAG_FWD;
7126 else if (unformat (i, "flood"))
7127 flags |= BRIDGE_API_FLAG_FLOOD;
7128 else if (unformat (i, "uu-flood"))
7129 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7130 else if (unformat (i, "arp-term"))
7131 flags |= BRIDGE_API_FLAG_ARP_TERM;
7132 else if (unformat (i, "off"))
7134 else if (unformat (i, "disable"))
7142 errmsg ("missing bridge domain");
7146 M (BRIDGE_FLAGS, mp);
7148 mp->bd_id = ntohl (bd_id);
7149 mp->flags = ntohl (flags);
7150 mp->is_set = is_set;
7158 api_bd_ip_mac_add_del (vat_main_t * vam)
7160 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7161 vl_api_mac_address_t mac = { 0 };
7162 unformat_input_t *i = vam->input;
7163 vl_api_bd_ip_mac_add_del_t *mp;
7172 /* Parse args required to build the message */
7173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7175 if (unformat (i, "bd_id %d", &bd_id))
7179 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7183 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7187 else if (unformat (i, "del"))
7195 errmsg ("missing bridge domain");
7198 else if (ip_set == 0)
7200 errmsg ("missing IP address");
7203 else if (mac_set == 0)
7205 errmsg ("missing MAC address");
7209 M (BD_IP_MAC_ADD_DEL, mp);
7211 mp->entry.bd_id = ntohl (bd_id);
7212 mp->is_add = is_add;
7214 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7215 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7223 api_bd_ip_mac_flush (vat_main_t * vam)
7225 unformat_input_t *i = vam->input;
7226 vl_api_bd_ip_mac_flush_t *mp;
7231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7233 if (unformat (i, "bd_id %d", &bd_id))
7243 errmsg ("missing bridge domain");
7247 M (BD_IP_MAC_FLUSH, mp);
7249 mp->bd_id = ntohl (bd_id);
7256 static void vl_api_bd_ip_mac_details_t_handler
7257 (vl_api_bd_ip_mac_details_t * mp)
7259 vat_main_t *vam = &vat_main;
7263 ntohl (mp->entry.bd_id),
7264 format_vl_api_mac_address, mp->entry.mac,
7265 format_vl_api_address, &mp->entry.ip);
7268 static void vl_api_bd_ip_mac_details_t_handler_json
7269 (vl_api_bd_ip_mac_details_t * mp)
7271 vat_main_t *vam = &vat_main;
7272 vat_json_node_t *node = NULL;
7274 if (VAT_JSON_ARRAY != vam->json_tree.type)
7276 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7277 vat_json_init_array (&vam->json_tree);
7279 node = vat_json_array_add (&vam->json_tree);
7281 vat_json_init_object (node);
7282 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7283 vat_json_object_add_string_copy (node, "mac_address",
7284 format (0, "%U", format_vl_api_mac_address,
7288 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7289 vat_json_object_add_string_copy (node, "ip_address", ip);
7294 api_bd_ip_mac_dump (vat_main_t * vam)
7296 unformat_input_t *i = vam->input;
7297 vl_api_bd_ip_mac_dump_t *mp;
7298 vl_api_control_ping_t *mp_ping;
7303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7305 if (unformat (i, "bd_id %d", &bd_id))
7314 "\n%-5s %-7s %-20s %-30s",
7315 "bd_id", "is_ipv6", "mac_address", "ip_address");
7317 /* Dump Bridge Domain Ip to Mac entries */
7318 M (BD_IP_MAC_DUMP, mp);
7321 mp->bd_id = htonl (bd_id);
7327 /* Use a control ping for synchronization */
7328 MPING (CONTROL_PING, mp_ping);
7336 api_tap_create_v2 (vat_main_t * vam)
7338 unformat_input_t *i = vam->input;
7339 vl_api_tap_create_v2_t *mp;
7340 #define TAP_FLAG_GSO (1 << 0)
7344 u8 *host_if_name = 0;
7346 u8 host_mac_addr[6];
7347 u8 host_mac_addr_set = 0;
7348 u8 *host_bridge = 0;
7349 ip4_address_t host_ip4_addr;
7350 ip4_address_t host_ip4_gw;
7351 u8 host_ip4_gw_set = 0;
7352 u32 host_ip4_prefix_len = 0;
7353 ip6_address_t host_ip6_addr;
7354 ip6_address_t host_ip6_gw;
7355 u8 host_ip6_gw_set = 0;
7356 u32 host_ip6_prefix_len = 0;
7357 u8 host_mtu_set = 0;
7358 u32 host_mtu_size = 0;
7361 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7363 clib_memset (mac_address, 0, sizeof (mac_address));
7365 /* Parse args required to build the message */
7366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7368 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7372 else if (unformat (i, "id %u", &id))
7374 else if (unformat (i, "host-if-name %s", &host_if_name))
7376 else if (unformat (i, "host-ns %s", &host_ns))
7378 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7380 host_mac_addr_set = 1;
7381 else if (unformat (i, "host-bridge %s", &host_bridge))
7383 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7384 &host_ip4_addr, &host_ip4_prefix_len))
7386 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7387 &host_ip6_addr, &host_ip6_prefix_len))
7389 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7391 host_ip4_gw_set = 1;
7392 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7394 host_ip6_gw_set = 1;
7395 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7397 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7399 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7401 else if (unformat (i, "no-gso"))
7402 tap_flags &= ~TAP_FLAG_GSO;
7403 else if (unformat (i, "gso"))
7404 tap_flags |= TAP_FLAG_GSO;
7409 if (vec_len (host_if_name) > 63)
7411 errmsg ("tap name too long. ");
7414 if (vec_len (host_ns) > 63)
7416 errmsg ("host name space too long. ");
7419 if (vec_len (host_bridge) > 63)
7421 errmsg ("host bridge name too long. ");
7424 if (host_ip4_prefix_len > 32)
7426 errmsg ("host ip4 prefix length not valid. ");
7429 if (host_ip6_prefix_len > 128)
7431 errmsg ("host ip6 prefix length not valid. ");
7434 if (!is_pow2 (rx_ring_sz))
7436 errmsg ("rx ring size must be power of 2. ");
7439 if (rx_ring_sz > 32768)
7441 errmsg ("rx ring size must be 32768 or lower. ");
7444 if (!is_pow2 (tx_ring_sz))
7446 errmsg ("tx ring size must be power of 2. ");
7449 if (tx_ring_sz > 32768)
7451 errmsg ("tx ring size must be 32768 or lower. ");
7454 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7456 errmsg ("host MTU size must be in between 64 and 65355. ");
7460 /* Construct the API message */
7461 M (TAP_CREATE_V2, mp);
7463 mp->use_random_mac = random_mac;
7465 mp->id = ntohl (id);
7466 mp->host_namespace_set = host_ns != 0;
7467 mp->host_bridge_set = host_bridge != 0;
7468 mp->host_ip4_prefix_set = host_ip4_prefix_len != 0;
7469 mp->host_ip6_prefix_set = host_ip6_prefix_len != 0;
7470 mp->rx_ring_sz = ntohs (rx_ring_sz);
7471 mp->tx_ring_sz = ntohs (tx_ring_sz);
7472 mp->host_mtu_set = host_mtu_set;
7473 mp->host_mtu_size = ntohl (host_mtu_size);
7474 mp->tap_flags = ntohl (tap_flags);
7476 if (random_mac == 0)
7477 clib_memcpy (mp->mac_address, mac_address, 6);
7478 if (host_mac_addr_set)
7479 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7481 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7483 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7485 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7486 if (host_ip4_prefix_len)
7487 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7488 if (host_ip6_prefix_len)
7489 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7490 if (host_ip4_gw_set)
7491 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7492 if (host_ip6_gw_set)
7493 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7496 vec_free (host_if_name);
7497 vec_free (host_bridge);
7502 /* Wait for a reply... */
7508 api_tap_delete_v2 (vat_main_t * vam)
7510 unformat_input_t *i = vam->input;
7511 vl_api_tap_delete_v2_t *mp;
7512 u32 sw_if_index = ~0;
7513 u8 sw_if_index_set = 0;
7516 /* Parse args required to build the message */
7517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7519 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7520 sw_if_index_set = 1;
7521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7522 sw_if_index_set = 1;
7527 if (sw_if_index_set == 0)
7529 errmsg ("missing vpp interface name. ");
7533 /* Construct the API message */
7534 M (TAP_DELETE_V2, mp);
7536 mp->sw_if_index = ntohl (sw_if_index);
7541 /* Wait for a reply... */
7547 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7549 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7552 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7555 addr->domain = x[0];
7558 addr->function = x[3];
7564 api_virtio_pci_create (vat_main_t * vam)
7566 unformat_input_t *i = vam->input;
7567 vl_api_virtio_pci_create_t *mp;
7572 u64 features = (u64) ~ (0ULL);
7575 clib_memset (mac_address, 0, sizeof (mac_address));
7577 /* Parse args required to build the message */
7578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7580 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7584 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7586 else if (unformat (i, "features 0x%llx", &features))
7588 else if (unformat (i, "gso-enabled"))
7596 errmsg ("pci address must be non zero. ");
7600 /* Construct the API message */
7601 M (VIRTIO_PCI_CREATE, mp);
7603 mp->use_random_mac = random_mac;
7605 mp->pci_addr = htonl (pci_addr);
7606 mp->features = clib_host_to_net_u64 (features);
7607 mp->gso_enabled = gso_enabled;
7609 if (random_mac == 0)
7610 clib_memcpy (mp->mac_address, mac_address, 6);
7615 /* Wait for a reply... */
7621 api_virtio_pci_delete (vat_main_t * vam)
7623 unformat_input_t *i = vam->input;
7624 vl_api_virtio_pci_delete_t *mp;
7625 u32 sw_if_index = ~0;
7626 u8 sw_if_index_set = 0;
7629 /* Parse args required to build the message */
7630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7632 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7633 sw_if_index_set = 1;
7634 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7635 sw_if_index_set = 1;
7640 if (sw_if_index_set == 0)
7642 errmsg ("missing vpp interface name. ");
7646 /* Construct the API message */
7647 M (VIRTIO_PCI_DELETE, mp);
7649 mp->sw_if_index = htonl (sw_if_index);
7654 /* Wait for a reply... */
7660 api_bond_create (vat_main_t * vam)
7662 unformat_input_t *i = vam->input;
7663 vl_api_bond_create_t *mp;
7673 clib_memset (mac_address, 0, sizeof (mac_address));
7676 /* Parse args required to build the message */
7677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7679 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7681 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7682 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7684 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7687 else if (unformat (i, "numa-only"))
7689 else if (unformat (i, "id %u", &id))
7695 if (mode_is_set == 0)
7697 errmsg ("Missing bond mode. ");
7701 /* Construct the API message */
7702 M (BOND_CREATE, mp);
7704 mp->use_custom_mac = custom_mac;
7706 mp->mode = htonl (mode);
7707 mp->lb = htonl (lb);
7708 mp->id = htonl (id);
7709 mp->numa_only = numa_only;
7712 clib_memcpy (mp->mac_address, mac_address, 6);
7717 /* Wait for a reply... */
7723 api_bond_delete (vat_main_t * vam)
7725 unformat_input_t *i = vam->input;
7726 vl_api_bond_delete_t *mp;
7727 u32 sw_if_index = ~0;
7728 u8 sw_if_index_set = 0;
7731 /* Parse args required to build the message */
7732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7734 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7735 sw_if_index_set = 1;
7736 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7737 sw_if_index_set = 1;
7742 if (sw_if_index_set == 0)
7744 errmsg ("missing vpp interface name. ");
7748 /* Construct the API message */
7749 M (BOND_DELETE, mp);
7751 mp->sw_if_index = ntohl (sw_if_index);
7756 /* Wait for a reply... */
7762 api_bond_enslave (vat_main_t * vam)
7764 unformat_input_t *i = vam->input;
7765 vl_api_bond_enslave_t *mp;
7766 u32 bond_sw_if_index;
7770 u32 bond_sw_if_index_is_set = 0;
7772 u8 sw_if_index_is_set = 0;
7774 /* Parse args required to build the message */
7775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7777 if (unformat (i, "sw_if_index %d", &sw_if_index))
7778 sw_if_index_is_set = 1;
7779 else if (unformat (i, "bond %u", &bond_sw_if_index))
7780 bond_sw_if_index_is_set = 1;
7781 else if (unformat (i, "passive %d", &is_passive))
7783 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7789 if (bond_sw_if_index_is_set == 0)
7791 errmsg ("Missing bond sw_if_index. ");
7794 if (sw_if_index_is_set == 0)
7796 errmsg ("Missing slave sw_if_index. ");
7800 /* Construct the API message */
7801 M (BOND_ENSLAVE, mp);
7803 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7804 mp->sw_if_index = ntohl (sw_if_index);
7805 mp->is_long_timeout = is_long_timeout;
7806 mp->is_passive = is_passive;
7811 /* Wait for a reply... */
7817 api_bond_detach_slave (vat_main_t * vam)
7819 unformat_input_t *i = vam->input;
7820 vl_api_bond_detach_slave_t *mp;
7821 u32 sw_if_index = ~0;
7822 u8 sw_if_index_set = 0;
7825 /* Parse args required to build the message */
7826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7828 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7829 sw_if_index_set = 1;
7830 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7831 sw_if_index_set = 1;
7836 if (sw_if_index_set == 0)
7838 errmsg ("missing vpp interface name. ");
7842 /* Construct the API message */
7843 M (BOND_DETACH_SLAVE, mp);
7845 mp->sw_if_index = ntohl (sw_if_index);
7850 /* Wait for a reply... */
7856 api_ip_table_add_del (vat_main_t * vam)
7858 unformat_input_t *i = vam->input;
7859 vl_api_ip_table_add_del_t *mp;
7865 /* Parse args required to build the message */
7866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7868 if (unformat (i, "ipv6"))
7870 else if (unformat (i, "del"))
7872 else if (unformat (i, "add"))
7874 else if (unformat (i, "table %d", &table_id))
7878 clib_warning ("parse error '%U'", format_unformat_error, i);
7885 errmsg ("missing table-ID");
7889 /* Construct the API message */
7890 M (IP_TABLE_ADD_DEL, mp);
7892 mp->table.table_id = ntohl (table_id);
7893 mp->table.is_ip6 = is_ipv6;
7894 mp->is_add = is_add;
7899 /* Wait for a reply... */
7906 unformat_fib_path (unformat_input_t * input, va_list * args)
7908 vat_main_t *vam = va_arg (*args, vat_main_t *);
7909 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7910 u32 weight, preference;
7911 mpls_label_t out_label;
7913 clib_memset (path, 0, sizeof (*path));
7915 path->sw_if_index = ~0;
7919 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7921 if (unformat (input, "%U %U",
7922 unformat_vl_api_ip4_address,
7923 &path->nh.address.ip4,
7924 api_unformat_sw_if_index, vam, &path->sw_if_index))
7926 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7928 else if (unformat (input, "%U %U",
7929 unformat_vl_api_ip6_address,
7930 &path->nh.address.ip6,
7931 api_unformat_sw_if_index, vam, &path->sw_if_index))
7933 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7935 else if (unformat (input, "weight %u", &weight))
7937 path->weight = weight;
7939 else if (unformat (input, "preference %u", &preference))
7941 path->preference = preference;
7943 else if (unformat (input, "%U next-hop-table %d",
7944 unformat_vl_api_ip4_address,
7945 &path->nh.address.ip4, &path->table_id))
7947 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7949 else if (unformat (input, "%U next-hop-table %d",
7950 unformat_vl_api_ip6_address,
7951 &path->nh.address.ip6, &path->table_id))
7953 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7955 else if (unformat (input, "%U",
7956 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7959 * the recursive next-hops are by default in the default table
7962 path->sw_if_index = ~0;
7963 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7965 else if (unformat (input, "%U",
7966 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7969 * the recursive next-hops are by default in the default table
7972 path->sw_if_index = ~0;
7973 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7975 else if (unformat (input, "resolve-via-host"))
7977 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7979 else if (unformat (input, "resolve-via-attached"))
7981 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7983 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7985 path->type = FIB_API_PATH_TYPE_LOCAL;
7986 path->sw_if_index = ~0;
7987 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7989 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7991 path->type = FIB_API_PATH_TYPE_LOCAL;
7992 path->sw_if_index = ~0;
7993 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7995 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7997 else if (unformat (input, "via-label %d", &path->nh.via_label))
7999 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8000 path->sw_if_index = ~0;
8002 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8004 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8005 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8007 else if (unformat (input, "local"))
8009 path->type = FIB_API_PATH_TYPE_LOCAL;
8011 else if (unformat (input, "out-labels"))
8013 while (unformat (input, "%d", &out_label))
8015 path->label_stack[path->n_labels].label = out_label;
8016 path->label_stack[path->n_labels].is_uniform = 0;
8017 path->label_stack[path->n_labels].ttl = 64;
8021 else if (unformat (input, "via"))
8023 /* new path, back up and return */
8024 unformat_put_input (input);
8025 unformat_put_input (input);
8026 unformat_put_input (input);
8027 unformat_put_input (input);
8036 path->proto = ntohl (path->proto);
8037 path->type = ntohl (path->type);
8038 path->flags = ntohl (path->flags);
8039 path->table_id = ntohl (path->table_id);
8040 path->sw_if_index = ntohl (path->sw_if_index);
8046 api_ip_route_add_del (vat_main_t * vam)
8048 unformat_input_t *i = vam->input;
8049 vl_api_ip_route_add_del_t *mp;
8052 u8 is_multipath = 0;
8055 vl_api_prefix_t pfx = { };
8056 vl_api_fib_path_t paths[8];
8060 u32 random_add_del = 0;
8061 u32 *random_vector = 0;
8062 u32 random_seed = 0xdeaddabe;
8064 /* Parse args required to build the message */
8065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8067 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8069 else if (unformat (i, "del"))
8071 else if (unformat (i, "add"))
8073 else if (unformat (i, "vrf %d", &vrf_id))
8075 else if (unformat (i, "count %d", &count))
8077 else if (unformat (i, "random"))
8079 else if (unformat (i, "multipath"))
8081 else if (unformat (i, "seed %d", &random_seed))
8085 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8088 if (8 == path_count)
8090 errmsg ("max 8 paths");
8096 clib_warning ("parse error '%U'", format_unformat_error, i);
8103 errmsg ("specify a path; via ...");
8106 if (prefix_set == 0)
8108 errmsg ("missing prefix");
8112 /* Generate a pile of unique, random routes */
8115 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8116 u32 this_random_address;
8119 random_hash = hash_create (count, sizeof (uword));
8121 hash_set (random_hash, i->as_u32, 1);
8122 for (j = 0; j <= count; j++)
8126 this_random_address = random_u32 (&random_seed);
8127 this_random_address =
8128 clib_host_to_net_u32 (this_random_address);
8130 while (hash_get (random_hash, this_random_address));
8131 vec_add1 (random_vector, this_random_address);
8132 hash_set (random_hash, this_random_address, 1);
8134 hash_free (random_hash);
8135 set_ip4_address (&pfx.address, random_vector[0]);
8140 /* Turn on async mode */
8141 vam->async_mode = 1;
8142 vam->async_errors = 0;
8143 before = vat_time_now (vam);
8146 for (j = 0; j < count; j++)
8148 /* Construct the API message */
8149 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8151 mp->is_add = is_add;
8152 mp->is_multipath = is_multipath;
8154 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8155 mp->route.table_id = ntohl (vrf_id);
8156 mp->route.n_paths = path_count;
8158 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8161 set_ip4_address (&pfx.address, random_vector[j + 1]);
8163 increment_address (&pfx.address);
8166 /* If we receive SIGTERM, stop now... */
8171 /* When testing multiple add/del ops, use a control-ping to sync */
8174 vl_api_control_ping_t *mp_ping;
8178 /* Shut off async mode */
8179 vam->async_mode = 0;
8181 MPING (CONTROL_PING, mp_ping);
8184 timeout = vat_time_now (vam) + 1.0;
8185 while (vat_time_now (vam) < timeout)
8186 if (vam->result_ready == 1)
8191 if (vam->retval == -99)
8194 if (vam->async_errors > 0)
8196 errmsg ("%d asynchronous errors", vam->async_errors);
8199 vam->async_errors = 0;
8200 after = vat_time_now (vam);
8202 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8206 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8207 count, after - before, count / (after - before));
8213 /* Wait for a reply... */
8218 /* Return the good/bad news */
8219 return (vam->retval);
8223 api_ip_mroute_add_del (vat_main_t * vam)
8225 unformat_input_t *i = vam->input;
8226 u8 path_set = 0, prefix_set = 0, is_add = 1;
8227 vl_api_ip_mroute_add_del_t *mp;
8228 mfib_entry_flags_t eflags = 0;
8229 vl_api_mfib_path_t path;
8230 vl_api_mprefix_t pfx = { };
8234 /* Parse args required to build the message */
8235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8237 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8240 pfx.grp_address_length = htons (pfx.grp_address_length);
8242 else if (unformat (i, "del"))
8244 else if (unformat (i, "add"))
8246 else if (unformat (i, "vrf %d", &vrf_id))
8248 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8249 path.itf_flags = htonl (path.itf_flags);
8250 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8252 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8256 clib_warning ("parse error '%U'", format_unformat_error, i);
8261 if (prefix_set == 0)
8263 errmsg ("missing addresses\n");
8268 errmsg ("missing path\n");
8272 /* Construct the API message */
8273 M (IP_MROUTE_ADD_DEL, mp);
8275 mp->is_add = is_add;
8276 mp->is_multipath = 1;
8278 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8279 mp->route.table_id = htonl (vrf_id);
8280 mp->route.n_paths = 1;
8281 mp->route.entry_flags = htonl (eflags);
8283 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8287 /* Wait for a reply... */
8293 api_mpls_table_add_del (vat_main_t * vam)
8295 unformat_input_t *i = vam->input;
8296 vl_api_mpls_table_add_del_t *mp;
8301 /* Parse args required to build the message */
8302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8304 if (unformat (i, "table %d", &table_id))
8306 else if (unformat (i, "del"))
8308 else if (unformat (i, "add"))
8312 clib_warning ("parse error '%U'", format_unformat_error, i);
8319 errmsg ("missing table-ID");
8323 /* Construct the API message */
8324 M (MPLS_TABLE_ADD_DEL, mp);
8326 mp->mt_table.mt_table_id = ntohl (table_id);
8327 mp->mt_is_add = is_add;
8332 /* Wait for a reply... */
8339 api_mpls_route_add_del (vat_main_t * vam)
8341 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8342 mpls_label_t local_label = MPLS_LABEL_INVALID;
8343 unformat_input_t *i = vam->input;
8344 vl_api_mpls_route_add_del_t *mp;
8345 vl_api_fib_path_t paths[8];
8349 /* Parse args required to build the message */
8350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8352 if (unformat (i, "%d", &local_label))
8354 else if (unformat (i, "eos"))
8356 else if (unformat (i, "non-eos"))
8358 else if (unformat (i, "del"))
8360 else if (unformat (i, "add"))
8362 else if (unformat (i, "multipath"))
8364 else if (unformat (i, "count %d", &count))
8368 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8371 if (8 == path_count)
8373 errmsg ("max 8 paths");
8379 clib_warning ("parse error '%U'", format_unformat_error, i);
8386 errmsg ("specify a path; via ...");
8390 if (MPLS_LABEL_INVALID == local_label)
8392 errmsg ("missing label");
8398 /* Turn on async mode */
8399 vam->async_mode = 1;
8400 vam->async_errors = 0;
8401 before = vat_time_now (vam);
8404 for (j = 0; j < count; j++)
8406 /* Construct the API message */
8407 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8409 mp->mr_is_add = is_add;
8410 mp->mr_is_multipath = is_multipath;
8412 mp->mr_route.mr_label = local_label;
8413 mp->mr_route.mr_eos = is_eos;
8414 mp->mr_route.mr_table_id = 0;
8415 mp->mr_route.mr_n_paths = path_count;
8417 clib_memcpy (&mp->mr_route.mr_paths, paths,
8418 sizeof (paths[0]) * path_count);
8424 /* If we receive SIGTERM, stop now... */
8429 /* When testing multiple add/del ops, use a control-ping to sync */
8432 vl_api_control_ping_t *mp_ping;
8436 /* Shut off async mode */
8437 vam->async_mode = 0;
8439 MPING (CONTROL_PING, mp_ping);
8442 timeout = vat_time_now (vam) + 1.0;
8443 while (vat_time_now (vam) < timeout)
8444 if (vam->result_ready == 1)
8449 if (vam->retval == -99)
8452 if (vam->async_errors > 0)
8454 errmsg ("%d asynchronous errors", vam->async_errors);
8457 vam->async_errors = 0;
8458 after = vat_time_now (vam);
8460 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8464 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8465 count, after - before, count / (after - before));
8471 /* Wait for a reply... */
8476 /* Return the good/bad news */
8477 return (vam->retval);
8482 api_mpls_ip_bind_unbind (vat_main_t * vam)
8484 unformat_input_t *i = vam->input;
8485 vl_api_mpls_ip_bind_unbind_t *mp;
8486 u32 ip_table_id = 0;
8488 vl_api_prefix_t pfx;
8490 mpls_label_t local_label = MPLS_LABEL_INVALID;
8493 /* Parse args required to build the message */
8494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8496 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8498 else if (unformat (i, "%d", &local_label))
8500 else if (unformat (i, "table-id %d", &ip_table_id))
8502 else if (unformat (i, "unbind"))
8504 else if (unformat (i, "bind"))
8508 clib_warning ("parse error '%U'", format_unformat_error, i);
8515 errmsg ("IP prefix not set");
8519 if (MPLS_LABEL_INVALID == local_label)
8521 errmsg ("missing label");
8525 /* Construct the API message */
8526 M (MPLS_IP_BIND_UNBIND, mp);
8528 mp->mb_is_bind = is_bind;
8529 mp->mb_ip_table_id = ntohl (ip_table_id);
8530 mp->mb_mpls_table_id = 0;
8531 mp->mb_label = ntohl (local_label);
8532 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8537 /* Wait for a reply... */
8544 api_sr_mpls_policy_add (vat_main_t * vam)
8546 unformat_input_t *i = vam->input;
8547 vl_api_sr_mpls_policy_add_t *mp;
8553 u32 *segments = NULL;
8556 /* Parse args required to build the message */
8557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8559 if (unformat (i, "bsid %d", &bsid))
8561 else if (unformat (i, "weight %d", &weight))
8563 else if (unformat (i, "spray"))
8565 else if (unformat (i, "next %d", &sid))
8568 vec_add1 (segments, htonl (sid));
8572 clib_warning ("parse error '%U'", format_unformat_error, i);
8579 errmsg ("bsid not set");
8583 if (n_segments == 0)
8585 errmsg ("no sid in segment stack");
8589 /* Construct the API message */
8590 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8592 mp->bsid = htonl (bsid);
8593 mp->weight = htonl (weight);
8595 mp->n_segments = n_segments;
8596 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8597 vec_free (segments);
8602 /* Wait for a reply... */
8608 api_sr_mpls_policy_del (vat_main_t * vam)
8610 unformat_input_t *i = vam->input;
8611 vl_api_sr_mpls_policy_del_t *mp;
8615 /* Parse args required to build the message */
8616 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8618 if (unformat (i, "bsid %d", &bsid))
8622 clib_warning ("parse error '%U'", format_unformat_error, i);
8629 errmsg ("bsid not set");
8633 /* Construct the API message */
8634 M (SR_MPLS_POLICY_DEL, mp);
8636 mp->bsid = htonl (bsid);
8641 /* Wait for a reply... */
8647 api_bier_table_add_del (vat_main_t * vam)
8649 unformat_input_t *i = vam->input;
8650 vl_api_bier_table_add_del_t *mp;
8652 u32 set = 0, sub_domain = 0, hdr_len = 3;
8653 mpls_label_t local_label = MPLS_LABEL_INVALID;
8656 /* Parse args required to build the message */
8657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8659 if (unformat (i, "sub-domain %d", &sub_domain))
8661 else if (unformat (i, "set %d", &set))
8663 else if (unformat (i, "label %d", &local_label))
8665 else if (unformat (i, "hdr-len %d", &hdr_len))
8667 else if (unformat (i, "add"))
8669 else if (unformat (i, "del"))
8673 clib_warning ("parse error '%U'", format_unformat_error, i);
8678 if (MPLS_LABEL_INVALID == local_label)
8680 errmsg ("missing label\n");
8684 /* Construct the API message */
8685 M (BIER_TABLE_ADD_DEL, mp);
8687 mp->bt_is_add = is_add;
8688 mp->bt_label = ntohl (local_label);
8689 mp->bt_tbl_id.bt_set = set;
8690 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8691 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8696 /* Wait for a reply... */
8703 api_bier_route_add_del (vat_main_t * vam)
8705 unformat_input_t *i = vam->input;
8706 vl_api_bier_route_add_del_t *mp;
8708 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8709 ip4_address_t v4_next_hop_address;
8710 ip6_address_t v6_next_hop_address;
8711 u8 next_hop_set = 0;
8712 u8 next_hop_proto_is_ip4 = 1;
8713 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8716 /* Parse args required to build the message */
8717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8719 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8721 next_hop_proto_is_ip4 = 1;
8724 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8726 next_hop_proto_is_ip4 = 0;
8729 if (unformat (i, "sub-domain %d", &sub_domain))
8731 else if (unformat (i, "set %d", &set))
8733 else if (unformat (i, "hdr-len %d", &hdr_len))
8735 else if (unformat (i, "bp %d", &bp))
8737 else if (unformat (i, "add"))
8739 else if (unformat (i, "del"))
8741 else if (unformat (i, "out-label %d", &next_hop_out_label))
8745 clib_warning ("parse error '%U'", format_unformat_error, i);
8750 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8752 errmsg ("next hop / label set\n");
8757 errmsg ("bit=position not set\n");
8761 /* Construct the API message */
8762 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8764 mp->br_is_add = is_add;
8765 mp->br_route.br_tbl_id.bt_set = set;
8766 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8767 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8768 mp->br_route.br_bp = ntohs (bp);
8769 mp->br_route.br_n_paths = 1;
8770 mp->br_route.br_paths[0].n_labels = 1;
8771 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8772 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8773 FIB_API_PATH_NH_PROTO_IP4 :
8774 FIB_API_PATH_NH_PROTO_IP6);
8776 if (next_hop_proto_is_ip4)
8778 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8779 &v4_next_hop_address, sizeof (v4_next_hop_address));
8783 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8784 &v6_next_hop_address, sizeof (v6_next_hop_address));
8790 /* Wait for a reply... */
8797 api_proxy_arp_add_del (vat_main_t * vam)
8799 unformat_input_t *i = vam->input;
8800 vl_api_proxy_arp_add_del_t *mp;
8803 vl_api_ip4_address_t lo, hi;
8807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8809 if (unformat (i, "vrf %d", &vrf_id))
8811 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
8812 unformat_vl_api_ip4_address, &hi))
8814 else if (unformat (i, "del"))
8818 clib_warning ("parse error '%U'", format_unformat_error, i);
8825 errmsg ("address range not set");
8829 M (PROXY_ARP_ADD_DEL, mp);
8831 mp->proxy.table_id = ntohl (vrf_id);
8832 mp->is_add = is_add;
8833 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
8834 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
8842 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8844 unformat_input_t *i = vam->input;
8845 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8848 u8 sw_if_index_set = 0;
8851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8853 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8854 sw_if_index_set = 1;
8855 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8856 sw_if_index_set = 1;
8857 else if (unformat (i, "enable"))
8859 else if (unformat (i, "disable"))
8863 clib_warning ("parse error '%U'", format_unformat_error, i);
8868 if (sw_if_index_set == 0)
8870 errmsg ("missing interface name or sw_if_index");
8874 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8876 mp->sw_if_index = ntohl (sw_if_index);
8877 mp->enable_disable = enable;
8885 api_mpls_tunnel_add_del (vat_main_t * vam)
8887 unformat_input_t *i = vam->input;
8888 vl_api_mpls_tunnel_add_del_t *mp;
8890 vl_api_fib_path_t paths[8];
8891 u32 sw_if_index = ~0;
8897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8899 if (unformat (i, "add"))
8903 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8905 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8907 else if (unformat (i, "l2-only"))
8911 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8914 if (8 == path_count)
8916 errmsg ("max 8 paths");
8922 clib_warning ("parse error '%U'", format_unformat_error, i);
8927 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8929 mp->mt_is_add = is_add;
8930 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8931 mp->mt_tunnel.mt_l2_only = l2_only;
8932 mp->mt_tunnel.mt_is_multicast = 0;
8933 mp->mt_tunnel.mt_n_paths = path_count;
8935 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8936 sizeof (paths[0]) * path_count);
8944 api_sw_interface_set_unnumbered (vat_main_t * vam)
8946 unformat_input_t *i = vam->input;
8947 vl_api_sw_interface_set_unnumbered_t *mp;
8949 u32 unnum_sw_index = ~0;
8951 u8 sw_if_index_set = 0;
8954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8956 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8957 sw_if_index_set = 1;
8958 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8959 sw_if_index_set = 1;
8960 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8962 else if (unformat (i, "del"))
8966 clib_warning ("parse error '%U'", format_unformat_error, i);
8971 if (sw_if_index_set == 0)
8973 errmsg ("missing interface name or sw_if_index");
8977 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8979 mp->sw_if_index = ntohl (sw_if_index);
8980 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8981 mp->is_add = is_add;
8989 api_ip_neighbor_add_del (vat_main_t * vam)
8991 vl_api_mac_address_t mac_address;
8992 unformat_input_t *i = vam->input;
8993 vl_api_ip_neighbor_add_del_t *mp;
8994 vl_api_address_t ip_address;
8996 u8 sw_if_index_set = 0;
9001 ip_neighbor_flags_t flags;
9003 flags = IP_NEIGHBOR_FLAG_NONE;
9004 clib_memset (&ip_address, 0, sizeof (ip_address));
9005 clib_memset (&mac_address, 0, sizeof (mac_address));
9007 /* Parse args required to build the message */
9008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9010 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9014 else if (unformat (i, "del"))
9017 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9018 sw_if_index_set = 1;
9019 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9020 sw_if_index_set = 1;
9021 else if (unformat (i, "static"))
9022 flags |= IP_NEIGHBOR_FLAG_STATIC;
9023 else if (unformat (i, "no-fib-entry"))
9024 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9025 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9029 clib_warning ("parse error '%U'", format_unformat_error, i);
9034 if (sw_if_index_set == 0)
9036 errmsg ("missing interface name or sw_if_index");
9041 errmsg ("no address set");
9045 /* Construct the API message */
9046 M (IP_NEIGHBOR_ADD_DEL, mp);
9048 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9049 mp->is_add = is_add;
9050 mp->neighbor.flags = htonl (flags);
9052 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9053 sizeof (mac_address));
9055 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9060 /* Wait for a reply, return good/bad news */
9066 api_create_vlan_subif (vat_main_t * vam)
9068 unformat_input_t *i = vam->input;
9069 vl_api_create_vlan_subif_t *mp;
9071 u8 sw_if_index_set = 0;
9076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9078 if (unformat (i, "sw_if_index %d", &sw_if_index))
9079 sw_if_index_set = 1;
9081 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9082 sw_if_index_set = 1;
9083 else if (unformat (i, "vlan %d", &vlan_id))
9087 clib_warning ("parse error '%U'", format_unformat_error, i);
9092 if (sw_if_index_set == 0)
9094 errmsg ("missing interface name or sw_if_index");
9098 if (vlan_id_set == 0)
9100 errmsg ("missing vlan_id");
9103 M (CREATE_VLAN_SUBIF, mp);
9105 mp->sw_if_index = ntohl (sw_if_index);
9106 mp->vlan_id = ntohl (vlan_id);
9113 #define foreach_create_subif_bit \
9120 _(outer_vlan_id_any) \
9121 _(inner_vlan_id_any)
9123 #define foreach_create_subif_flag \
9128 _(4, "exact_match") \
9129 _(5, "default_sub") \
9130 _(6, "outer_vlan_id_any") \
9131 _(7, "inner_vlan_id_any")
9134 api_create_subif (vat_main_t * vam)
9136 unformat_input_t *i = vam->input;
9137 vl_api_create_subif_t *mp;
9139 u8 sw_if_index_set = 0;
9142 u32 __attribute__ ((unused)) no_tags = 0;
9143 u32 __attribute__ ((unused)) one_tag = 0;
9144 u32 __attribute__ ((unused)) two_tags = 0;
9145 u32 __attribute__ ((unused)) dot1ad = 0;
9146 u32 __attribute__ ((unused)) exact_match = 0;
9147 u32 __attribute__ ((unused)) default_sub = 0;
9148 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
9149 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
9151 u16 outer_vlan_id = 0;
9152 u16 inner_vlan_id = 0;
9155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9157 if (unformat (i, "sw_if_index %d", &sw_if_index))
9158 sw_if_index_set = 1;
9160 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9161 sw_if_index_set = 1;
9162 else if (unformat (i, "sub_id %d", &sub_id))
9164 else if (unformat (i, "outer_vlan_id %d", &tmp))
9165 outer_vlan_id = tmp;
9166 else if (unformat (i, "inner_vlan_id %d", &tmp))
9167 inner_vlan_id = tmp;
9169 #define _(a) else if (unformat (i, #a)) a = 1 ;
9170 foreach_create_subif_bit
9174 clib_warning ("parse error '%U'", format_unformat_error, i);
9179 if (sw_if_index_set == 0)
9181 errmsg ("missing interface name or sw_if_index");
9185 if (sub_id_set == 0)
9187 errmsg ("missing sub_id");
9190 M (CREATE_SUBIF, mp);
9192 mp->sw_if_index = ntohl (sw_if_index);
9193 mp->sub_id = ntohl (sub_id);
9195 #define _(a,b) mp->sub_if_flags |= (1 << a);
9196 foreach_create_subif_flag;
9199 mp->outer_vlan_id = ntohs (outer_vlan_id);
9200 mp->inner_vlan_id = ntohs (inner_vlan_id);
9208 api_ip_table_replace_begin (vat_main_t * vam)
9210 unformat_input_t *i = vam->input;
9211 vl_api_ip_table_replace_begin_t *mp;
9216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9218 if (unformat (i, "table %d", &table_id))
9220 else if (unformat (i, "ipv6"))
9224 clib_warning ("parse error '%U'", format_unformat_error, i);
9229 M (IP_TABLE_REPLACE_BEGIN, mp);
9231 mp->table.table_id = ntohl (table_id);
9232 mp->table.is_ip6 = is_ipv6;
9240 api_ip_table_flush (vat_main_t * vam)
9242 unformat_input_t *i = vam->input;
9243 vl_api_ip_table_flush_t *mp;
9248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9250 if (unformat (i, "table %d", &table_id))
9252 else if (unformat (i, "ipv6"))
9256 clib_warning ("parse error '%U'", format_unformat_error, i);
9261 M (IP_TABLE_FLUSH, mp);
9263 mp->table.table_id = ntohl (table_id);
9264 mp->table.is_ip6 = is_ipv6;
9272 api_ip_table_replace_end (vat_main_t * vam)
9274 unformat_input_t *i = vam->input;
9275 vl_api_ip_table_replace_end_t *mp;
9280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9282 if (unformat (i, "table %d", &table_id))
9284 else if (unformat (i, "ipv6"))
9288 clib_warning ("parse error '%U'", format_unformat_error, i);
9293 M (IP_TABLE_REPLACE_END, mp);
9295 mp->table.table_id = ntohl (table_id);
9296 mp->table.is_ip6 = is_ipv6;
9304 api_set_ip_flow_hash (vat_main_t * vam)
9306 unformat_input_t *i = vam->input;
9307 vl_api_set_ip_flow_hash_t *mp;
9319 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9321 if (unformat (i, "vrf %d", &vrf_id))
9323 else if (unformat (i, "ipv6"))
9325 else if (unformat (i, "src"))
9327 else if (unformat (i, "dst"))
9329 else if (unformat (i, "sport"))
9331 else if (unformat (i, "dport"))
9333 else if (unformat (i, "proto"))
9335 else if (unformat (i, "reverse"))
9340 clib_warning ("parse error '%U'", format_unformat_error, i);
9345 if (vrf_id_set == 0)
9347 errmsg ("missing vrf id");
9351 M (SET_IP_FLOW_HASH, mp);
9357 mp->reverse = reverse;
9358 mp->vrf_id = ntohl (vrf_id);
9359 mp->is_ipv6 = is_ipv6;
9367 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9369 unformat_input_t *i = vam->input;
9370 vl_api_sw_interface_ip6_enable_disable_t *mp;
9372 u8 sw_if_index_set = 0;
9376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9378 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9379 sw_if_index_set = 1;
9380 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9381 sw_if_index_set = 1;
9382 else if (unformat (i, "enable"))
9384 else if (unformat (i, "disable"))
9388 clib_warning ("parse error '%U'", format_unformat_error, i);
9393 if (sw_if_index_set == 0)
9395 errmsg ("missing interface name or sw_if_index");
9399 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9401 mp->sw_if_index = ntohl (sw_if_index);
9402 mp->enable = enable;
9410 api_ip6nd_proxy_add_del (vat_main_t * vam)
9412 unformat_input_t *i = vam->input;
9413 vl_api_ip6nd_proxy_add_del_t *mp;
9414 u32 sw_if_index = ~0;
9415 u8 v6_address_set = 0;
9416 vl_api_ip6_address_t v6address;
9420 /* Parse args required to build the message */
9421 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9423 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9425 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9427 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
9429 if (unformat (i, "del"))
9433 clib_warning ("parse error '%U'", format_unformat_error, i);
9438 if (sw_if_index == ~0)
9440 errmsg ("missing interface name or sw_if_index");
9443 if (!v6_address_set)
9445 errmsg ("no address set");
9449 /* Construct the API message */
9450 M (IP6ND_PROXY_ADD_DEL, mp);
9452 mp->is_del = is_del;
9453 mp->sw_if_index = ntohl (sw_if_index);
9454 clib_memcpy (mp->ip, v6address, sizeof (v6address));
9459 /* Wait for a reply, return good/bad news */
9465 api_ip6nd_proxy_dump (vat_main_t * vam)
9467 vl_api_ip6nd_proxy_dump_t *mp;
9468 vl_api_control_ping_t *mp_ping;
9471 M (IP6ND_PROXY_DUMP, mp);
9475 /* Use a control ping for synchronization */
9476 MPING (CONTROL_PING, mp_ping);
9483 static void vl_api_ip6nd_proxy_details_t_handler
9484 (vl_api_ip6nd_proxy_details_t * mp)
9486 vat_main_t *vam = &vat_main;
9488 print (vam->ofp, "host %U sw_if_index %d",
9489 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
9492 static void vl_api_ip6nd_proxy_details_t_handler_json
9493 (vl_api_ip6nd_proxy_details_t * mp)
9495 vat_main_t *vam = &vat_main;
9496 struct in6_addr ip6;
9497 vat_json_node_t *node = NULL;
9499 if (VAT_JSON_ARRAY != vam->json_tree.type)
9501 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9502 vat_json_init_array (&vam->json_tree);
9504 node = vat_json_array_add (&vam->json_tree);
9506 vat_json_init_object (node);
9507 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9509 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
9510 vat_json_object_add_ip6 (node, "host", ip6);
9514 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9516 unformat_input_t *i = vam->input;
9517 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9519 u8 sw_if_index_set = 0;
9520 u8 v6_address_set = 0;
9521 vl_api_prefix_t pfx;
9523 u8 no_advertise = 0;
9525 u8 no_autoconfig = 0;
9528 u32 val_lifetime = 0;
9529 u32 pref_lifetime = 0;
9532 /* Parse args required to build the message */
9533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9535 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9536 sw_if_index_set = 1;
9537 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9538 sw_if_index_set = 1;
9539 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9541 else if (unformat (i, "val_life %d", &val_lifetime))
9543 else if (unformat (i, "pref_life %d", &pref_lifetime))
9545 else if (unformat (i, "def"))
9547 else if (unformat (i, "noadv"))
9549 else if (unformat (i, "offl"))
9551 else if (unformat (i, "noauto"))
9553 else if (unformat (i, "nolink"))
9555 else if (unformat (i, "isno"))
9559 clib_warning ("parse error '%U'", format_unformat_error, i);
9564 if (sw_if_index_set == 0)
9566 errmsg ("missing interface name or sw_if_index");
9569 if (!v6_address_set)
9571 errmsg ("no address set");
9575 /* Construct the API message */
9576 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9578 mp->sw_if_index = ntohl (sw_if_index);
9579 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
9580 mp->use_default = use_default;
9581 mp->no_advertise = no_advertise;
9582 mp->off_link = off_link;
9583 mp->no_autoconfig = no_autoconfig;
9584 mp->no_onlink = no_onlink;
9586 mp->val_lifetime = ntohl (val_lifetime);
9587 mp->pref_lifetime = ntohl (pref_lifetime);
9592 /* Wait for a reply, return good/bad news */
9598 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9600 unformat_input_t *i = vam->input;
9601 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9603 u8 sw_if_index_set = 0;
9608 u8 send_unicast = 0;
9611 u8 default_router = 0;
9612 u32 max_interval = 0;
9613 u32 min_interval = 0;
9615 u32 initial_count = 0;
9616 u32 initial_interval = 0;
9620 /* Parse args required to build the message */
9621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9623 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9624 sw_if_index_set = 1;
9625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9626 sw_if_index_set = 1;
9627 else if (unformat (i, "maxint %d", &max_interval))
9629 else if (unformat (i, "minint %d", &min_interval))
9631 else if (unformat (i, "life %d", &lifetime))
9633 else if (unformat (i, "count %d", &initial_count))
9635 else if (unformat (i, "interval %d", &initial_interval))
9637 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9639 else if (unformat (i, "managed"))
9641 else if (unformat (i, "other"))
9643 else if (unformat (i, "ll"))
9645 else if (unformat (i, "send"))
9647 else if (unformat (i, "cease"))
9649 else if (unformat (i, "isno"))
9651 else if (unformat (i, "def"))
9655 clib_warning ("parse error '%U'", format_unformat_error, i);
9660 if (sw_if_index_set == 0)
9662 errmsg ("missing interface name or sw_if_index");
9666 /* Construct the API message */
9667 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9669 mp->sw_if_index = ntohl (sw_if_index);
9670 mp->max_interval = ntohl (max_interval);
9671 mp->min_interval = ntohl (min_interval);
9672 mp->lifetime = ntohl (lifetime);
9673 mp->initial_count = ntohl (initial_count);
9674 mp->initial_interval = ntohl (initial_interval);
9675 mp->suppress = suppress;
9676 mp->managed = managed;
9678 mp->ll_option = ll_option;
9679 mp->send_unicast = send_unicast;
9682 mp->default_router = default_router;
9687 /* Wait for a reply, return good/bad news */
9693 api_set_arp_neighbor_limit (vat_main_t * vam)
9695 unformat_input_t *i = vam->input;
9696 vl_api_set_arp_neighbor_limit_t *mp;
9702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9704 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9706 else if (unformat (i, "ipv6"))
9710 clib_warning ("parse error '%U'", format_unformat_error, i);
9717 errmsg ("missing limit value");
9721 M (SET_ARP_NEIGHBOR_LIMIT, mp);
9723 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
9724 mp->is_ipv6 = is_ipv6;
9732 api_l2_patch_add_del (vat_main_t * vam)
9734 unformat_input_t *i = vam->input;
9735 vl_api_l2_patch_add_del_t *mp;
9737 u8 rx_sw_if_index_set = 0;
9739 u8 tx_sw_if_index_set = 0;
9743 /* Parse args required to build the message */
9744 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9746 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9747 rx_sw_if_index_set = 1;
9748 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9749 tx_sw_if_index_set = 1;
9750 else if (unformat (i, "rx"))
9752 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9754 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9756 rx_sw_if_index_set = 1;
9761 else if (unformat (i, "tx"))
9763 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9765 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9767 tx_sw_if_index_set = 1;
9772 else if (unformat (i, "del"))
9778 if (rx_sw_if_index_set == 0)
9780 errmsg ("missing rx interface name or rx_sw_if_index");
9784 if (tx_sw_if_index_set == 0)
9786 errmsg ("missing tx interface name or tx_sw_if_index");
9790 M (L2_PATCH_ADD_DEL, mp);
9792 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9793 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9794 mp->is_add = is_add;
9802 u8 localsid_addr[16];
9811 api_sr_localsid_add_del (vat_main_t * vam)
9813 unformat_input_t *i = vam->input;
9814 vl_api_sr_localsid_add_del_t *mp;
9817 ip6_address_t localsid;
9821 u32 fib_table = ~(u32) 0;
9822 ip6_address_t nh_addr6;
9823 ip4_address_t nh_addr4;
9824 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9825 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9827 bool nexthop_set = 0;
9831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9833 if (unformat (i, "del"))
9835 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9836 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9838 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9840 else if (unformat (i, "behavior %u", &behavior));
9841 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9842 else if (unformat (i, "fib-table %u", &fib_table));
9843 else if (unformat (i, "end.psp %u", &behavior));
9848 M (SR_LOCALSID_ADD_DEL, mp);
9850 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9854 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9855 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9857 mp->behavior = behavior;
9858 mp->sw_if_index = ntohl (sw_if_index);
9859 mp->fib_table = ntohl (fib_table);
9860 mp->end_psp = end_psp;
9861 mp->is_del = is_del;
9869 api_ioam_enable (vat_main_t * vam)
9871 unformat_input_t *input = vam->input;
9872 vl_api_ioam_enable_t *mp;
9874 int has_trace_option = 0;
9875 int has_pot_option = 0;
9876 int has_seqno_option = 0;
9877 int has_analyse_option = 0;
9880 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9882 if (unformat (input, "trace"))
9883 has_trace_option = 1;
9884 else if (unformat (input, "pot"))
9886 else if (unformat (input, "seqno"))
9887 has_seqno_option = 1;
9888 else if (unformat (input, "analyse"))
9889 has_analyse_option = 1;
9893 M (IOAM_ENABLE, mp);
9894 mp->id = htons (id);
9895 mp->seqno = has_seqno_option;
9896 mp->analyse = has_analyse_option;
9897 mp->pot_enable = has_pot_option;
9898 mp->trace_enable = has_trace_option;
9907 api_ioam_disable (vat_main_t * vam)
9909 vl_api_ioam_disable_t *mp;
9912 M (IOAM_DISABLE, mp);
9918 #define foreach_tcp_proto_field \
9922 #define foreach_udp_proto_field \
9926 #define foreach_ip4_proto_field \
9938 u16 src_port, dst_port;
9941 #if VPP_API_TEST_BUILTIN == 0
9943 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9945 u8 **maskp = va_arg (*args, u8 **);
9947 u8 found_something = 0;
9950 #define _(a) u8 a=0;
9951 foreach_tcp_proto_field;
9954 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9957 #define _(a) else if (unformat (input, #a)) a=1;
9958 foreach_tcp_proto_field
9964 #define _(a) found_something += a;
9965 foreach_tcp_proto_field;
9968 if (found_something == 0)
9971 vec_validate (mask, sizeof (*tcp) - 1);
9973 tcp = (tcp_header_t *) mask;
9975 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9976 foreach_tcp_proto_field;
9984 unformat_udp_mask (unformat_input_t * input, va_list * args)
9986 u8 **maskp = va_arg (*args, u8 **);
9988 u8 found_something = 0;
9991 #define _(a) u8 a=0;
9992 foreach_udp_proto_field;
9995 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9998 #define _(a) else if (unformat (input, #a)) a=1;
9999 foreach_udp_proto_field
10005 #define _(a) found_something += a;
10006 foreach_udp_proto_field;
10009 if (found_something == 0)
10012 vec_validate (mask, sizeof (*udp) - 1);
10014 udp = (udp_header_t *) mask;
10016 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10017 foreach_udp_proto_field;
10025 unformat_l4_mask (unformat_input_t * input, va_list * args)
10027 u8 **maskp = va_arg (*args, u8 **);
10028 u16 src_port = 0, dst_port = 0;
10029 tcpudp_header_t *tcpudp;
10031 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10033 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10035 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10037 else if (unformat (input, "src_port"))
10039 else if (unformat (input, "dst_port"))
10045 if (!src_port && !dst_port)
10049 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10051 tcpudp = (tcpudp_header_t *) mask;
10052 tcpudp->src_port = src_port;
10053 tcpudp->dst_port = dst_port;
10061 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10063 u8 **maskp = va_arg (*args, u8 **);
10065 u8 found_something = 0;
10068 #define _(a) u8 a=0;
10069 foreach_ip4_proto_field;
10075 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10077 if (unformat (input, "version"))
10079 else if (unformat (input, "hdr_length"))
10081 else if (unformat (input, "src"))
10083 else if (unformat (input, "dst"))
10085 else if (unformat (input, "proto"))
10088 #define _(a) else if (unformat (input, #a)) a=1;
10089 foreach_ip4_proto_field
10095 #define _(a) found_something += a;
10096 foreach_ip4_proto_field;
10099 if (found_something == 0)
10102 vec_validate (mask, sizeof (*ip) - 1);
10104 ip = (ip4_header_t *) mask;
10106 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10107 foreach_ip4_proto_field;
10110 ip->ip_version_and_header_length = 0;
10113 ip->ip_version_and_header_length |= 0xF0;
10116 ip->ip_version_and_header_length |= 0x0F;
10122 #define foreach_ip6_proto_field \
10125 _(payload_length) \
10130 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10132 u8 **maskp = va_arg (*args, u8 **);
10134 u8 found_something = 0;
10136 u32 ip_version_traffic_class_and_flow_label;
10138 #define _(a) u8 a=0;
10139 foreach_ip6_proto_field;
10142 u8 traffic_class = 0;
10145 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10147 if (unformat (input, "version"))
10149 else if (unformat (input, "traffic-class"))
10151 else if (unformat (input, "flow-label"))
10153 else if (unformat (input, "src"))
10155 else if (unformat (input, "dst"))
10157 else if (unformat (input, "proto"))
10160 #define _(a) else if (unformat (input, #a)) a=1;
10161 foreach_ip6_proto_field
10167 #define _(a) found_something += a;
10168 foreach_ip6_proto_field;
10171 if (found_something == 0)
10174 vec_validate (mask, sizeof (*ip) - 1);
10176 ip = (ip6_header_t *) mask;
10178 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10179 foreach_ip6_proto_field;
10182 ip_version_traffic_class_and_flow_label = 0;
10185 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10188 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10191 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10193 ip->ip_version_traffic_class_and_flow_label =
10194 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10201 unformat_l3_mask (unformat_input_t * input, va_list * args)
10203 u8 **maskp = va_arg (*args, u8 **);
10205 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10207 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10209 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10218 unformat_l2_mask (unformat_input_t * input, va_list * args)
10220 u8 **maskp = va_arg (*args, u8 **);
10227 u8 ignore_tag1 = 0;
10228 u8 ignore_tag2 = 0;
10235 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10237 if (unformat (input, "src"))
10239 else if (unformat (input, "dst"))
10241 else if (unformat (input, "proto"))
10243 else if (unformat (input, "tag1"))
10245 else if (unformat (input, "tag2"))
10247 else if (unformat (input, "ignore-tag1"))
10249 else if (unformat (input, "ignore-tag2"))
10251 else if (unformat (input, "cos1"))
10253 else if (unformat (input, "cos2"))
10255 else if (unformat (input, "dot1q"))
10257 else if (unformat (input, "dot1ad"))
10262 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10263 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10266 if (tag1 || ignore_tag1 || cos1 || dot1q)
10268 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10271 vec_validate (mask, len - 1);
10274 clib_memset (mask, 0xff, 6);
10277 clib_memset (mask + 6, 0xff, 6);
10279 if (tag2 || dot1ad)
10281 /* inner vlan tag */
10290 mask[21] = mask[20] = 0xff;
10311 mask[16] = mask[17] = 0xff;
10321 mask[12] = mask[13] = 0xff;
10328 unformat_classify_mask (unformat_input_t * input, va_list * args)
10330 u8 **maskp = va_arg (*args, u8 **);
10331 u32 *skipp = va_arg (*args, u32 *);
10332 u32 *matchp = va_arg (*args, u32 *);
10340 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10342 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10344 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10346 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10348 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10362 if (mask || l2 || l3 || l4)
10364 if (l2 || l3 || l4)
10366 /* "With a free Ethernet header in every package" */
10368 vec_validate (l2, 13);
10372 vec_append (mask, l3);
10377 vec_append (mask, l4);
10382 /* Scan forward looking for the first significant mask octet */
10383 for (i = 0; i < vec_len (mask); i++)
10387 /* compute (skip, match) params */
10388 *skipp = i / sizeof (u32x4);
10389 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10391 /* Pad mask to an even multiple of the vector size */
10392 while (vec_len (mask) % sizeof (u32x4))
10393 vec_add1 (mask, 0);
10395 match = vec_len (mask) / sizeof (u32x4);
10397 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10399 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10400 if (*tmp || *(tmp + 1))
10405 clib_warning ("BUG: match 0");
10407 _vec_len (mask) = match * sizeof (u32x4);
10417 #endif /* VPP_API_TEST_BUILTIN */
10419 #define foreach_l2_next \
10421 _(ethernet, ETHERNET_INPUT) \
10422 _(ip4, IP4_INPUT) \
10426 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10428 u32 *miss_next_indexp = va_arg (*args, u32 *);
10429 u32 next_index = 0;
10433 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10437 if (unformat (input, "%d", &tmp))
10446 *miss_next_indexp = next_index;
10450 #define foreach_ip_next \
10453 _(rewrite, REWRITE)
10456 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10458 u32 *miss_next_indexp = va_arg (*args, u32 *);
10459 u32 next_index = 0;
10463 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10467 if (unformat (input, "%d", &tmp))
10476 *miss_next_indexp = next_index;
10480 #define foreach_acl_next \
10484 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10486 u32 *miss_next_indexp = va_arg (*args, u32 *);
10487 u32 next_index = 0;
10491 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10495 if (unformat (input, "permit"))
10500 else if (unformat (input, "%d", &tmp))
10509 *miss_next_indexp = next_index;
10514 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10516 u32 *r = va_arg (*args, u32 *);
10518 if (unformat (input, "conform-color"))
10519 *r = POLICE_CONFORM;
10520 else if (unformat (input, "exceed-color"))
10521 *r = POLICE_EXCEED;
10529 api_classify_add_del_table (vat_main_t * vam)
10531 unformat_input_t *i = vam->input;
10532 vl_api_classify_add_del_table_t *mp;
10539 u32 table_index = ~0;
10540 u32 next_table_index = ~0;
10541 u32 miss_next_index = ~0;
10542 u32 memory_size = 32 << 20;
10544 u32 current_data_flag = 0;
10545 int current_data_offset = 0;
10548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10550 if (unformat (i, "del"))
10552 else if (unformat (i, "del-chain"))
10557 else if (unformat (i, "buckets %d", &nbuckets))
10559 else if (unformat (i, "memory_size %d", &memory_size))
10561 else if (unformat (i, "skip %d", &skip))
10563 else if (unformat (i, "match %d", &match))
10565 else if (unformat (i, "table %d", &table_index))
10567 else if (unformat (i, "mask %U", unformat_classify_mask,
10568 &mask, &skip, &match))
10570 else if (unformat (i, "next-table %d", &next_table_index))
10572 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10575 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10578 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10581 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10583 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10589 if (is_add && mask == 0)
10591 errmsg ("Mask required");
10595 if (is_add && skip == ~0)
10597 errmsg ("skip count required");
10601 if (is_add && match == ~0)
10603 errmsg ("match count required");
10607 if (!is_add && table_index == ~0)
10609 errmsg ("table index required for delete");
10613 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10615 mp->is_add = is_add;
10616 mp->del_chain = del_chain;
10617 mp->table_index = ntohl (table_index);
10618 mp->nbuckets = ntohl (nbuckets);
10619 mp->memory_size = ntohl (memory_size);
10620 mp->skip_n_vectors = ntohl (skip);
10621 mp->match_n_vectors = ntohl (match);
10622 mp->next_table_index = ntohl (next_table_index);
10623 mp->miss_next_index = ntohl (miss_next_index);
10624 mp->current_data_flag = ntohl (current_data_flag);
10625 mp->current_data_offset = ntohl (current_data_offset);
10626 mp->mask_len = ntohl (vec_len (mask));
10627 clib_memcpy (mp->mask, mask, vec_len (mask));
10636 #if VPP_API_TEST_BUILTIN == 0
10638 unformat_l4_match (unformat_input_t * input, va_list * args)
10640 u8 **matchp = va_arg (*args, u8 **);
10642 u8 *proto_header = 0;
10648 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10650 if (unformat (input, "src_port %d", &src_port))
10652 else if (unformat (input, "dst_port %d", &dst_port))
10658 h.src_port = clib_host_to_net_u16 (src_port);
10659 h.dst_port = clib_host_to_net_u16 (dst_port);
10660 vec_validate (proto_header, sizeof (h) - 1);
10661 memcpy (proto_header, &h, sizeof (h));
10663 *matchp = proto_header;
10669 unformat_ip4_match (unformat_input_t * input, va_list * args)
10671 u8 **matchp = va_arg (*args, u8 **);
10676 int hdr_length = 0;
10677 u32 hdr_length_val;
10678 int src = 0, dst = 0;
10679 ip4_address_t src_val, dst_val;
10686 int fragment_id = 0;
10687 u32 fragment_id_val;
10693 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10695 if (unformat (input, "version %d", &version_val))
10697 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10699 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10701 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10703 else if (unformat (input, "proto %d", &proto_val))
10705 else if (unformat (input, "tos %d", &tos_val))
10707 else if (unformat (input, "length %d", &length_val))
10709 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10711 else if (unformat (input, "ttl %d", &ttl_val))
10713 else if (unformat (input, "checksum %d", &checksum_val))
10719 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10720 + ttl + checksum == 0)
10724 * Aligned because we use the real comparison functions
10726 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10728 ip = (ip4_header_t *) match;
10730 /* These are realistically matched in practice */
10732 ip->src_address.as_u32 = src_val.as_u32;
10735 ip->dst_address.as_u32 = dst_val.as_u32;
10738 ip->protocol = proto_val;
10741 /* These are not, but they're included for completeness */
10743 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10746 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10752 ip->length = clib_host_to_net_u16 (length_val);
10758 ip->checksum = clib_host_to_net_u16 (checksum_val);
10765 unformat_ip6_match (unformat_input_t * input, va_list * args)
10767 u8 **matchp = va_arg (*args, u8 **);
10772 u8 traffic_class = 0;
10773 u32 traffic_class_val = 0;
10776 int src = 0, dst = 0;
10777 ip6_address_t src_val, dst_val;
10780 int payload_length = 0;
10781 u32 payload_length_val;
10784 u32 ip_version_traffic_class_and_flow_label;
10786 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10788 if (unformat (input, "version %d", &version_val))
10790 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10792 else if (unformat (input, "flow_label %d", &flow_label_val))
10794 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10796 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10798 else if (unformat (input, "proto %d", &proto_val))
10800 else if (unformat (input, "payload_length %d", &payload_length_val))
10801 payload_length = 1;
10802 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10808 if (version + traffic_class + flow_label + src + dst + proto +
10809 payload_length + hop_limit == 0)
10813 * Aligned because we use the real comparison functions
10815 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10817 ip = (ip6_header_t *) match;
10820 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10823 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10826 ip->protocol = proto_val;
10828 ip_version_traffic_class_and_flow_label = 0;
10831 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10834 ip_version_traffic_class_and_flow_label |=
10835 (traffic_class_val & 0xFF) << 20;
10838 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10840 ip->ip_version_traffic_class_and_flow_label =
10841 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10843 if (payload_length)
10844 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10847 ip->hop_limit = hop_limit_val;
10854 unformat_l3_match (unformat_input_t * input, va_list * args)
10856 u8 **matchp = va_arg (*args, u8 **);
10858 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10860 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10862 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10871 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10873 u8 *tagp = va_arg (*args, u8 *);
10876 if (unformat (input, "%d", &tag))
10878 tagp[0] = (tag >> 8) & 0x0F;
10879 tagp[1] = tag & 0xFF;
10887 unformat_l2_match (unformat_input_t * input, va_list * args)
10889 u8 **matchp = va_arg (*args, u8 **);
10902 u8 ignore_tag1 = 0;
10903 u8 ignore_tag2 = 0;
10909 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10911 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10914 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10916 else if (unformat (input, "proto %U",
10917 unformat_ethernet_type_host_byte_order, &proto_val))
10919 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10921 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10923 else if (unformat (input, "ignore-tag1"))
10925 else if (unformat (input, "ignore-tag2"))
10927 else if (unformat (input, "cos1 %d", &cos1_val))
10929 else if (unformat (input, "cos2 %d", &cos2_val))
10934 if ((src + dst + proto + tag1 + tag2 +
10935 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10938 if (tag1 || ignore_tag1 || cos1)
10940 if (tag2 || ignore_tag2 || cos2)
10943 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10946 clib_memcpy (match, dst_val, 6);
10949 clib_memcpy (match + 6, src_val, 6);
10953 /* inner vlan tag */
10954 match[19] = tag2_val[1];
10955 match[18] = tag2_val[0];
10957 match[18] |= (cos2_val & 0x7) << 5;
10960 match[21] = proto_val & 0xff;
10961 match[20] = proto_val >> 8;
10965 match[15] = tag1_val[1];
10966 match[14] = tag1_val[0];
10969 match[14] |= (cos1_val & 0x7) << 5;
10975 match[15] = tag1_val[1];
10976 match[14] = tag1_val[0];
10979 match[17] = proto_val & 0xff;
10980 match[16] = proto_val >> 8;
10983 match[14] |= (cos1_val & 0x7) << 5;
10989 match[18] |= (cos2_val & 0x7) << 5;
10991 match[14] |= (cos1_val & 0x7) << 5;
10994 match[13] = proto_val & 0xff;
10995 match[12] = proto_val >> 8;
11003 unformat_qos_source (unformat_input_t * input, va_list * args)
11005 int *qs = va_arg (*args, int *);
11007 if (unformat (input, "ip"))
11008 *qs = QOS_SOURCE_IP;
11009 else if (unformat (input, "mpls"))
11010 *qs = QOS_SOURCE_MPLS;
11011 else if (unformat (input, "ext"))
11012 *qs = QOS_SOURCE_EXT;
11013 else if (unformat (input, "vlan"))
11014 *qs = QOS_SOURCE_VLAN;
11023 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11025 u8 **matchp = va_arg (*args, u8 **);
11026 u32 skip_n_vectors = va_arg (*args, u32);
11027 u32 match_n_vectors = va_arg (*args, u32);
11034 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11036 if (unformat (input, "hex %U", unformat_hex_string, &match))
11038 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11040 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11042 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11056 if (match || l2 || l3 || l4)
11058 if (l2 || l3 || l4)
11060 /* "Win a free Ethernet header in every packet" */
11062 vec_validate_aligned (l2, 13, sizeof (u32x4));
11066 vec_append_aligned (match, l3, sizeof (u32x4));
11071 vec_append_aligned (match, l4, sizeof (u32x4));
11076 /* Make sure the vector is big enough even if key is all 0's */
11077 vec_validate_aligned
11078 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11081 /* Set size, include skipped vectors */
11082 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11093 api_classify_add_del_session (vat_main_t * vam)
11095 unformat_input_t *i = vam->input;
11096 vl_api_classify_add_del_session_t *mp;
11098 u32 table_index = ~0;
11099 u32 hit_next_index = ~0;
11100 u32 opaque_index = ~0;
11103 u32 skip_n_vectors = 0;
11104 u32 match_n_vectors = 0;
11110 * Warning: you have to supply skip_n and match_n
11111 * because the API client cant simply look at the classify
11115 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11117 if (unformat (i, "del"))
11119 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11122 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11125 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11128 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11130 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11132 else if (unformat (i, "opaque-index %d", &opaque_index))
11134 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11136 else if (unformat (i, "match_n %d", &match_n_vectors))
11138 else if (unformat (i, "match %U", api_unformat_classify_match,
11139 &match, skip_n_vectors, match_n_vectors))
11141 else if (unformat (i, "advance %d", &advance))
11143 else if (unformat (i, "table-index %d", &table_index))
11145 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11147 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11149 else if (unformat (i, "action %d", &action))
11151 else if (unformat (i, "metadata %d", &metadata))
11157 if (table_index == ~0)
11159 errmsg ("Table index required");
11163 if (is_add && match == 0)
11165 errmsg ("Match value required");
11169 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11171 mp->is_add = is_add;
11172 mp->table_index = ntohl (table_index);
11173 mp->hit_next_index = ntohl (hit_next_index);
11174 mp->opaque_index = ntohl (opaque_index);
11175 mp->advance = ntohl (advance);
11176 mp->action = action;
11177 mp->metadata = ntohl (metadata);
11178 mp->match_len = ntohl (vec_len (match));
11179 clib_memcpy (mp->match, match, vec_len (match));
11188 api_classify_set_interface_ip_table (vat_main_t * vam)
11190 unformat_input_t *i = vam->input;
11191 vl_api_classify_set_interface_ip_table_t *mp;
11193 int sw_if_index_set;
11194 u32 table_index = ~0;
11198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11200 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11201 sw_if_index_set = 1;
11202 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11203 sw_if_index_set = 1;
11204 else if (unformat (i, "table %d", &table_index))
11208 clib_warning ("parse error '%U'", format_unformat_error, i);
11213 if (sw_if_index_set == 0)
11215 errmsg ("missing interface name or sw_if_index");
11220 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11222 mp->sw_if_index = ntohl (sw_if_index);
11223 mp->table_index = ntohl (table_index);
11224 mp->is_ipv6 = is_ipv6;
11232 api_classify_set_interface_l2_tables (vat_main_t * vam)
11234 unformat_input_t *i = vam->input;
11235 vl_api_classify_set_interface_l2_tables_t *mp;
11237 int sw_if_index_set;
11238 u32 ip4_table_index = ~0;
11239 u32 ip6_table_index = ~0;
11240 u32 other_table_index = ~0;
11244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11246 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11247 sw_if_index_set = 1;
11248 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11249 sw_if_index_set = 1;
11250 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11252 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11254 else if (unformat (i, "other-table %d", &other_table_index))
11256 else if (unformat (i, "is-input %d", &is_input))
11260 clib_warning ("parse error '%U'", format_unformat_error, i);
11265 if (sw_if_index_set == 0)
11267 errmsg ("missing interface name or sw_if_index");
11272 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11274 mp->sw_if_index = ntohl (sw_if_index);
11275 mp->ip4_table_index = ntohl (ip4_table_index);
11276 mp->ip6_table_index = ntohl (ip6_table_index);
11277 mp->other_table_index = ntohl (other_table_index);
11278 mp->is_input = (u8) is_input;
11286 api_set_ipfix_exporter (vat_main_t * vam)
11288 unformat_input_t *i = vam->input;
11289 vl_api_set_ipfix_exporter_t *mp;
11290 ip4_address_t collector_address;
11291 u8 collector_address_set = 0;
11292 u32 collector_port = ~0;
11293 ip4_address_t src_address;
11294 u8 src_address_set = 0;
11297 u32 template_interval = ~0;
11298 u8 udp_checksum = 0;
11301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11303 if (unformat (i, "collector_address %U", unformat_ip4_address,
11304 &collector_address))
11305 collector_address_set = 1;
11306 else if (unformat (i, "collector_port %d", &collector_port))
11308 else if (unformat (i, "src_address %U", unformat_ip4_address,
11310 src_address_set = 1;
11311 else if (unformat (i, "vrf_id %d", &vrf_id))
11313 else if (unformat (i, "path_mtu %d", &path_mtu))
11315 else if (unformat (i, "template_interval %d", &template_interval))
11317 else if (unformat (i, "udp_checksum"))
11323 if (collector_address_set == 0)
11325 errmsg ("collector_address required");
11329 if (src_address_set == 0)
11331 errmsg ("src_address required");
11335 M (SET_IPFIX_EXPORTER, mp);
11337 memcpy (mp->collector_address.un.ip4, collector_address.data,
11338 sizeof (collector_address.data));
11339 mp->collector_port = htons ((u16) collector_port);
11340 memcpy (mp->src_address.un.ip4, src_address.data,
11341 sizeof (src_address.data));
11342 mp->vrf_id = htonl (vrf_id);
11343 mp->path_mtu = htonl (path_mtu);
11344 mp->template_interval = htonl (template_interval);
11345 mp->udp_checksum = udp_checksum;
11353 api_set_ipfix_classify_stream (vat_main_t * vam)
11355 unformat_input_t *i = vam->input;
11356 vl_api_set_ipfix_classify_stream_t *mp;
11358 u32 src_port = UDP_DST_PORT_ipfix;
11361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11363 if (unformat (i, "domain %d", &domain_id))
11365 else if (unformat (i, "src_port %d", &src_port))
11369 errmsg ("unknown input `%U'", format_unformat_error, i);
11374 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11376 mp->domain_id = htonl (domain_id);
11377 mp->src_port = htons ((u16) src_port);
11385 api_ipfix_classify_table_add_del (vat_main_t * vam)
11387 unformat_input_t *i = vam->input;
11388 vl_api_ipfix_classify_table_add_del_t *mp;
11390 u32 classify_table_index = ~0;
11392 u8 transport_protocol = 255;
11395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11397 if (unformat (i, "add"))
11399 else if (unformat (i, "del"))
11401 else if (unformat (i, "table %d", &classify_table_index))
11403 else if (unformat (i, "ip4"))
11405 else if (unformat (i, "ip6"))
11407 else if (unformat (i, "tcp"))
11408 transport_protocol = 6;
11409 else if (unformat (i, "udp"))
11410 transport_protocol = 17;
11413 errmsg ("unknown input `%U'", format_unformat_error, i);
11420 errmsg ("expecting: add|del");
11423 if (classify_table_index == ~0)
11425 errmsg ("classifier table not specified");
11428 if (ip_version == 0)
11430 errmsg ("IP version not specified");
11434 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11436 mp->is_add = is_add;
11437 mp->table_id = htonl (classify_table_index);
11438 mp->ip_version = ip_version;
11439 mp->transport_protocol = transport_protocol;
11447 api_get_node_index (vat_main_t * vam)
11449 unformat_input_t *i = vam->input;
11450 vl_api_get_node_index_t *mp;
11454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11456 if (unformat (i, "node %s", &name))
11463 errmsg ("node name required");
11466 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11468 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11472 M (GET_NODE_INDEX, mp);
11473 clib_memcpy (mp->node_name, name, vec_len (name));
11482 api_get_next_index (vat_main_t * vam)
11484 unformat_input_t *i = vam->input;
11485 vl_api_get_next_index_t *mp;
11486 u8 *node_name = 0, *next_node_name = 0;
11489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11491 if (unformat (i, "node-name %s", &node_name))
11493 else if (unformat (i, "next-node-name %s", &next_node_name))
11497 if (node_name == 0)
11499 errmsg ("node name required");
11502 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11504 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11508 if (next_node_name == 0)
11510 errmsg ("next node name required");
11513 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11515 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11519 M (GET_NEXT_INDEX, mp);
11520 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11521 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11522 vec_free (node_name);
11523 vec_free (next_node_name);
11531 api_add_node_next (vat_main_t * vam)
11533 unformat_input_t *i = vam->input;
11534 vl_api_add_node_next_t *mp;
11539 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11541 if (unformat (i, "node %s", &name))
11543 else if (unformat (i, "next %s", &next))
11550 errmsg ("node name required");
11553 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11555 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11560 errmsg ("next node required");
11563 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11565 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11569 M (ADD_NODE_NEXT, mp);
11570 clib_memcpy (mp->node_name, name, vec_len (name));
11571 clib_memcpy (mp->next_name, next, vec_len (next));
11581 api_l2tpv3_create_tunnel (vat_main_t * vam)
11583 unformat_input_t *i = vam->input;
11584 ip6_address_t client_address, our_address;
11585 int client_address_set = 0;
11586 int our_address_set = 0;
11587 u32 local_session_id = 0;
11588 u32 remote_session_id = 0;
11589 u64 local_cookie = 0;
11590 u64 remote_cookie = 0;
11591 u8 l2_sublayer_present = 0;
11592 vl_api_l2tpv3_create_tunnel_t *mp;
11595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11597 if (unformat (i, "client_address %U", unformat_ip6_address,
11599 client_address_set = 1;
11600 else if (unformat (i, "our_address %U", unformat_ip6_address,
11602 our_address_set = 1;
11603 else if (unformat (i, "local_session_id %d", &local_session_id))
11605 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11607 else if (unformat (i, "local_cookie %lld", &local_cookie))
11609 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11611 else if (unformat (i, "l2-sublayer-present"))
11612 l2_sublayer_present = 1;
11617 if (client_address_set == 0)
11619 errmsg ("client_address required");
11623 if (our_address_set == 0)
11625 errmsg ("our_address required");
11629 M (L2TPV3_CREATE_TUNNEL, mp);
11631 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11632 sizeof (ip6_address_t));
11634 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11635 sizeof (ip6_address_t));
11637 mp->local_session_id = ntohl (local_session_id);
11638 mp->remote_session_id = ntohl (remote_session_id);
11639 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11640 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11641 mp->l2_sublayer_present = l2_sublayer_present;
11649 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11651 unformat_input_t *i = vam->input;
11653 u8 sw_if_index_set = 0;
11654 u64 new_local_cookie = 0;
11655 u64 new_remote_cookie = 0;
11656 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11659 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11661 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11662 sw_if_index_set = 1;
11663 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11664 sw_if_index_set = 1;
11665 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11667 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11673 if (sw_if_index_set == 0)
11675 errmsg ("missing interface name or sw_if_index");
11679 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11681 mp->sw_if_index = ntohl (sw_if_index);
11682 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11683 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11691 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11693 unformat_input_t *i = vam->input;
11694 vl_api_l2tpv3_interface_enable_disable_t *mp;
11696 u8 sw_if_index_set = 0;
11697 u8 enable_disable = 1;
11700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11702 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11703 sw_if_index_set = 1;
11704 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11705 sw_if_index_set = 1;
11706 else if (unformat (i, "enable"))
11707 enable_disable = 1;
11708 else if (unformat (i, "disable"))
11709 enable_disable = 0;
11714 if (sw_if_index_set == 0)
11716 errmsg ("missing interface name or sw_if_index");
11720 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11722 mp->sw_if_index = ntohl (sw_if_index);
11723 mp->enable_disable = enable_disable;
11731 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11733 unformat_input_t *i = vam->input;
11734 vl_api_l2tpv3_set_lookup_key_t *mp;
11738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11740 if (unformat (i, "lookup_v6_src"))
11741 key = L2T_LOOKUP_SRC_ADDRESS;
11742 else if (unformat (i, "lookup_v6_dst"))
11743 key = L2T_LOOKUP_DST_ADDRESS;
11744 else if (unformat (i, "lookup_session_id"))
11745 key = L2T_LOOKUP_SESSION_ID;
11750 if (key == (u8) ~ 0)
11752 errmsg ("l2tp session lookup key unset");
11756 M (L2TPV3_SET_LOOKUP_KEY, mp);
11765 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11766 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11768 vat_main_t *vam = &vat_main;
11770 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11771 format_ip6_address, mp->our_address,
11772 format_ip6_address, mp->client_address,
11773 clib_net_to_host_u32 (mp->sw_if_index));
11776 " local cookies %016llx %016llx remote cookie %016llx",
11777 clib_net_to_host_u64 (mp->local_cookie[0]),
11778 clib_net_to_host_u64 (mp->local_cookie[1]),
11779 clib_net_to_host_u64 (mp->remote_cookie));
11781 print (vam->ofp, " local session-id %d remote session-id %d",
11782 clib_net_to_host_u32 (mp->local_session_id),
11783 clib_net_to_host_u32 (mp->remote_session_id));
11785 print (vam->ofp, " l2 specific sublayer %s\n",
11786 mp->l2_sublayer_present ? "preset" : "absent");
11790 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11791 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11793 vat_main_t *vam = &vat_main;
11794 vat_json_node_t *node = NULL;
11795 struct in6_addr addr;
11797 if (VAT_JSON_ARRAY != vam->json_tree.type)
11799 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11800 vat_json_init_array (&vam->json_tree);
11802 node = vat_json_array_add (&vam->json_tree);
11804 vat_json_init_object (node);
11806 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11807 vat_json_object_add_ip6 (node, "our_address", addr);
11808 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11809 vat_json_object_add_ip6 (node, "client_address", addr);
11811 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11812 vat_json_init_array (lc);
11813 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11814 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11815 vat_json_object_add_uint (node, "remote_cookie",
11816 clib_net_to_host_u64 (mp->remote_cookie));
11818 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11819 vat_json_object_add_uint (node, "local_session_id",
11820 clib_net_to_host_u32 (mp->local_session_id));
11821 vat_json_object_add_uint (node, "remote_session_id",
11822 clib_net_to_host_u32 (mp->remote_session_id));
11823 vat_json_object_add_string_copy (node, "l2_sublayer",
11824 mp->l2_sublayer_present ? (u8 *) "present"
11825 : (u8 *) "absent");
11829 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11831 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11832 vl_api_control_ping_t *mp_ping;
11835 /* Get list of l2tpv3-tunnel interfaces */
11836 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11839 /* Use a control ping for synchronization */
11840 MPING (CONTROL_PING, mp_ping);
11848 static void vl_api_sw_interface_tap_v2_details_t_handler
11849 (vl_api_sw_interface_tap_v2_details_t * mp)
11851 vat_main_t *vam = &vat_main;
11854 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11855 mp->host_ip4_prefix.len);
11857 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11858 mp->host_ip6_prefix.len);
11861 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11862 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11863 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11864 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11865 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11871 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11872 (vl_api_sw_interface_tap_v2_details_t * mp)
11874 vat_main_t *vam = &vat_main;
11875 vat_json_node_t *node = NULL;
11877 if (VAT_JSON_ARRAY != vam->json_tree.type)
11879 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11880 vat_json_init_array (&vam->json_tree);
11882 node = vat_json_array_add (&vam->json_tree);
11884 vat_json_init_object (node);
11885 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11886 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11887 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11888 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11889 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11890 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11891 vat_json_object_add_string_copy (node, "host_mac_addr",
11892 format (0, "%U", format_ethernet_address,
11893 &mp->host_mac_addr));
11894 vat_json_object_add_string_copy (node, "host_namespace",
11895 mp->host_namespace);
11896 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11897 vat_json_object_add_string_copy (node, "host_ip4_addr",
11898 format (0, "%U/%d", format_ip4_address,
11899 mp->host_ip4_prefix.address,
11900 mp->host_ip4_prefix.len));
11901 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11902 format (0, "%U/%d", format_ip6_address,
11903 mp->host_ip6_prefix.address,
11904 mp->host_ip6_prefix.len));
11909 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11911 vl_api_sw_interface_tap_v2_dump_t *mp;
11912 vl_api_control_ping_t *mp_ping;
11916 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11917 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11918 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11921 /* Get list of tap interfaces */
11922 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11925 /* Use a control ping for synchronization */
11926 MPING (CONTROL_PING, mp_ping);
11933 static void vl_api_sw_interface_virtio_pci_details_t_handler
11934 (vl_api_sw_interface_virtio_pci_details_t * mp)
11936 vat_main_t *vam = &vat_main;
11950 addr.as_u32 = ntohl (mp->pci_addr);
11951 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11952 addr.slot, addr.function);
11955 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11956 pci_addr, ntohl (mp->sw_if_index),
11957 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11958 format_ethernet_address, mp->mac_addr,
11959 clib_net_to_host_u64 (mp->features));
11960 vec_free (pci_addr);
11963 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11964 (vl_api_sw_interface_virtio_pci_details_t * mp)
11966 vat_main_t *vam = &vat_main;
11967 vat_json_node_t *node = NULL;
11969 if (VAT_JSON_ARRAY != vam->json_tree.type)
11971 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11972 vat_json_init_array (&vam->json_tree);
11974 node = vat_json_array_add (&vam->json_tree);
11976 vat_json_init_object (node);
11977 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
11978 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11979 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11980 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11981 vat_json_object_add_uint (node, "features",
11982 clib_net_to_host_u64 (mp->features));
11983 vat_json_object_add_string_copy (node, "mac_addr",
11984 format (0, "%U", format_ethernet_address,
11989 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11991 vl_api_sw_interface_virtio_pci_dump_t *mp;
11992 vl_api_control_ping_t *mp_ping;
11996 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11997 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11998 "mac_addr", "features");
12000 /* Get list of tap interfaces */
12001 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12004 /* Use a control ping for synchronization */
12005 MPING (CONTROL_PING, mp_ping);
12013 api_vxlan_offload_rx (vat_main_t * vam)
12015 unformat_input_t *line_input = vam->input;
12016 vl_api_vxlan_offload_rx_t *mp;
12017 u32 hw_if_index = ~0, rx_if_index = ~0;
12021 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12023 if (unformat (line_input, "del"))
12025 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12028 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12030 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12033 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12037 errmsg ("parse error '%U'", format_unformat_error, line_input);
12042 if (hw_if_index == ~0)
12044 errmsg ("no hw interface");
12048 if (rx_if_index == ~0)
12050 errmsg ("no rx tunnel");
12054 M (VXLAN_OFFLOAD_RX, mp);
12056 mp->hw_if_index = ntohl (hw_if_index);
12057 mp->sw_if_index = ntohl (rx_if_index);
12058 mp->enable = is_add;
12065 static uword unformat_vxlan_decap_next
12066 (unformat_input_t * input, va_list * args)
12068 u32 *result = va_arg (*args, u32 *);
12071 if (unformat (input, "l2"))
12072 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12073 else if (unformat (input, "%d", &tmp))
12081 api_vxlan_add_del_tunnel (vat_main_t * vam)
12083 unformat_input_t *line_input = vam->input;
12084 vl_api_vxlan_add_del_tunnel_t *mp;
12085 ip46_address_t src, dst;
12087 u8 ipv4_set = 0, ipv6_set = 0;
12092 u32 mcast_sw_if_index = ~0;
12093 u32 encap_vrf_id = 0;
12094 u32 decap_next_index = ~0;
12098 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12099 clib_memset (&src, 0, sizeof src);
12100 clib_memset (&dst, 0, sizeof dst);
12102 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12104 if (unformat (line_input, "del"))
12106 else if (unformat (line_input, "instance %d", &instance))
12109 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12115 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12121 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12127 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12132 else if (unformat (line_input, "group %U %U",
12133 unformat_ip4_address, &dst.ip4,
12134 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12136 grp_set = dst_set = 1;
12139 else if (unformat (line_input, "group %U",
12140 unformat_ip4_address, &dst.ip4))
12142 grp_set = dst_set = 1;
12145 else if (unformat (line_input, "group %U %U",
12146 unformat_ip6_address, &dst.ip6,
12147 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12149 grp_set = dst_set = 1;
12152 else if (unformat (line_input, "group %U",
12153 unformat_ip6_address, &dst.ip6))
12155 grp_set = dst_set = 1;
12159 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12161 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12163 else if (unformat (line_input, "decap-next %U",
12164 unformat_vxlan_decap_next, &decap_next_index))
12166 else if (unformat (line_input, "vni %d", &vni))
12170 errmsg ("parse error '%U'", format_unformat_error, line_input);
12177 errmsg ("tunnel src address not specified");
12182 errmsg ("tunnel dst address not specified");
12186 if (grp_set && !ip46_address_is_multicast (&dst))
12188 errmsg ("tunnel group address not multicast");
12191 if (grp_set && mcast_sw_if_index == ~0)
12193 errmsg ("tunnel nonexistent multicast device");
12196 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12198 errmsg ("tunnel dst address must be unicast");
12203 if (ipv4_set && ipv6_set)
12205 errmsg ("both IPv4 and IPv6 addresses specified");
12209 if ((vni == 0) || (vni >> 24))
12211 errmsg ("vni not specified or out of range");
12215 M (VXLAN_ADD_DEL_TUNNEL, mp);
12219 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12220 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12224 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12225 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12228 mp->instance = htonl (instance);
12229 mp->encap_vrf_id = ntohl (encap_vrf_id);
12230 mp->decap_next_index = ntohl (decap_next_index);
12231 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12232 mp->vni = ntohl (vni);
12233 mp->is_add = is_add;
12234 mp->is_ipv6 = ipv6_set;
12241 static void vl_api_vxlan_tunnel_details_t_handler
12242 (vl_api_vxlan_tunnel_details_t * mp)
12244 vat_main_t *vam = &vat_main;
12245 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12246 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12248 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12249 ntohl (mp->sw_if_index),
12250 ntohl (mp->instance),
12251 format_ip46_address, &src, IP46_TYPE_ANY,
12252 format_ip46_address, &dst, IP46_TYPE_ANY,
12253 ntohl (mp->encap_vrf_id),
12254 ntohl (mp->decap_next_index), ntohl (mp->vni),
12255 ntohl (mp->mcast_sw_if_index));
12258 static void vl_api_vxlan_tunnel_details_t_handler_json
12259 (vl_api_vxlan_tunnel_details_t * mp)
12261 vat_main_t *vam = &vat_main;
12262 vat_json_node_t *node = NULL;
12264 if (VAT_JSON_ARRAY != vam->json_tree.type)
12266 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12267 vat_json_init_array (&vam->json_tree);
12269 node = vat_json_array_add (&vam->json_tree);
12271 vat_json_init_object (node);
12272 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12274 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12278 struct in6_addr ip6;
12280 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12281 vat_json_object_add_ip6 (node, "src_address", ip6);
12282 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12283 vat_json_object_add_ip6 (node, "dst_address", ip6);
12287 struct in_addr ip4;
12289 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12290 vat_json_object_add_ip4 (node, "src_address", ip4);
12291 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12292 vat_json_object_add_ip4 (node, "dst_address", ip4);
12294 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12295 vat_json_object_add_uint (node, "decap_next_index",
12296 ntohl (mp->decap_next_index));
12297 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12298 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12299 vat_json_object_add_uint (node, "mcast_sw_if_index",
12300 ntohl (mp->mcast_sw_if_index));
12304 api_vxlan_tunnel_dump (vat_main_t * vam)
12306 unformat_input_t *i = vam->input;
12307 vl_api_vxlan_tunnel_dump_t *mp;
12308 vl_api_control_ping_t *mp_ping;
12310 u8 sw_if_index_set = 0;
12313 /* Parse args required to build the message */
12314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12316 if (unformat (i, "sw_if_index %d", &sw_if_index))
12317 sw_if_index_set = 1;
12322 if (sw_if_index_set == 0)
12327 if (!vam->json_output)
12329 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12330 "sw_if_index", "instance", "src_address", "dst_address",
12331 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12334 /* Get list of vxlan-tunnel interfaces */
12335 M (VXLAN_TUNNEL_DUMP, mp);
12337 mp->sw_if_index = htonl (sw_if_index);
12341 /* Use a control ping for synchronization */
12342 MPING (CONTROL_PING, mp_ping);
12349 static uword unformat_geneve_decap_next
12350 (unformat_input_t * input, va_list * args)
12352 u32 *result = va_arg (*args, u32 *);
12355 if (unformat (input, "l2"))
12356 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12357 else if (unformat (input, "%d", &tmp))
12365 api_geneve_add_del_tunnel (vat_main_t * vam)
12367 unformat_input_t *line_input = vam->input;
12368 vl_api_geneve_add_del_tunnel_t *mp;
12369 ip46_address_t src, dst;
12371 u8 ipv4_set = 0, ipv6_set = 0;
12375 u32 mcast_sw_if_index = ~0;
12376 u32 encap_vrf_id = 0;
12377 u32 decap_next_index = ~0;
12381 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12382 clib_memset (&src, 0, sizeof src);
12383 clib_memset (&dst, 0, sizeof dst);
12385 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12387 if (unformat (line_input, "del"))
12390 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12396 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12402 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12408 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12413 else if (unformat (line_input, "group %U %U",
12414 unformat_ip4_address, &dst.ip4,
12415 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12417 grp_set = dst_set = 1;
12420 else if (unformat (line_input, "group %U",
12421 unformat_ip4_address, &dst.ip4))
12423 grp_set = dst_set = 1;
12426 else if (unformat (line_input, "group %U %U",
12427 unformat_ip6_address, &dst.ip6,
12428 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12430 grp_set = dst_set = 1;
12433 else if (unformat (line_input, "group %U",
12434 unformat_ip6_address, &dst.ip6))
12436 grp_set = dst_set = 1;
12440 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12442 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12444 else if (unformat (line_input, "decap-next %U",
12445 unformat_geneve_decap_next, &decap_next_index))
12447 else if (unformat (line_input, "vni %d", &vni))
12451 errmsg ("parse error '%U'", format_unformat_error, line_input);
12458 errmsg ("tunnel src address not specified");
12463 errmsg ("tunnel dst address not specified");
12467 if (grp_set && !ip46_address_is_multicast (&dst))
12469 errmsg ("tunnel group address not multicast");
12472 if (grp_set && mcast_sw_if_index == ~0)
12474 errmsg ("tunnel nonexistent multicast device");
12477 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12479 errmsg ("tunnel dst address must be unicast");
12484 if (ipv4_set && ipv6_set)
12486 errmsg ("both IPv4 and IPv6 addresses specified");
12490 if ((vni == 0) || (vni >> 24))
12492 errmsg ("vni not specified or out of range");
12496 M (GENEVE_ADD_DEL_TUNNEL, mp);
12500 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12501 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12505 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12506 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12508 mp->encap_vrf_id = ntohl (encap_vrf_id);
12509 mp->decap_next_index = ntohl (decap_next_index);
12510 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12511 mp->vni = ntohl (vni);
12512 mp->is_add = is_add;
12519 static void vl_api_geneve_tunnel_details_t_handler
12520 (vl_api_geneve_tunnel_details_t * mp)
12522 vat_main_t *vam = &vat_main;
12523 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12524 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12526 if (mp->src_address.af == ADDRESS_IP6)
12528 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12529 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12533 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12534 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12537 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12538 ntohl (mp->sw_if_index),
12539 format_ip46_address, &src, IP46_TYPE_ANY,
12540 format_ip46_address, &dst, IP46_TYPE_ANY,
12541 ntohl (mp->encap_vrf_id),
12542 ntohl (mp->decap_next_index), ntohl (mp->vni),
12543 ntohl (mp->mcast_sw_if_index));
12546 static void vl_api_geneve_tunnel_details_t_handler_json
12547 (vl_api_geneve_tunnel_details_t * mp)
12549 vat_main_t *vam = &vat_main;
12550 vat_json_node_t *node = NULL;
12553 if (VAT_JSON_ARRAY != vam->json_tree.type)
12555 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12556 vat_json_init_array (&vam->json_tree);
12558 node = vat_json_array_add (&vam->json_tree);
12560 vat_json_init_object (node);
12561 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12562 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12565 struct in6_addr ip6;
12567 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12568 vat_json_object_add_ip6 (node, "src_address", ip6);
12569 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12570 vat_json_object_add_ip6 (node, "dst_address", ip6);
12574 struct in_addr ip4;
12576 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12577 vat_json_object_add_ip4 (node, "src_address", ip4);
12578 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12579 vat_json_object_add_ip4 (node, "dst_address", ip4);
12581 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12582 vat_json_object_add_uint (node, "decap_next_index",
12583 ntohl (mp->decap_next_index));
12584 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12585 vat_json_object_add_uint (node, "mcast_sw_if_index",
12586 ntohl (mp->mcast_sw_if_index));
12590 api_geneve_tunnel_dump (vat_main_t * vam)
12592 unformat_input_t *i = vam->input;
12593 vl_api_geneve_tunnel_dump_t *mp;
12594 vl_api_control_ping_t *mp_ping;
12596 u8 sw_if_index_set = 0;
12599 /* Parse args required to build the message */
12600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12602 if (unformat (i, "sw_if_index %d", &sw_if_index))
12603 sw_if_index_set = 1;
12608 if (sw_if_index_set == 0)
12613 if (!vam->json_output)
12615 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12616 "sw_if_index", "local_address", "remote_address",
12617 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12620 /* Get list of geneve-tunnel interfaces */
12621 M (GENEVE_TUNNEL_DUMP, mp);
12623 mp->sw_if_index = htonl (sw_if_index);
12627 /* Use a control ping for synchronization */
12628 M (CONTROL_PING, mp_ping);
12636 api_gre_tunnel_add_del (vat_main_t * vam)
12638 unformat_input_t *line_input = vam->input;
12639 vl_api_address_t src = { }, dst =
12642 vl_api_gre_tunnel_add_del_t *mp;
12643 vl_api_gre_tunnel_type_t t_type;
12647 u32 outer_table_id = 0;
12648 u32 session_id = 0;
12652 t_type = GRE_API_TUNNEL_TYPE_L3;
12654 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12656 if (unformat (line_input, "del"))
12658 else if (unformat (line_input, "instance %d", &instance))
12660 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12664 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12668 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12670 else if (unformat (line_input, "teb"))
12671 t_type = GRE_API_TUNNEL_TYPE_TEB;
12672 else if (unformat (line_input, "erspan %d", &session_id))
12673 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12676 errmsg ("parse error '%U'", format_unformat_error, line_input);
12683 errmsg ("tunnel src address not specified");
12688 errmsg ("tunnel dst address not specified");
12692 M (GRE_TUNNEL_ADD_DEL, mp);
12694 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12695 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12697 mp->tunnel.instance = htonl (instance);
12698 mp->tunnel.outer_table_id = htonl (outer_table_id);
12699 mp->is_add = is_add;
12700 mp->tunnel.session_id = htons ((u16) session_id);
12701 mp->tunnel.type = htonl (t_type);
12708 static void vl_api_gre_tunnel_details_t_handler
12709 (vl_api_gre_tunnel_details_t * mp)
12711 vat_main_t *vam = &vat_main;
12713 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12714 ntohl (mp->tunnel.sw_if_index),
12715 ntohl (mp->tunnel.instance),
12716 format_vl_api_address, &mp->tunnel.src,
12717 format_vl_api_address, &mp->tunnel.dst,
12718 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12719 ntohl (mp->tunnel.session_id));
12722 static void vl_api_gre_tunnel_details_t_handler_json
12723 (vl_api_gre_tunnel_details_t * mp)
12725 vat_main_t *vam = &vat_main;
12726 vat_json_node_t *node = NULL;
12728 if (VAT_JSON_ARRAY != vam->json_tree.type)
12730 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12731 vat_json_init_array (&vam->json_tree);
12733 node = vat_json_array_add (&vam->json_tree);
12735 vat_json_init_object (node);
12736 vat_json_object_add_uint (node, "sw_if_index",
12737 ntohl (mp->tunnel.sw_if_index));
12738 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12740 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12741 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12742 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12743 vat_json_object_add_uint (node, "outer_table_id",
12744 ntohl (mp->tunnel.outer_table_id));
12745 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12749 api_gre_tunnel_dump (vat_main_t * vam)
12751 unformat_input_t *i = vam->input;
12752 vl_api_gre_tunnel_dump_t *mp;
12753 vl_api_control_ping_t *mp_ping;
12755 u8 sw_if_index_set = 0;
12758 /* Parse args required to build the message */
12759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12761 if (unformat (i, "sw_if_index %d", &sw_if_index))
12762 sw_if_index_set = 1;
12767 if (sw_if_index_set == 0)
12772 if (!vam->json_output)
12774 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12775 "sw_if_index", "instance", "src_address", "dst_address",
12776 "tunnel_type", "outer_fib_id", "session_id");
12779 /* Get list of gre-tunnel interfaces */
12780 M (GRE_TUNNEL_DUMP, mp);
12782 mp->sw_if_index = htonl (sw_if_index);
12786 /* Use a control ping for synchronization */
12787 MPING (CONTROL_PING, mp_ping);
12795 api_l2_fib_clear_table (vat_main_t * vam)
12797 // unformat_input_t * i = vam->input;
12798 vl_api_l2_fib_clear_table_t *mp;
12801 M (L2_FIB_CLEAR_TABLE, mp);
12809 api_l2_interface_efp_filter (vat_main_t * vam)
12811 unformat_input_t *i = vam->input;
12812 vl_api_l2_interface_efp_filter_t *mp;
12815 u8 sw_if_index_set = 0;
12818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12820 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12821 sw_if_index_set = 1;
12822 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12823 sw_if_index_set = 1;
12824 else if (unformat (i, "enable"))
12826 else if (unformat (i, "disable"))
12830 clib_warning ("parse error '%U'", format_unformat_error, i);
12835 if (sw_if_index_set == 0)
12837 errmsg ("missing sw_if_index");
12841 M (L2_INTERFACE_EFP_FILTER, mp);
12843 mp->sw_if_index = ntohl (sw_if_index);
12844 mp->enable_disable = enable;
12851 #define foreach_vtr_op \
12852 _("disable", L2_VTR_DISABLED) \
12853 _("push-1", L2_VTR_PUSH_1) \
12854 _("push-2", L2_VTR_PUSH_2) \
12855 _("pop-1", L2_VTR_POP_1) \
12856 _("pop-2", L2_VTR_POP_2) \
12857 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12858 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12859 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12860 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12863 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12865 unformat_input_t *i = vam->input;
12866 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12868 u8 sw_if_index_set = 0;
12871 u32 push_dot1q = 1;
12876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12879 sw_if_index_set = 1;
12880 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12881 sw_if_index_set = 1;
12882 else if (unformat (i, "vtr_op %d", &vtr_op))
12884 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12887 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12889 else if (unformat (i, "tag1 %d", &tag1))
12891 else if (unformat (i, "tag2 %d", &tag2))
12895 clib_warning ("parse error '%U'", format_unformat_error, i);
12900 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12902 errmsg ("missing vtr operation or sw_if_index");
12906 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12907 mp->sw_if_index = ntohl (sw_if_index);
12908 mp->vtr_op = ntohl (vtr_op);
12909 mp->push_dot1q = ntohl (push_dot1q);
12910 mp->tag1 = ntohl (tag1);
12911 mp->tag2 = ntohl (tag2);
12919 api_create_vhost_user_if (vat_main_t * vam)
12921 unformat_input_t *i = vam->input;
12922 vl_api_create_vhost_user_if_t *mp;
12925 u8 file_name_set = 0;
12926 u32 custom_dev_instance = ~0;
12928 u8 use_custom_mac = 0;
12929 u8 disable_mrg_rxbuf = 0;
12930 u8 disable_indirect_desc = 0;
12935 /* Shut up coverity */
12936 clib_memset (hwaddr, 0, sizeof (hwaddr));
12938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12940 if (unformat (i, "socket %s", &file_name))
12944 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12946 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12947 use_custom_mac = 1;
12948 else if (unformat (i, "server"))
12950 else if (unformat (i, "disable_mrg_rxbuf"))
12951 disable_mrg_rxbuf = 1;
12952 else if (unformat (i, "disable_indirect_desc"))
12953 disable_indirect_desc = 1;
12954 else if (unformat (i, "gso"))
12956 else if (unformat (i, "tag %s", &tag))
12962 if (file_name_set == 0)
12964 errmsg ("missing socket file name");
12968 if (vec_len (file_name) > 255)
12970 errmsg ("socket file name too long");
12973 vec_add1 (file_name, 0);
12975 M (CREATE_VHOST_USER_IF, mp);
12977 mp->is_server = is_server;
12978 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12979 mp->disable_indirect_desc = disable_indirect_desc;
12980 mp->enable_gso = enable_gso;
12981 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12982 vec_free (file_name);
12983 if (custom_dev_instance != ~0)
12986 mp->custom_dev_instance = ntohl (custom_dev_instance);
12989 mp->use_custom_mac = use_custom_mac;
12990 clib_memcpy (mp->mac_address, hwaddr, 6);
12992 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13001 api_modify_vhost_user_if (vat_main_t * vam)
13003 unformat_input_t *i = vam->input;
13004 vl_api_modify_vhost_user_if_t *mp;
13007 u8 file_name_set = 0;
13008 u32 custom_dev_instance = ~0;
13009 u8 sw_if_index_set = 0;
13010 u32 sw_if_index = (u32) ~ 0;
13014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13016 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13017 sw_if_index_set = 1;
13018 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13019 sw_if_index_set = 1;
13020 else if (unformat (i, "socket %s", &file_name))
13024 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13026 else if (unformat (i, "server"))
13028 else if (unformat (i, "gso"))
13034 if (sw_if_index_set == 0)
13036 errmsg ("missing sw_if_index or interface name");
13040 if (file_name_set == 0)
13042 errmsg ("missing socket file name");
13046 if (vec_len (file_name) > 255)
13048 errmsg ("socket file name too long");
13051 vec_add1 (file_name, 0);
13053 M (MODIFY_VHOST_USER_IF, mp);
13055 mp->sw_if_index = ntohl (sw_if_index);
13056 mp->is_server = is_server;
13057 mp->enable_gso = enable_gso;
13058 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13059 vec_free (file_name);
13060 if (custom_dev_instance != ~0)
13063 mp->custom_dev_instance = ntohl (custom_dev_instance);
13072 api_delete_vhost_user_if (vat_main_t * vam)
13074 unformat_input_t *i = vam->input;
13075 vl_api_delete_vhost_user_if_t *mp;
13076 u32 sw_if_index = ~0;
13077 u8 sw_if_index_set = 0;
13080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13082 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13083 sw_if_index_set = 1;
13084 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13085 sw_if_index_set = 1;
13090 if (sw_if_index_set == 0)
13092 errmsg ("missing sw_if_index or interface name");
13097 M (DELETE_VHOST_USER_IF, mp);
13099 mp->sw_if_index = ntohl (sw_if_index);
13106 static void vl_api_sw_interface_vhost_user_details_t_handler
13107 (vl_api_sw_interface_vhost_user_details_t * mp)
13109 vat_main_t *vam = &vat_main;
13113 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
13114 clib_net_to_host_u32
13115 (mp->features_last_32) <<
13118 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13119 (char *) mp->interface_name,
13120 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13121 features, mp->is_server,
13122 ntohl (mp->num_regions), (char *) mp->sock_filename);
13123 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13126 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13127 (vl_api_sw_interface_vhost_user_details_t * mp)
13129 vat_main_t *vam = &vat_main;
13130 vat_json_node_t *node = NULL;
13132 if (VAT_JSON_ARRAY != vam->json_tree.type)
13134 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13135 vat_json_init_array (&vam->json_tree);
13137 node = vat_json_array_add (&vam->json_tree);
13139 vat_json_init_object (node);
13140 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13141 vat_json_object_add_string_copy (node, "interface_name",
13142 mp->interface_name);
13143 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13144 ntohl (mp->virtio_net_hdr_sz));
13145 vat_json_object_add_uint (node, "features_first_32",
13146 clib_net_to_host_u32 (mp->features_first_32));
13147 vat_json_object_add_uint (node, "features_last_32",
13148 clib_net_to_host_u32 (mp->features_last_32));
13149 vat_json_object_add_uint (node, "is_server", mp->is_server);
13150 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13151 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13152 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13156 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13158 vl_api_sw_interface_vhost_user_dump_t *mp;
13159 vl_api_control_ping_t *mp_ping;
13162 "Interface name idx hdr_sz features server regions filename");
13164 /* Get list of vhost-user interfaces */
13165 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13168 /* Use a control ping for synchronization */
13169 MPING (CONTROL_PING, mp_ping);
13177 api_show_version (vat_main_t * vam)
13179 vl_api_show_version_t *mp;
13182 M (SHOW_VERSION, mp);
13191 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13193 unformat_input_t *line_input = vam->input;
13194 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13195 ip4_address_t local4, remote4;
13196 ip6_address_t local6, remote6;
13198 u8 ipv4_set = 0, ipv6_set = 0;
13202 u32 mcast_sw_if_index = ~0;
13203 u32 encap_vrf_id = 0;
13204 u32 decap_vrf_id = 0;
13210 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13211 clib_memset (&local4, 0, sizeof local4);
13212 clib_memset (&remote4, 0, sizeof remote4);
13213 clib_memset (&local6, 0, sizeof local6);
13214 clib_memset (&remote6, 0, sizeof remote6);
13216 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13218 if (unformat (line_input, "del"))
13220 else if (unformat (line_input, "local %U",
13221 unformat_ip4_address, &local4))
13226 else if (unformat (line_input, "remote %U",
13227 unformat_ip4_address, &remote4))
13232 else if (unformat (line_input, "local %U",
13233 unformat_ip6_address, &local6))
13238 else if (unformat (line_input, "remote %U",
13239 unformat_ip6_address, &remote6))
13244 else if (unformat (line_input, "group %U %U",
13245 unformat_ip4_address, &remote4,
13246 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13248 grp_set = remote_set = 1;
13251 else if (unformat (line_input, "group %U",
13252 unformat_ip4_address, &remote4))
13254 grp_set = remote_set = 1;
13257 else if (unformat (line_input, "group %U %U",
13258 unformat_ip6_address, &remote6,
13259 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13261 grp_set = remote_set = 1;
13264 else if (unformat (line_input, "group %U",
13265 unformat_ip6_address, &remote6))
13267 grp_set = remote_set = 1;
13271 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13273 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13275 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13277 else if (unformat (line_input, "vni %d", &vni))
13279 else if (unformat (line_input, "next-ip4"))
13281 else if (unformat (line_input, "next-ip6"))
13283 else if (unformat (line_input, "next-ethernet"))
13285 else if (unformat (line_input, "next-nsh"))
13289 errmsg ("parse error '%U'", format_unformat_error, line_input);
13294 if (local_set == 0)
13296 errmsg ("tunnel local address not specified");
13299 if (remote_set == 0)
13301 errmsg ("tunnel remote address not specified");
13304 if (grp_set && mcast_sw_if_index == ~0)
13306 errmsg ("tunnel nonexistent multicast device");
13309 if (ipv4_set && ipv6_set)
13311 errmsg ("both IPv4 and IPv6 addresses specified");
13317 errmsg ("vni not specified");
13321 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13326 clib_memcpy (&mp->local, &local6, sizeof (local6));
13327 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13331 clib_memcpy (&mp->local, &local4, sizeof (local4));
13332 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13335 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13336 mp->encap_vrf_id = ntohl (encap_vrf_id);
13337 mp->decap_vrf_id = ntohl (decap_vrf_id);
13338 mp->protocol = protocol;
13339 mp->vni = ntohl (vni);
13340 mp->is_add = is_add;
13341 mp->is_ipv6 = ipv6_set;
13348 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13349 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13351 vat_main_t *vam = &vat_main;
13352 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13353 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13355 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13356 ntohl (mp->sw_if_index),
13357 format_ip46_address, &local, IP46_TYPE_ANY,
13358 format_ip46_address, &remote, IP46_TYPE_ANY,
13359 ntohl (mp->vni), mp->protocol,
13360 ntohl (mp->mcast_sw_if_index),
13361 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13365 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13366 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13368 vat_main_t *vam = &vat_main;
13369 vat_json_node_t *node = NULL;
13370 struct in_addr ip4;
13371 struct in6_addr ip6;
13373 if (VAT_JSON_ARRAY != vam->json_tree.type)
13375 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13376 vat_json_init_array (&vam->json_tree);
13378 node = vat_json_array_add (&vam->json_tree);
13380 vat_json_init_object (node);
13381 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13384 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13385 vat_json_object_add_ip6 (node, "local", ip6);
13386 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13387 vat_json_object_add_ip6 (node, "remote", ip6);
13391 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13392 vat_json_object_add_ip4 (node, "local", ip4);
13393 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13394 vat_json_object_add_ip4 (node, "remote", ip4);
13396 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13397 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13398 vat_json_object_add_uint (node, "mcast_sw_if_index",
13399 ntohl (mp->mcast_sw_if_index));
13400 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13401 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13402 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13406 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13408 unformat_input_t *i = vam->input;
13409 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13410 vl_api_control_ping_t *mp_ping;
13412 u8 sw_if_index_set = 0;
13415 /* Parse args required to build the message */
13416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13418 if (unformat (i, "sw_if_index %d", &sw_if_index))
13419 sw_if_index_set = 1;
13424 if (sw_if_index_set == 0)
13429 if (!vam->json_output)
13431 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13432 "sw_if_index", "local", "remote", "vni",
13433 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13436 /* Get list of vxlan-tunnel interfaces */
13437 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13439 mp->sw_if_index = htonl (sw_if_index);
13443 /* Use a control ping for synchronization */
13444 MPING (CONTROL_PING, mp_ping);
13451 static void vl_api_l2_fib_table_details_t_handler
13452 (vl_api_l2_fib_table_details_t * mp)
13454 vat_main_t *vam = &vat_main;
13456 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13458 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13459 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13463 static void vl_api_l2_fib_table_details_t_handler_json
13464 (vl_api_l2_fib_table_details_t * mp)
13466 vat_main_t *vam = &vat_main;
13467 vat_json_node_t *node = NULL;
13469 if (VAT_JSON_ARRAY != vam->json_tree.type)
13471 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13472 vat_json_init_array (&vam->json_tree);
13474 node = vat_json_array_add (&vam->json_tree);
13476 vat_json_init_object (node);
13477 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13478 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13479 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13480 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13481 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13482 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13486 api_l2_fib_table_dump (vat_main_t * vam)
13488 unformat_input_t *i = vam->input;
13489 vl_api_l2_fib_table_dump_t *mp;
13490 vl_api_control_ping_t *mp_ping;
13495 /* Parse args required to build the message */
13496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13498 if (unformat (i, "bd_id %d", &bd_id))
13504 if (bd_id_set == 0)
13506 errmsg ("missing bridge domain");
13510 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13512 /* Get list of l2 fib entries */
13513 M (L2_FIB_TABLE_DUMP, mp);
13515 mp->bd_id = ntohl (bd_id);
13518 /* Use a control ping for synchronization */
13519 MPING (CONTROL_PING, mp_ping);
13528 api_interface_name_renumber (vat_main_t * vam)
13530 unformat_input_t *line_input = vam->input;
13531 vl_api_interface_name_renumber_t *mp;
13532 u32 sw_if_index = ~0;
13533 u32 new_show_dev_instance = ~0;
13536 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13538 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13541 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13543 else if (unformat (line_input, "new_show_dev_instance %d",
13544 &new_show_dev_instance))
13550 if (sw_if_index == ~0)
13552 errmsg ("missing interface name or sw_if_index");
13556 if (new_show_dev_instance == ~0)
13558 errmsg ("missing new_show_dev_instance");
13562 M (INTERFACE_NAME_RENUMBER, mp);
13564 mp->sw_if_index = ntohl (sw_if_index);
13565 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13573 api_ip_probe_neighbor (vat_main_t * vam)
13575 unformat_input_t *i = vam->input;
13576 vl_api_ip_probe_neighbor_t *mp;
13577 vl_api_address_t dst_adr = { };
13583 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13585 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13587 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13589 else if (unformat (i, "address %U", unformat_vl_api_address, &dst_adr))
13597 errmsg ("missing interface");
13603 errmsg ("missing addresses");
13607 M (IP_PROBE_NEIGHBOR, mp);
13609 mp->sw_if_index = ntohl (sw_if_index);
13610 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
13618 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
13620 unformat_input_t *i = vam->input;
13621 vl_api_ip_scan_neighbor_enable_disable_t *mp;
13622 u8 mode = IP_SCAN_V46_NEIGHBORS;
13623 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
13626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13628 if (unformat (i, "ip4"))
13629 mode = IP_SCAN_V4_NEIGHBORS;
13630 else if (unformat (i, "ip6"))
13631 mode = IP_SCAN_V6_NEIGHBORS;
13632 if (unformat (i, "both"))
13633 mode = IP_SCAN_V46_NEIGHBORS;
13634 else if (unformat (i, "disable"))
13635 mode = IP_SCAN_DISABLED;
13636 else if (unformat (i, "interval %d", &interval))
13638 else if (unformat (i, "max-time %d", &time))
13640 else if (unformat (i, "max-update %d", &update))
13642 else if (unformat (i, "delay %d", &delay))
13644 else if (unformat (i, "stale %d", &stale))
13650 if (interval > 255)
13652 errmsg ("interval cannot exceed 255 minutes.");
13657 errmsg ("max-time cannot exceed 255 usec.");
13662 errmsg ("max-update cannot exceed 255.");
13667 errmsg ("delay cannot exceed 255 msec.");
13672 errmsg ("stale cannot exceed 255 minutes.");
13676 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
13678 mp->scan_interval = interval;
13679 mp->max_proc_time = time;
13680 mp->max_update = update;
13681 mp->scan_int_delay = delay;
13682 mp->stale_threshold = stale;
13690 api_want_ip4_arp_events (vat_main_t * vam)
13692 unformat_input_t *line_input = vam->input;
13693 vl_api_want_ip4_arp_events_t *mp;
13694 ip4_address_t address;
13695 int address_set = 0;
13696 u32 enable_disable = 1;
13699 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13701 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13703 else if (unformat (line_input, "del"))
13704 enable_disable = 0;
13709 if (address_set == 0)
13711 errmsg ("missing addresses");
13715 M (WANT_IP4_ARP_EVENTS, mp);
13716 mp->enable_disable = enable_disable;
13717 mp->pid = htonl (getpid ());
13718 clib_memcpy (mp->ip, &address, sizeof (address));
13726 api_want_ip6_nd_events (vat_main_t * vam)
13728 unformat_input_t *line_input = vam->input;
13729 vl_api_want_ip6_nd_events_t *mp;
13730 vl_api_ip6_address_t address;
13731 int address_set = 0;
13732 u32 enable_disable = 1;
13735 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13738 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
13740 else if (unformat (line_input, "del"))
13741 enable_disable = 0;
13746 if (address_set == 0)
13748 errmsg ("missing addresses");
13752 M (WANT_IP6_ND_EVENTS, mp);
13753 mp->enable_disable = enable_disable;
13754 mp->pid = htonl (getpid ());
13755 clib_memcpy (&mp->ip, &address, sizeof (address));
13763 api_want_l2_macs_events (vat_main_t * vam)
13765 unformat_input_t *line_input = vam->input;
13766 vl_api_want_l2_macs_events_t *mp;
13767 u8 enable_disable = 1;
13768 u32 scan_delay = 0;
13769 u32 max_macs_in_event = 0;
13770 u32 learn_limit = 0;
13773 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13775 if (unformat (line_input, "learn-limit %d", &learn_limit))
13777 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13779 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13781 else if (unformat (line_input, "disable"))
13782 enable_disable = 0;
13787 M (WANT_L2_MACS_EVENTS, mp);
13788 mp->enable_disable = enable_disable;
13789 mp->pid = htonl (getpid ());
13790 mp->learn_limit = htonl (learn_limit);
13791 mp->scan_delay = (u8) scan_delay;
13792 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13799 api_input_acl_set_interface (vat_main_t * vam)
13801 unformat_input_t *i = vam->input;
13802 vl_api_input_acl_set_interface_t *mp;
13804 int sw_if_index_set;
13805 u32 ip4_table_index = ~0;
13806 u32 ip6_table_index = ~0;
13807 u32 l2_table_index = ~0;
13811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13813 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13814 sw_if_index_set = 1;
13815 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13816 sw_if_index_set = 1;
13817 else if (unformat (i, "del"))
13819 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13821 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13823 else if (unformat (i, "l2-table %d", &l2_table_index))
13827 clib_warning ("parse error '%U'", format_unformat_error, i);
13832 if (sw_if_index_set == 0)
13834 errmsg ("missing interface name or sw_if_index");
13838 M (INPUT_ACL_SET_INTERFACE, mp);
13840 mp->sw_if_index = ntohl (sw_if_index);
13841 mp->ip4_table_index = ntohl (ip4_table_index);
13842 mp->ip6_table_index = ntohl (ip6_table_index);
13843 mp->l2_table_index = ntohl (l2_table_index);
13844 mp->is_add = is_add;
13852 api_output_acl_set_interface (vat_main_t * vam)
13854 unformat_input_t *i = vam->input;
13855 vl_api_output_acl_set_interface_t *mp;
13857 int sw_if_index_set;
13858 u32 ip4_table_index = ~0;
13859 u32 ip6_table_index = ~0;
13860 u32 l2_table_index = ~0;
13864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13866 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13867 sw_if_index_set = 1;
13868 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13869 sw_if_index_set = 1;
13870 else if (unformat (i, "del"))
13872 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13874 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13876 else if (unformat (i, "l2-table %d", &l2_table_index))
13880 clib_warning ("parse error '%U'", format_unformat_error, i);
13885 if (sw_if_index_set == 0)
13887 errmsg ("missing interface name or sw_if_index");
13891 M (OUTPUT_ACL_SET_INTERFACE, mp);
13893 mp->sw_if_index = ntohl (sw_if_index);
13894 mp->ip4_table_index = ntohl (ip4_table_index);
13895 mp->ip6_table_index = ntohl (ip6_table_index);
13896 mp->l2_table_index = ntohl (l2_table_index);
13897 mp->is_add = is_add;
13905 api_ip_address_dump (vat_main_t * vam)
13907 unformat_input_t *i = vam->input;
13908 vl_api_ip_address_dump_t *mp;
13909 vl_api_control_ping_t *mp_ping;
13910 u32 sw_if_index = ~0;
13911 u8 sw_if_index_set = 0;
13916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13918 if (unformat (i, "sw_if_index %d", &sw_if_index))
13919 sw_if_index_set = 1;
13921 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13922 sw_if_index_set = 1;
13923 else if (unformat (i, "ipv4"))
13925 else if (unformat (i, "ipv6"))
13931 if (ipv4_set && ipv6_set)
13933 errmsg ("ipv4 and ipv6 flags cannot be both set");
13937 if ((!ipv4_set) && (!ipv6_set))
13939 errmsg ("no ipv4 nor ipv6 flag set");
13943 if (sw_if_index_set == 0)
13945 errmsg ("missing interface name or sw_if_index");
13949 vam->current_sw_if_index = sw_if_index;
13950 vam->is_ipv6 = ipv6_set;
13952 M (IP_ADDRESS_DUMP, mp);
13953 mp->sw_if_index = ntohl (sw_if_index);
13954 mp->is_ipv6 = ipv6_set;
13957 /* Use a control ping for synchronization */
13958 MPING (CONTROL_PING, mp_ping);
13966 api_ip_dump (vat_main_t * vam)
13968 vl_api_ip_dump_t *mp;
13969 vl_api_control_ping_t *mp_ping;
13970 unformat_input_t *in = vam->input;
13977 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13979 if (unformat (in, "ipv4"))
13981 else if (unformat (in, "ipv6"))
13987 if (ipv4_set && ipv6_set)
13989 errmsg ("ipv4 and ipv6 flags cannot be both set");
13993 if ((!ipv4_set) && (!ipv6_set))
13995 errmsg ("no ipv4 nor ipv6 flag set");
13999 is_ipv6 = ipv6_set;
14000 vam->is_ipv6 = is_ipv6;
14002 /* free old data */
14003 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14005 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14007 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14010 mp->is_ipv6 = ipv6_set;
14013 /* Use a control ping for synchronization */
14014 MPING (CONTROL_PING, mp_ping);
14022 api_ipsec_spd_add_del (vat_main_t * vam)
14024 unformat_input_t *i = vam->input;
14025 vl_api_ipsec_spd_add_del_t *mp;
14030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14032 if (unformat (i, "spd_id %d", &spd_id))
14034 else if (unformat (i, "del"))
14038 clib_warning ("parse error '%U'", format_unformat_error, i);
14044 errmsg ("spd_id must be set");
14048 M (IPSEC_SPD_ADD_DEL, mp);
14050 mp->spd_id = ntohl (spd_id);
14051 mp->is_add = is_add;
14059 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14061 unformat_input_t *i = vam->input;
14062 vl_api_ipsec_interface_add_del_spd_t *mp;
14064 u8 sw_if_index_set = 0;
14065 u32 spd_id = (u32) ~ 0;
14069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14071 if (unformat (i, "del"))
14073 else if (unformat (i, "spd_id %d", &spd_id))
14076 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14077 sw_if_index_set = 1;
14078 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14079 sw_if_index_set = 1;
14082 clib_warning ("parse error '%U'", format_unformat_error, i);
14088 if (spd_id == (u32) ~ 0)
14090 errmsg ("spd_id must be set");
14094 if (sw_if_index_set == 0)
14096 errmsg ("missing interface name or sw_if_index");
14100 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14102 mp->spd_id = ntohl (spd_id);
14103 mp->sw_if_index = ntohl (sw_if_index);
14104 mp->is_add = is_add;
14112 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14114 unformat_input_t *i = vam->input;
14115 vl_api_ipsec_spd_entry_add_del_t *mp;
14116 u8 is_add = 1, is_outbound = 0;
14117 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14119 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14120 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14121 vl_api_address_t laddr_start = { }, laddr_stop =
14130 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14132 if (unformat (i, "del"))
14134 if (unformat (i, "outbound"))
14136 if (unformat (i, "inbound"))
14138 else if (unformat (i, "spd_id %d", &spd_id))
14140 else if (unformat (i, "sa_id %d", &sa_id))
14142 else if (unformat (i, "priority %d", &priority))
14144 else if (unformat (i, "protocol %d", &protocol))
14146 else if (unformat (i, "lport_start %d", &lport_start))
14148 else if (unformat (i, "lport_stop %d", &lport_stop))
14150 else if (unformat (i, "rport_start %d", &rport_start))
14152 else if (unformat (i, "rport_stop %d", &rport_stop))
14154 else if (unformat (i, "laddr_start %U",
14155 unformat_vl_api_address, &laddr_start))
14157 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14160 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14163 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14167 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14169 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14171 clib_warning ("unsupported action: 'resolve'");
14177 clib_warning ("parse error '%U'", format_unformat_error, i);
14183 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14185 mp->is_add = is_add;
14187 mp->entry.spd_id = ntohl (spd_id);
14188 mp->entry.priority = ntohl (priority);
14189 mp->entry.is_outbound = is_outbound;
14191 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14192 sizeof (vl_api_address_t));
14193 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14194 sizeof (vl_api_address_t));
14195 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14196 sizeof (vl_api_address_t));
14197 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14198 sizeof (vl_api_address_t));
14200 mp->entry.protocol = (u8) protocol;
14201 mp->entry.local_port_start = ntohs ((u16) lport_start);
14202 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14203 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14204 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14205 mp->entry.policy = (u8) policy;
14206 mp->entry.sa_id = ntohl (sa_id);
14214 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14216 unformat_input_t *i = vam->input;
14217 vl_api_ipsec_sad_entry_add_del_t *mp;
14218 u32 sad_id = 0, spi = 0;
14219 u8 *ck = 0, *ik = 0;
14222 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14223 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14224 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14225 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14226 vl_api_address_t tun_src, tun_dst;
14229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14231 if (unformat (i, "del"))
14233 else if (unformat (i, "sad_id %d", &sad_id))
14235 else if (unformat (i, "spi %d", &spi))
14237 else if (unformat (i, "esp"))
14238 protocol = IPSEC_API_PROTO_ESP;
14240 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14242 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14243 if (ADDRESS_IP6 == tun_src.af)
14244 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14247 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14249 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14250 if (ADDRESS_IP6 == tun_src.af)
14251 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14254 if (unformat (i, "crypto_alg %U",
14255 unformat_ipsec_api_crypto_alg, &crypto_alg))
14257 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14259 else if (unformat (i, "integ_alg %U",
14260 unformat_ipsec_api_integ_alg, &integ_alg))
14262 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14266 clib_warning ("parse error '%U'", format_unformat_error, i);
14272 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14274 mp->is_add = is_add;
14275 mp->entry.sad_id = ntohl (sad_id);
14276 mp->entry.protocol = protocol;
14277 mp->entry.spi = ntohl (spi);
14278 mp->entry.flags = flags;
14280 mp->entry.crypto_algorithm = crypto_alg;
14281 mp->entry.integrity_algorithm = integ_alg;
14282 mp->entry.crypto_key.length = vec_len (ck);
14283 mp->entry.integrity_key.length = vec_len (ik);
14285 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14286 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14288 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14289 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14292 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14294 clib_memcpy (mp->entry.integrity_key.data, ik,
14295 mp->entry.integrity_key.length);
14297 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14299 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14300 sizeof (mp->entry.tunnel_src));
14301 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14302 sizeof (mp->entry.tunnel_dst));
14311 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14313 unformat_input_t *i = vam->input;
14314 vl_api_ipsec_tunnel_if_add_del_t *mp;
14315 u32 local_spi = 0, remote_spi = 0;
14316 u32 crypto_alg = 0, integ_alg = 0;
14317 u8 *lck = NULL, *rck = NULL;
14318 u8 *lik = NULL, *rik = NULL;
14319 vl_api_address_t local_ip = { 0 };
14320 vl_api_address_t remote_ip = { 0 };
14324 u8 anti_replay = 0;
14330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14332 if (unformat (i, "del"))
14334 else if (unformat (i, "esn"))
14336 else if (unformat (i, "anti-replay"))
14338 else if (unformat (i, "count %d", &count))
14340 else if (unformat (i, "local_spi %d", &local_spi))
14342 else if (unformat (i, "remote_spi %d", &remote_spi))
14345 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14348 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14350 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14353 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14355 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14357 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14361 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
14363 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
14365 errmsg ("unsupported crypto-alg: '%U'\n",
14366 format_ipsec_crypto_alg, crypto_alg);
14372 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
14374 if (integ_alg >= IPSEC_INTEG_N_ALG)
14376 errmsg ("unsupported integ-alg: '%U'\n",
14377 format_ipsec_integ_alg, integ_alg);
14381 else if (unformat (i, "instance %u", &instance))
14385 errmsg ("parse error '%U'\n", format_unformat_error, i);
14392 /* Turn on async mode */
14393 vam->async_mode = 1;
14394 vam->async_errors = 0;
14395 before = vat_time_now (vam);
14398 for (jj = 0; jj < count; jj++)
14400 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14402 mp->is_add = is_add;
14404 mp->anti_replay = anti_replay;
14407 increment_address (&remote_ip);
14409 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
14410 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
14412 mp->local_spi = htonl (local_spi + jj);
14413 mp->remote_spi = htonl (remote_spi + jj);
14414 mp->crypto_alg = (u8) crypto_alg;
14416 mp->local_crypto_key_len = 0;
14419 mp->local_crypto_key_len = vec_len (lck);
14420 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14421 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14422 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14425 mp->remote_crypto_key_len = 0;
14428 mp->remote_crypto_key_len = vec_len (rck);
14429 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14430 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14431 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14434 mp->integ_alg = (u8) integ_alg;
14436 mp->local_integ_key_len = 0;
14439 mp->local_integ_key_len = vec_len (lik);
14440 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14441 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14442 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14445 mp->remote_integ_key_len = 0;
14448 mp->remote_integ_key_len = vec_len (rik);
14449 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14450 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14451 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14456 mp->renumber = renumber;
14457 mp->show_instance = ntohl (instance);
14462 /* When testing multiple add/del ops, use a control-ping to sync */
14465 vl_api_control_ping_t *mp_ping;
14469 /* Shut off async mode */
14470 vam->async_mode = 0;
14472 MPING (CONTROL_PING, mp_ping);
14475 timeout = vat_time_now (vam) + 1.0;
14476 while (vat_time_now (vam) < timeout)
14477 if (vam->result_ready == 1)
14482 if (vam->retval == -99)
14483 errmsg ("timeout");
14485 if (vam->async_errors > 0)
14487 errmsg ("%d asynchronous errors", vam->async_errors);
14490 vam->async_errors = 0;
14491 after = vat_time_now (vam);
14493 /* slim chance, but we might have eaten SIGTERM on the first iteration */
14497 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
14498 count, after - before, count / (after - before));
14502 /* Wait for a reply... */
14511 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14513 vat_main_t *vam = &vat_main;
14515 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14516 "crypto_key %U integ_alg %u integ_key %U flags %x "
14517 "tunnel_src_addr %U tunnel_dst_addr %U "
14518 "salt %u seq_outbound %lu last_seq_inbound %lu "
14519 "replay_window %lu\n",
14520 ntohl (mp->entry.sad_id),
14521 ntohl (mp->sw_if_index),
14522 ntohl (mp->entry.spi),
14523 ntohl (mp->entry.protocol),
14524 ntohl (mp->entry.crypto_algorithm),
14525 format_hex_bytes, mp->entry.crypto_key.data,
14526 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
14527 format_hex_bytes, mp->entry.integrity_key.data,
14528 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
14529 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
14530 &mp->entry.tunnel_dst, ntohl (mp->salt),
14531 clib_net_to_host_u64 (mp->seq_outbound),
14532 clib_net_to_host_u64 (mp->last_seq_inbound),
14533 clib_net_to_host_u64 (mp->replay_window));
14536 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14537 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14539 static void vl_api_ipsec_sa_details_t_handler_json
14540 (vl_api_ipsec_sa_details_t * mp)
14542 vat_main_t *vam = &vat_main;
14543 vat_json_node_t *node = NULL;
14544 vl_api_ipsec_sad_flags_t flags;
14546 if (VAT_JSON_ARRAY != vam->json_tree.type)
14548 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14549 vat_json_init_array (&vam->json_tree);
14551 node = vat_json_array_add (&vam->json_tree);
14553 vat_json_init_object (node);
14554 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
14555 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14556 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
14557 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
14558 vat_json_object_add_uint (node, "crypto_alg",
14559 ntohl (mp->entry.crypto_algorithm));
14560 vat_json_object_add_uint (node, "integ_alg",
14561 ntohl (mp->entry.integrity_algorithm));
14562 flags = ntohl (mp->entry.flags);
14563 vat_json_object_add_uint (node, "use_esn",
14564 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
14565 vat_json_object_add_uint (node, "use_anti_replay",
14566 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
14567 vat_json_object_add_uint (node, "is_tunnel",
14568 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
14569 vat_json_object_add_uint (node, "is_tunnel_ip6",
14570 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
14571 vat_json_object_add_uint (node, "udp_encap",
14572 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
14573 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
14574 mp->entry.crypto_key.length);
14575 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
14576 mp->entry.integrity_key.length);
14577 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
14578 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
14579 vat_json_object_add_uint (node, "replay_window",
14580 clib_net_to_host_u64 (mp->replay_window));
14584 api_ipsec_sa_dump (vat_main_t * vam)
14586 unformat_input_t *i = vam->input;
14587 vl_api_ipsec_sa_dump_t *mp;
14588 vl_api_control_ping_t *mp_ping;
14592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14594 if (unformat (i, "sa_id %d", &sa_id))
14598 clib_warning ("parse error '%U'", format_unformat_error, i);
14603 M (IPSEC_SA_DUMP, mp);
14605 mp->sa_id = ntohl (sa_id);
14609 /* Use a control ping for synchronization */
14610 M (CONTROL_PING, mp_ping);
14618 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14620 unformat_input_t *i = vam->input;
14621 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14622 u32 sw_if_index = ~0;
14624 u8 is_outbound = (u8) ~ 0;
14627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14629 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14631 else if (unformat (i, "sa_id %d", &sa_id))
14633 else if (unformat (i, "outbound"))
14635 else if (unformat (i, "inbound"))
14639 clib_warning ("parse error '%U'", format_unformat_error, i);
14644 if (sw_if_index == ~0)
14646 errmsg ("interface must be specified");
14652 errmsg ("SA ID must be specified");
14656 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14658 mp->sw_if_index = htonl (sw_if_index);
14659 mp->sa_id = htonl (sa_id);
14660 mp->is_outbound = is_outbound;
14669 api_get_first_msg_id (vat_main_t * vam)
14671 vl_api_get_first_msg_id_t *mp;
14672 unformat_input_t *i = vam->input;
14677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14679 if (unformat (i, "client %s", &name))
14687 errmsg ("missing client name");
14690 vec_add1 (name, 0);
14692 if (vec_len (name) > 63)
14694 errmsg ("client name too long");
14698 M (GET_FIRST_MSG_ID, mp);
14699 clib_memcpy (mp->name, name, vec_len (name));
14706 api_cop_interface_enable_disable (vat_main_t * vam)
14708 unformat_input_t *line_input = vam->input;
14709 vl_api_cop_interface_enable_disable_t *mp;
14710 u32 sw_if_index = ~0;
14711 u8 enable_disable = 1;
14714 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14716 if (unformat (line_input, "disable"))
14717 enable_disable = 0;
14718 if (unformat (line_input, "enable"))
14719 enable_disable = 1;
14720 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14721 vam, &sw_if_index))
14723 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14729 if (sw_if_index == ~0)
14731 errmsg ("missing interface name or sw_if_index");
14735 /* Construct the API message */
14736 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14737 mp->sw_if_index = ntohl (sw_if_index);
14738 mp->enable_disable = enable_disable;
14742 /* Wait for the reply */
14748 api_cop_whitelist_enable_disable (vat_main_t * vam)
14750 unformat_input_t *line_input = vam->input;
14751 vl_api_cop_whitelist_enable_disable_t *mp;
14752 u32 sw_if_index = ~0;
14753 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14757 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14759 if (unformat (line_input, "ip4"))
14761 else if (unformat (line_input, "ip6"))
14763 else if (unformat (line_input, "default"))
14765 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14766 vam, &sw_if_index))
14768 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14770 else if (unformat (line_input, "fib-id %d", &fib_id))
14776 if (sw_if_index == ~0)
14778 errmsg ("missing interface name or sw_if_index");
14782 /* Construct the API message */
14783 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14784 mp->sw_if_index = ntohl (sw_if_index);
14785 mp->fib_id = ntohl (fib_id);
14788 mp->default_cop = default_cop;
14792 /* Wait for the reply */
14798 api_get_node_graph (vat_main_t * vam)
14800 vl_api_get_node_graph_t *mp;
14803 M (GET_NODE_GRAPH, mp);
14807 /* Wait for the reply */
14813 /** Used for parsing LISP eids */
14814 typedef CLIB_PACKED(struct{
14815 u8 addr[16]; /**< eid address */
14816 u32 len; /**< prefix length if IP */
14817 u8 type; /**< type of eid */
14822 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14824 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14826 clib_memset (a, 0, sizeof (a[0]));
14828 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14830 a->type = 0; /* ipv4 type */
14832 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14834 a->type = 1; /* ipv6 type */
14836 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14838 a->type = 2; /* mac type */
14840 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14842 a->type = 3; /* NSH type */
14843 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14844 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14851 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14860 lisp_eid_size_vat (u8 type)
14877 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14879 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14883 api_one_add_del_locator_set (vat_main_t * vam)
14885 unformat_input_t *input = vam->input;
14886 vl_api_one_add_del_locator_set_t *mp;
14888 u8 *locator_set_name = NULL;
14889 u8 locator_set_name_set = 0;
14890 vl_api_local_locator_t locator, *locators = 0;
14891 u32 sw_if_index, priority, weight;
14895 /* Parse args required to build the message */
14896 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14898 if (unformat (input, "del"))
14902 else if (unformat (input, "locator-set %s", &locator_set_name))
14904 locator_set_name_set = 1;
14906 else if (unformat (input, "sw_if_index %u p %u w %u",
14907 &sw_if_index, &priority, &weight))
14909 locator.sw_if_index = htonl (sw_if_index);
14910 locator.priority = priority;
14911 locator.weight = weight;
14912 vec_add1 (locators, locator);
14916 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14917 &sw_if_index, &priority, &weight))
14919 locator.sw_if_index = htonl (sw_if_index);
14920 locator.priority = priority;
14921 locator.weight = weight;
14922 vec_add1 (locators, locator);
14928 if (locator_set_name_set == 0)
14930 errmsg ("missing locator-set name");
14931 vec_free (locators);
14935 if (vec_len (locator_set_name) > 64)
14937 errmsg ("locator-set name too long");
14938 vec_free (locator_set_name);
14939 vec_free (locators);
14942 vec_add1 (locator_set_name, 0);
14944 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14946 /* Construct the API message */
14947 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14949 mp->is_add = is_add;
14950 clib_memcpy (mp->locator_set_name, locator_set_name,
14951 vec_len (locator_set_name));
14952 vec_free (locator_set_name);
14954 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14956 clib_memcpy (mp->locators, locators, data_len);
14957 vec_free (locators);
14962 /* Wait for a reply... */
14967 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14970 api_one_add_del_locator (vat_main_t * vam)
14972 unformat_input_t *input = vam->input;
14973 vl_api_one_add_del_locator_t *mp;
14974 u32 tmp_if_index = ~0;
14975 u32 sw_if_index = ~0;
14976 u8 sw_if_index_set = 0;
14977 u8 sw_if_index_if_name_set = 0;
14979 u8 priority_set = 0;
14983 u8 *locator_set_name = NULL;
14984 u8 locator_set_name_set = 0;
14987 /* Parse args required to build the message */
14988 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14990 if (unformat (input, "del"))
14994 else if (unformat (input, "locator-set %s", &locator_set_name))
14996 locator_set_name_set = 1;
14998 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15001 sw_if_index_if_name_set = 1;
15002 sw_if_index = tmp_if_index;
15004 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15006 sw_if_index_set = 1;
15007 sw_if_index = tmp_if_index;
15009 else if (unformat (input, "p %d", &priority))
15013 else if (unformat (input, "w %d", &weight))
15021 if (locator_set_name_set == 0)
15023 errmsg ("missing locator-set name");
15027 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15029 errmsg ("missing sw_if_index");
15030 vec_free (locator_set_name);
15034 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15036 errmsg ("cannot use both params interface name and sw_if_index");
15037 vec_free (locator_set_name);
15041 if (priority_set == 0)
15043 errmsg ("missing locator-set priority");
15044 vec_free (locator_set_name);
15048 if (weight_set == 0)
15050 errmsg ("missing locator-set weight");
15051 vec_free (locator_set_name);
15055 if (vec_len (locator_set_name) > 64)
15057 errmsg ("locator-set name too long");
15058 vec_free (locator_set_name);
15061 vec_add1 (locator_set_name, 0);
15063 /* Construct the API message */
15064 M (ONE_ADD_DEL_LOCATOR, mp);
15066 mp->is_add = is_add;
15067 mp->sw_if_index = ntohl (sw_if_index);
15068 mp->priority = priority;
15069 mp->weight = weight;
15070 clib_memcpy (mp->locator_set_name, locator_set_name,
15071 vec_len (locator_set_name));
15072 vec_free (locator_set_name);
15077 /* Wait for a reply... */
15082 #define api_lisp_add_del_locator api_one_add_del_locator
15085 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15087 u32 *key_id = va_arg (*args, u32 *);
15090 if (unformat (input, "%s", &s))
15092 if (!strcmp ((char *) s, "sha1"))
15093 key_id[0] = HMAC_SHA_1_96;
15094 else if (!strcmp ((char *) s, "sha256"))
15095 key_id[0] = HMAC_SHA_256_128;
15098 clib_warning ("invalid key_id: '%s'", s);
15099 key_id[0] = HMAC_NO_KEY;
15110 api_one_add_del_local_eid (vat_main_t * vam)
15112 unformat_input_t *input = vam->input;
15113 vl_api_one_add_del_local_eid_t *mp;
15116 lisp_eid_vat_t _eid, *eid = &_eid;
15117 u8 *locator_set_name = 0;
15118 u8 locator_set_name_set = 0;
15124 /* Parse args required to build the message */
15125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15127 if (unformat (input, "del"))
15131 else if (unformat (input, "vni %d", &vni))
15135 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15139 else if (unformat (input, "locator-set %s", &locator_set_name))
15141 locator_set_name_set = 1;
15143 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15145 else if (unformat (input, "secret-key %_%v%_", &key))
15151 if (locator_set_name_set == 0)
15153 errmsg ("missing locator-set name");
15159 errmsg ("EID address not set!");
15160 vec_free (locator_set_name);
15164 if (key && (0 == key_id))
15166 errmsg ("invalid key_id!");
15170 if (vec_len (key) > 64)
15172 errmsg ("key too long");
15177 if (vec_len (locator_set_name) > 64)
15179 errmsg ("locator-set name too long");
15180 vec_free (locator_set_name);
15183 vec_add1 (locator_set_name, 0);
15185 /* Construct the API message */
15186 M (ONE_ADD_DEL_LOCAL_EID, mp);
15188 mp->is_add = is_add;
15189 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15190 mp->eid_type = eid->type;
15191 mp->prefix_len = eid->len;
15192 mp->vni = clib_host_to_net_u32 (vni);
15193 mp->key_id = clib_host_to_net_u16 (key_id);
15194 clib_memcpy (mp->locator_set_name, locator_set_name,
15195 vec_len (locator_set_name));
15196 clib_memcpy (mp->key, key, vec_len (key));
15198 vec_free (locator_set_name);
15204 /* Wait for a reply... */
15209 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15212 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15214 u32 dp_table = 0, vni = 0;;
15215 unformat_input_t *input = vam->input;
15216 vl_api_gpe_add_del_fwd_entry_t *mp;
15218 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15219 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15220 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15221 u32 action = ~0, w;
15222 ip4_address_t rmt_rloc4, lcl_rloc4;
15223 ip6_address_t rmt_rloc6, lcl_rloc6;
15224 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15227 clib_memset (&rloc, 0, sizeof (rloc));
15229 /* Parse args required to build the message */
15230 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15232 if (unformat (input, "del"))
15234 else if (unformat (input, "add"))
15236 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15240 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15244 else if (unformat (input, "vrf %d", &dp_table))
15246 else if (unformat (input, "bd %d", &dp_table))
15248 else if (unformat (input, "vni %d", &vni))
15250 else if (unformat (input, "w %d", &w))
15254 errmsg ("No RLOC configured for setting priority/weight!");
15257 curr_rloc->weight = w;
15259 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15260 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15264 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15266 vec_add1 (lcl_locs, rloc);
15268 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15269 vec_add1 (rmt_locs, rloc);
15270 /* weight saved in rmt loc */
15271 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15273 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15274 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15277 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15279 vec_add1 (lcl_locs, rloc);
15281 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15282 vec_add1 (rmt_locs, rloc);
15283 /* weight saved in rmt loc */
15284 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15286 else if (unformat (input, "action %d", &action))
15292 clib_warning ("parse error '%U'", format_unformat_error, input);
15299 errmsg ("remote eid addresses not set");
15303 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15305 errmsg ("eid types don't match");
15309 if (0 == rmt_locs && (u32) ~ 0 == action)
15311 errmsg ("action not set for negative mapping");
15315 /* Construct the API message */
15316 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15317 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15319 mp->is_add = is_add;
15320 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15321 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15322 mp->eid_type = rmt_eid->type;
15323 mp->dp_table = clib_host_to_net_u32 (dp_table);
15324 mp->vni = clib_host_to_net_u32 (vni);
15325 mp->rmt_len = rmt_eid->len;
15326 mp->lcl_len = lcl_eid->len;
15327 mp->action = action;
15329 if (0 != rmt_locs && 0 != lcl_locs)
15331 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15332 clib_memcpy (mp->locs, lcl_locs,
15333 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15335 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15336 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15337 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15339 vec_free (lcl_locs);
15340 vec_free (rmt_locs);
15345 /* Wait for a reply... */
15351 api_one_add_del_map_server (vat_main_t * vam)
15353 unformat_input_t *input = vam->input;
15354 vl_api_one_add_del_map_server_t *mp;
15358 ip4_address_t ipv4;
15359 ip6_address_t ipv6;
15362 /* Parse args required to build the message */
15363 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15365 if (unformat (input, "del"))
15369 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15373 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15381 if (ipv4_set && ipv6_set)
15383 errmsg ("both eid v4 and v6 addresses set");
15387 if (!ipv4_set && !ipv6_set)
15389 errmsg ("eid addresses not set");
15393 /* Construct the API message */
15394 M (ONE_ADD_DEL_MAP_SERVER, mp);
15396 mp->is_add = is_add;
15400 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15405 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15411 /* Wait for a reply... */
15416 #define api_lisp_add_del_map_server api_one_add_del_map_server
15419 api_one_add_del_map_resolver (vat_main_t * vam)
15421 unformat_input_t *input = vam->input;
15422 vl_api_one_add_del_map_resolver_t *mp;
15426 ip4_address_t ipv4;
15427 ip6_address_t ipv6;
15430 /* Parse args required to build the message */
15431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15433 if (unformat (input, "del"))
15437 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15441 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15449 if (ipv4_set && ipv6_set)
15451 errmsg ("both eid v4 and v6 addresses set");
15455 if (!ipv4_set && !ipv6_set)
15457 errmsg ("eid addresses not set");
15461 /* Construct the API message */
15462 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15464 mp->is_add = is_add;
15468 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15473 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15479 /* Wait for a reply... */
15484 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15487 api_lisp_gpe_enable_disable (vat_main_t * vam)
15489 unformat_input_t *input = vam->input;
15490 vl_api_gpe_enable_disable_t *mp;
15495 /* Parse args required to build the message */
15496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15498 if (unformat (input, "enable"))
15503 else if (unformat (input, "disable"))
15514 errmsg ("Value not set");
15518 /* Construct the API message */
15519 M (GPE_ENABLE_DISABLE, mp);
15526 /* Wait for a reply... */
15532 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15534 unformat_input_t *input = vam->input;
15535 vl_api_one_rloc_probe_enable_disable_t *mp;
15540 /* Parse args required to build the message */
15541 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15543 if (unformat (input, "enable"))
15548 else if (unformat (input, "disable"))
15556 errmsg ("Value not set");
15560 /* Construct the API message */
15561 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15563 mp->is_enabled = is_en;
15568 /* Wait for a reply... */
15573 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15576 api_one_map_register_enable_disable (vat_main_t * vam)
15578 unformat_input_t *input = vam->input;
15579 vl_api_one_map_register_enable_disable_t *mp;
15584 /* Parse args required to build the message */
15585 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15587 if (unformat (input, "enable"))
15592 else if (unformat (input, "disable"))
15600 errmsg ("Value not set");
15604 /* Construct the API message */
15605 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15607 mp->is_enabled = is_en;
15612 /* Wait for a reply... */
15617 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15620 api_one_enable_disable (vat_main_t * vam)
15622 unformat_input_t *input = vam->input;
15623 vl_api_one_enable_disable_t *mp;
15628 /* Parse args required to build the message */
15629 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15631 if (unformat (input, "enable"))
15636 else if (unformat (input, "disable"))
15646 errmsg ("Value not set");
15650 /* Construct the API message */
15651 M (ONE_ENABLE_DISABLE, mp);
15658 /* Wait for a reply... */
15663 #define api_lisp_enable_disable api_one_enable_disable
15666 api_one_enable_disable_xtr_mode (vat_main_t * vam)
15668 unformat_input_t *input = vam->input;
15669 vl_api_one_enable_disable_xtr_mode_t *mp;
15674 /* Parse args required to build the message */
15675 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15677 if (unformat (input, "enable"))
15682 else if (unformat (input, "disable"))
15692 errmsg ("Value not set");
15696 /* Construct the API message */
15697 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15704 /* Wait for a reply... */
15710 api_one_show_xtr_mode (vat_main_t * vam)
15712 vl_api_one_show_xtr_mode_t *mp;
15715 /* Construct the API message */
15716 M (ONE_SHOW_XTR_MODE, mp);
15721 /* Wait for a reply... */
15727 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15729 unformat_input_t *input = vam->input;
15730 vl_api_one_enable_disable_pitr_mode_t *mp;
15735 /* Parse args required to build the message */
15736 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15738 if (unformat (input, "enable"))
15743 else if (unformat (input, "disable"))
15753 errmsg ("Value not set");
15757 /* Construct the API message */
15758 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15765 /* Wait for a reply... */
15771 api_one_show_pitr_mode (vat_main_t * vam)
15773 vl_api_one_show_pitr_mode_t *mp;
15776 /* Construct the API message */
15777 M (ONE_SHOW_PITR_MODE, mp);
15782 /* Wait for a reply... */
15788 api_one_enable_disable_petr_mode (vat_main_t * vam)
15790 unformat_input_t *input = vam->input;
15791 vl_api_one_enable_disable_petr_mode_t *mp;
15796 /* Parse args required to build the message */
15797 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15799 if (unformat (input, "enable"))
15804 else if (unformat (input, "disable"))
15814 errmsg ("Value not set");
15818 /* Construct the API message */
15819 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15826 /* Wait for a reply... */
15832 api_one_show_petr_mode (vat_main_t * vam)
15834 vl_api_one_show_petr_mode_t *mp;
15837 /* Construct the API message */
15838 M (ONE_SHOW_PETR_MODE, mp);
15843 /* Wait for a reply... */
15849 api_show_one_map_register_state (vat_main_t * vam)
15851 vl_api_show_one_map_register_state_t *mp;
15854 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15859 /* wait for reply */
15864 #define api_show_lisp_map_register_state api_show_one_map_register_state
15867 api_show_one_rloc_probe_state (vat_main_t * vam)
15869 vl_api_show_one_rloc_probe_state_t *mp;
15872 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15877 /* wait for reply */
15882 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15885 api_one_add_del_ndp_entry (vat_main_t * vam)
15887 vl_api_one_add_del_ndp_entry_t *mp;
15888 unformat_input_t *input = vam->input;
15893 u8 mac[6] = { 0, };
15894 u8 ip6[16] = { 0, };
15898 /* Parse args required to build the message */
15899 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15901 if (unformat (input, "del"))
15903 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15905 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15907 else if (unformat (input, "bd %d", &bd))
15911 errmsg ("parse error '%U'", format_unformat_error, input);
15916 if (!bd_set || !ip_set || (!mac_set && is_add))
15918 errmsg ("Missing BD, IP or MAC!");
15922 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15923 mp->is_add = is_add;
15924 clib_memcpy (mp->mac, mac, 6);
15925 mp->bd = clib_host_to_net_u32 (bd);
15926 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15931 /* wait for reply */
15937 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15939 vl_api_one_add_del_l2_arp_entry_t *mp;
15940 unformat_input_t *input = vam->input;
15945 u8 mac[6] = { 0, };
15946 u32 ip4 = 0, bd = ~0;
15949 /* Parse args required to build the message */
15950 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15952 if (unformat (input, "del"))
15954 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15956 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15958 else if (unformat (input, "bd %d", &bd))
15962 errmsg ("parse error '%U'", format_unformat_error, input);
15967 if (!bd_set || !ip_set || (!mac_set && is_add))
15969 errmsg ("Missing BD, IP or MAC!");
15973 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15974 mp->is_add = is_add;
15975 clib_memcpy (mp->mac, mac, 6);
15976 mp->bd = clib_host_to_net_u32 (bd);
15982 /* wait for reply */
15988 api_one_ndp_bd_get (vat_main_t * vam)
15990 vl_api_one_ndp_bd_get_t *mp;
15993 M (ONE_NDP_BD_GET, mp);
15998 /* wait for reply */
16004 api_one_ndp_entries_get (vat_main_t * vam)
16006 vl_api_one_ndp_entries_get_t *mp;
16007 unformat_input_t *input = vam->input;
16012 /* Parse args required to build the message */
16013 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16015 if (unformat (input, "bd %d", &bd))
16019 errmsg ("parse error '%U'", format_unformat_error, input);
16026 errmsg ("Expected bridge domain!");
16030 M (ONE_NDP_ENTRIES_GET, mp);
16031 mp->bd = clib_host_to_net_u32 (bd);
16036 /* wait for reply */
16042 api_one_l2_arp_bd_get (vat_main_t * vam)
16044 vl_api_one_l2_arp_bd_get_t *mp;
16047 M (ONE_L2_ARP_BD_GET, mp);
16052 /* wait for reply */
16058 api_one_l2_arp_entries_get (vat_main_t * vam)
16060 vl_api_one_l2_arp_entries_get_t *mp;
16061 unformat_input_t *input = vam->input;
16066 /* Parse args required to build the message */
16067 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16069 if (unformat (input, "bd %d", &bd))
16073 errmsg ("parse error '%U'", format_unformat_error, input);
16080 errmsg ("Expected bridge domain!");
16084 M (ONE_L2_ARP_ENTRIES_GET, mp);
16085 mp->bd = clib_host_to_net_u32 (bd);
16090 /* wait for reply */
16096 api_one_stats_enable_disable (vat_main_t * vam)
16098 vl_api_one_stats_enable_disable_t *mp;
16099 unformat_input_t *input = vam->input;
16104 /* Parse args required to build the message */
16105 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16107 if (unformat (input, "enable"))
16112 else if (unformat (input, "disable"))
16122 errmsg ("Value not set");
16126 M (ONE_STATS_ENABLE_DISABLE, mp);
16132 /* wait for reply */
16138 api_show_one_stats_enable_disable (vat_main_t * vam)
16140 vl_api_show_one_stats_enable_disable_t *mp;
16143 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16148 /* wait for reply */
16154 api_show_one_map_request_mode (vat_main_t * vam)
16156 vl_api_show_one_map_request_mode_t *mp;
16159 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16164 /* wait for reply */
16169 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16172 api_one_map_request_mode (vat_main_t * vam)
16174 unformat_input_t *input = vam->input;
16175 vl_api_one_map_request_mode_t *mp;
16179 /* Parse args required to build the message */
16180 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16182 if (unformat (input, "dst-only"))
16184 else if (unformat (input, "src-dst"))
16188 errmsg ("parse error '%U'", format_unformat_error, input);
16193 M (ONE_MAP_REQUEST_MODE, mp);
16200 /* wait for reply */
16205 #define api_lisp_map_request_mode api_one_map_request_mode
16208 * Enable/disable ONE proxy ITR.
16210 * @param vam vpp API test context
16211 * @return return code
16214 api_one_pitr_set_locator_set (vat_main_t * vam)
16216 u8 ls_name_set = 0;
16217 unformat_input_t *input = vam->input;
16218 vl_api_one_pitr_set_locator_set_t *mp;
16223 /* Parse args required to build the message */
16224 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16226 if (unformat (input, "del"))
16228 else if (unformat (input, "locator-set %s", &ls_name))
16232 errmsg ("parse error '%U'", format_unformat_error, input);
16239 errmsg ("locator-set name not set!");
16243 M (ONE_PITR_SET_LOCATOR_SET, mp);
16245 mp->is_add = is_add;
16246 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16247 vec_free (ls_name);
16252 /* wait for reply */
16257 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16260 api_one_nsh_set_locator_set (vat_main_t * vam)
16262 u8 ls_name_set = 0;
16263 unformat_input_t *input = vam->input;
16264 vl_api_one_nsh_set_locator_set_t *mp;
16269 /* Parse args required to build the message */
16270 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16272 if (unformat (input, "del"))
16274 else if (unformat (input, "ls %s", &ls_name))
16278 errmsg ("parse error '%U'", format_unformat_error, input);
16283 if (!ls_name_set && is_add)
16285 errmsg ("locator-set name not set!");
16289 M (ONE_NSH_SET_LOCATOR_SET, mp);
16291 mp->is_add = is_add;
16292 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16293 vec_free (ls_name);
16298 /* wait for reply */
16304 api_show_one_pitr (vat_main_t * vam)
16306 vl_api_show_one_pitr_t *mp;
16309 if (!vam->json_output)
16311 print (vam->ofp, "%=20s", "lisp status:");
16314 M (SHOW_ONE_PITR, mp);
16318 /* Wait for a reply... */
16323 #define api_show_lisp_pitr api_show_one_pitr
16326 api_one_use_petr (vat_main_t * vam)
16328 unformat_input_t *input = vam->input;
16329 vl_api_one_use_petr_t *mp;
16334 clib_memset (&ip, 0, sizeof (ip));
16336 /* Parse args required to build the message */
16337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16339 if (unformat (input, "disable"))
16342 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16345 ip_addr_version (&ip) = AF_IP4;
16348 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16351 ip_addr_version (&ip) = AF_IP6;
16355 errmsg ("parse error '%U'", format_unformat_error, input);
16360 M (ONE_USE_PETR, mp);
16362 mp->is_add = is_add;
16365 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
16367 clib_memcpy (mp->address, &ip, 4);
16369 clib_memcpy (mp->address, &ip, 16);
16375 /* wait for reply */
16380 #define api_lisp_use_petr api_one_use_petr
16383 api_show_one_nsh_mapping (vat_main_t * vam)
16385 vl_api_show_one_use_petr_t *mp;
16388 if (!vam->json_output)
16390 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16393 M (SHOW_ONE_NSH_MAPPING, mp);
16397 /* Wait for a reply... */
16403 api_show_one_use_petr (vat_main_t * vam)
16405 vl_api_show_one_use_petr_t *mp;
16408 if (!vam->json_output)
16410 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16413 M (SHOW_ONE_USE_PETR, mp);
16417 /* Wait for a reply... */
16422 #define api_show_lisp_use_petr api_show_one_use_petr
16425 * Add/delete mapping between vni and vrf
16428 api_one_eid_table_add_del_map (vat_main_t * vam)
16430 unformat_input_t *input = vam->input;
16431 vl_api_one_eid_table_add_del_map_t *mp;
16432 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16433 u32 vni, vrf, bd_index;
16436 /* Parse args required to build the message */
16437 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16439 if (unformat (input, "del"))
16441 else if (unformat (input, "vrf %d", &vrf))
16443 else if (unformat (input, "bd_index %d", &bd_index))
16445 else if (unformat (input, "vni %d", &vni))
16451 if (!vni_set || (!vrf_set && !bd_index_set))
16453 errmsg ("missing arguments!");
16457 if (vrf_set && bd_index_set)
16459 errmsg ("error: both vrf and bd entered!");
16463 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16465 mp->is_add = is_add;
16466 mp->vni = htonl (vni);
16467 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16468 mp->is_l2 = bd_index_set;
16473 /* wait for reply */
16478 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16481 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16483 u32 *action = va_arg (*args, u32 *);
16486 if (unformat (input, "%s", &s))
16488 if (!strcmp ((char *) s, "no-action"))
16490 else if (!strcmp ((char *) s, "natively-forward"))
16492 else if (!strcmp ((char *) s, "send-map-request"))
16494 else if (!strcmp ((char *) s, "drop"))
16498 clib_warning ("invalid action: '%s'", s);
16510 * Add/del remote mapping to/from ONE control plane
16512 * @param vam vpp API test context
16513 * @return return code
16516 api_one_add_del_remote_mapping (vat_main_t * vam)
16518 unformat_input_t *input = vam->input;
16519 vl_api_one_add_del_remote_mapping_t *mp;
16521 lisp_eid_vat_t _eid, *eid = &_eid;
16522 lisp_eid_vat_t _seid, *seid = &_seid;
16523 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
16524 u32 action = ~0, p, w, data_len;
16525 ip4_address_t rloc4;
16526 ip6_address_t rloc6;
16527 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
16530 clib_memset (&rloc, 0, sizeof (rloc));
16532 /* Parse args required to build the message */
16533 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16535 if (unformat (input, "del-all"))
16539 else if (unformat (input, "del"))
16543 else if (unformat (input, "add"))
16547 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16551 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
16555 else if (unformat (input, "vni %d", &vni))
16559 else if (unformat (input, "p %d w %d", &p, &w))
16563 errmsg ("No RLOC configured for setting priority/weight!");
16566 curr_rloc->priority = p;
16567 curr_rloc->weight = w;
16569 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
16572 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
16573 vec_add1 (rlocs, rloc);
16574 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16576 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
16579 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
16580 vec_add1 (rlocs, rloc);
16581 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16583 else if (unformat (input, "action %U",
16584 unformat_negative_mapping_action, &action))
16590 clib_warning ("parse error '%U'", format_unformat_error, input);
16597 errmsg ("missing params!");
16601 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16603 errmsg ("no action set for negative map-reply!");
16607 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16609 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16610 mp->is_add = is_add;
16611 mp->vni = htonl (vni);
16612 mp->action = (u8) action;
16613 mp->is_src_dst = seid_set;
16614 mp->eid_len = eid->len;
16615 mp->seid_len = seid->len;
16616 mp->del_all = del_all;
16617 mp->eid_type = eid->type;
16618 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16619 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
16621 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
16622 clib_memcpy (mp->rlocs, rlocs, data_len);
16628 /* Wait for a reply... */
16633 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
16636 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
16637 * forwarding entries in data-plane accordingly.
16639 * @param vam vpp API test context
16640 * @return return code
16643 api_one_add_del_adjacency (vat_main_t * vam)
16645 unformat_input_t *input = vam->input;
16646 vl_api_one_add_del_adjacency_t *mp;
16648 ip4_address_t leid4, reid4;
16649 ip6_address_t leid6, reid6;
16650 u8 reid_mac[6] = { 0 };
16651 u8 leid_mac[6] = { 0 };
16652 u8 reid_type, leid_type;
16653 u32 leid_len = 0, reid_len = 0, len;
16657 leid_type = reid_type = (u8) ~ 0;
16659 /* Parse args required to build the message */
16660 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16662 if (unformat (input, "del"))
16666 else if (unformat (input, "add"))
16670 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
16673 reid_type = 0; /* ipv4 */
16676 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
16679 reid_type = 1; /* ipv6 */
16682 else if (unformat (input, "reid %U", unformat_ethernet_address,
16685 reid_type = 2; /* mac */
16687 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
16690 leid_type = 0; /* ipv4 */
16693 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
16696 leid_type = 1; /* ipv6 */
16699 else if (unformat (input, "leid %U", unformat_ethernet_address,
16702 leid_type = 2; /* mac */
16704 else if (unformat (input, "vni %d", &vni))
16710 errmsg ("parse error '%U'", format_unformat_error, input);
16715 if ((u8) ~ 0 == reid_type)
16717 errmsg ("missing params!");
16721 if (leid_type != reid_type)
16723 errmsg ("remote and local EIDs are of different types!");
16727 M (ONE_ADD_DEL_ADJACENCY, mp);
16728 mp->is_add = is_add;
16729 mp->vni = htonl (vni);
16730 mp->leid_len = leid_len;
16731 mp->reid_len = reid_len;
16732 mp->eid_type = reid_type;
16734 switch (mp->eid_type)
16737 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16738 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16741 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16742 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16745 clib_memcpy (mp->leid, leid_mac, 6);
16746 clib_memcpy (mp->reid, reid_mac, 6);
16749 errmsg ("unknown EID type %d!", mp->eid_type);
16756 /* Wait for a reply... */
16761 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16764 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16766 u32 *mode = va_arg (*args, u32 *);
16768 if (unformat (input, "lisp"))
16770 else if (unformat (input, "vxlan"))
16779 api_gpe_get_encap_mode (vat_main_t * vam)
16781 vl_api_gpe_get_encap_mode_t *mp;
16784 /* Construct the API message */
16785 M (GPE_GET_ENCAP_MODE, mp);
16790 /* Wait for a reply... */
16796 api_gpe_set_encap_mode (vat_main_t * vam)
16798 unformat_input_t *input = vam->input;
16799 vl_api_gpe_set_encap_mode_t *mp;
16803 /* Parse args required to build the message */
16804 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16806 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16812 /* Construct the API message */
16813 M (GPE_SET_ENCAP_MODE, mp);
16820 /* Wait for a reply... */
16826 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16828 unformat_input_t *input = vam->input;
16829 vl_api_gpe_add_del_iface_t *mp;
16830 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16831 u32 dp_table = 0, vni = 0;
16834 /* Parse args required to build the message */
16835 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16837 if (unformat (input, "up"))
16842 else if (unformat (input, "down"))
16847 else if (unformat (input, "table_id %d", &dp_table))
16851 else if (unformat (input, "bd_id %d", &dp_table))
16856 else if (unformat (input, "vni %d", &vni))
16864 if (action_set == 0)
16866 errmsg ("Action not set");
16869 if (dp_table_set == 0 || vni_set == 0)
16871 errmsg ("vni and dp_table must be set");
16875 /* Construct the API message */
16876 M (GPE_ADD_DEL_IFACE, mp);
16878 mp->is_add = is_add;
16879 mp->dp_table = clib_host_to_net_u32 (dp_table);
16881 mp->vni = clib_host_to_net_u32 (vni);
16886 /* Wait for a reply... */
16892 api_one_map_register_fallback_threshold (vat_main_t * vam)
16894 unformat_input_t *input = vam->input;
16895 vl_api_one_map_register_fallback_threshold_t *mp;
16900 /* Parse args required to build the message */
16901 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16903 if (unformat (input, "%u", &value))
16907 clib_warning ("parse error '%U'", format_unformat_error, input);
16914 errmsg ("fallback threshold value is missing!");
16918 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16919 mp->value = clib_host_to_net_u32 (value);
16924 /* Wait for a reply... */
16930 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16932 vl_api_show_one_map_register_fallback_threshold_t *mp;
16935 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16940 /* Wait for a reply... */
16946 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16948 u32 *proto = va_arg (*args, u32 *);
16950 if (unformat (input, "udp"))
16952 else if (unformat (input, "api"))
16961 api_one_set_transport_protocol (vat_main_t * vam)
16963 unformat_input_t *input = vam->input;
16964 vl_api_one_set_transport_protocol_t *mp;
16969 /* Parse args required to build the message */
16970 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16972 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16976 clib_warning ("parse error '%U'", format_unformat_error, input);
16983 errmsg ("Transport protocol missing!");
16987 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16988 mp->protocol = (u8) protocol;
16993 /* Wait for a reply... */
16999 api_one_get_transport_protocol (vat_main_t * vam)
17001 vl_api_one_get_transport_protocol_t *mp;
17004 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17009 /* Wait for a reply... */
17015 api_one_map_register_set_ttl (vat_main_t * vam)
17017 unformat_input_t *input = vam->input;
17018 vl_api_one_map_register_set_ttl_t *mp;
17023 /* Parse args required to build the message */
17024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17026 if (unformat (input, "%u", &ttl))
17030 clib_warning ("parse error '%U'", format_unformat_error, input);
17037 errmsg ("TTL value missing!");
17041 M (ONE_MAP_REGISTER_SET_TTL, mp);
17042 mp->ttl = clib_host_to_net_u32 (ttl);
17047 /* Wait for a reply... */
17053 api_show_one_map_register_ttl (vat_main_t * vam)
17055 vl_api_show_one_map_register_ttl_t *mp;
17058 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17063 /* Wait for a reply... */
17069 * Add/del map request itr rlocs from ONE control plane and updates
17071 * @param vam vpp API test context
17072 * @return return code
17075 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17077 unformat_input_t *input = vam->input;
17078 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17079 u8 *locator_set_name = 0;
17080 u8 locator_set_name_set = 0;
17084 /* Parse args required to build the message */
17085 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17087 if (unformat (input, "del"))
17091 else if (unformat (input, "%_%v%_", &locator_set_name))
17093 locator_set_name_set = 1;
17097 clib_warning ("parse error '%U'", format_unformat_error, input);
17102 if (is_add && !locator_set_name_set)
17104 errmsg ("itr-rloc is not set!");
17108 if (is_add && vec_len (locator_set_name) > 64)
17110 errmsg ("itr-rloc locator-set name too long");
17111 vec_free (locator_set_name);
17115 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17116 mp->is_add = is_add;
17119 clib_memcpy (mp->locator_set_name, locator_set_name,
17120 vec_len (locator_set_name));
17124 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17126 vec_free (locator_set_name);
17131 /* Wait for a reply... */
17136 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17139 api_one_locator_dump (vat_main_t * vam)
17141 unformat_input_t *input = vam->input;
17142 vl_api_one_locator_dump_t *mp;
17143 vl_api_control_ping_t *mp_ping;
17144 u8 is_index_set = 0, is_name_set = 0;
17149 /* Parse args required to build the message */
17150 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17152 if (unformat (input, "ls_name %_%v%_", &ls_name))
17156 else if (unformat (input, "ls_index %d", &ls_index))
17162 errmsg ("parse error '%U'", format_unformat_error, input);
17167 if (!is_index_set && !is_name_set)
17169 errmsg ("error: expected one of index or name!");
17173 if (is_index_set && is_name_set)
17175 errmsg ("error: only one param expected!");
17179 if (vec_len (ls_name) > 62)
17181 errmsg ("error: locator set name too long!");
17185 if (!vam->json_output)
17187 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17190 M (ONE_LOCATOR_DUMP, mp);
17191 mp->is_index_set = is_index_set;
17194 mp->ls_index = clib_host_to_net_u32 (ls_index);
17197 vec_add1 (ls_name, 0);
17198 strncpy ((char *) mp->ls_name, (char *) ls_name,
17199 sizeof (mp->ls_name) - 1);
17205 /* Use a control ping for synchronization */
17206 MPING (CONTROL_PING, mp_ping);
17209 /* Wait for a reply... */
17214 #define api_lisp_locator_dump api_one_locator_dump
17217 api_one_locator_set_dump (vat_main_t * vam)
17219 vl_api_one_locator_set_dump_t *mp;
17220 vl_api_control_ping_t *mp_ping;
17221 unformat_input_t *input = vam->input;
17225 /* Parse args required to build the message */
17226 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17228 if (unformat (input, "local"))
17232 else if (unformat (input, "remote"))
17238 errmsg ("parse error '%U'", format_unformat_error, input);
17243 if (!vam->json_output)
17245 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17248 M (ONE_LOCATOR_SET_DUMP, mp);
17250 mp->filter = filter;
17255 /* Use a control ping for synchronization */
17256 MPING (CONTROL_PING, mp_ping);
17259 /* Wait for a reply... */
17264 #define api_lisp_locator_set_dump api_one_locator_set_dump
17267 api_one_eid_table_map_dump (vat_main_t * vam)
17271 unformat_input_t *input = vam->input;
17272 vl_api_one_eid_table_map_dump_t *mp;
17273 vl_api_control_ping_t *mp_ping;
17276 /* Parse args required to build the message */
17277 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17279 if (unformat (input, "l2"))
17284 else if (unformat (input, "l3"))
17291 errmsg ("parse error '%U'", format_unformat_error, input);
17298 errmsg ("expected one of 'l2' or 'l3' parameter!");
17302 if (!vam->json_output)
17304 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17307 M (ONE_EID_TABLE_MAP_DUMP, mp);
17313 /* Use a control ping for synchronization */
17314 MPING (CONTROL_PING, mp_ping);
17317 /* Wait for a reply... */
17322 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17325 api_one_eid_table_vni_dump (vat_main_t * vam)
17327 vl_api_one_eid_table_vni_dump_t *mp;
17328 vl_api_control_ping_t *mp_ping;
17331 if (!vam->json_output)
17333 print (vam->ofp, "VNI");
17336 M (ONE_EID_TABLE_VNI_DUMP, mp);
17341 /* Use a control ping for synchronization */
17342 MPING (CONTROL_PING, mp_ping);
17345 /* Wait for a reply... */
17350 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17353 api_one_eid_table_dump (vat_main_t * vam)
17355 unformat_input_t *i = vam->input;
17356 vl_api_one_eid_table_dump_t *mp;
17357 vl_api_control_ping_t *mp_ping;
17358 struct in_addr ip4;
17359 struct in6_addr ip6;
17361 u8 eid_type = ~0, eid_set = 0;
17362 u32 prefix_length = ~0, t, vni = 0;
17365 lisp_nsh_api_t nsh;
17367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17369 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17375 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17381 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17386 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17391 else if (unformat (i, "vni %d", &t))
17395 else if (unformat (i, "local"))
17399 else if (unformat (i, "remote"))
17405 errmsg ("parse error '%U'", format_unformat_error, i);
17410 if (!vam->json_output)
17412 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17413 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17416 M (ONE_EID_TABLE_DUMP, mp);
17418 mp->filter = filter;
17422 mp->vni = htonl (vni);
17423 mp->eid_type = eid_type;
17427 mp->prefix_length = prefix_length;
17428 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17431 mp->prefix_length = prefix_length;
17432 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17435 clib_memcpy (mp->eid, mac, sizeof (mac));
17438 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17441 errmsg ("unknown EID type %d!", eid_type);
17449 /* Use a control ping for synchronization */
17450 MPING (CONTROL_PING, mp_ping);
17453 /* Wait for a reply... */
17458 #define api_lisp_eid_table_dump api_one_eid_table_dump
17461 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17463 unformat_input_t *i = vam->input;
17464 vl_api_gpe_fwd_entries_get_t *mp;
17469 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17471 if (unformat (i, "vni %d", &vni))
17477 errmsg ("parse error '%U'", format_unformat_error, i);
17484 errmsg ("vni not set!");
17488 if (!vam->json_output)
17490 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
17494 M (GPE_FWD_ENTRIES_GET, mp);
17495 mp->vni = clib_host_to_net_u32 (vni);
17500 /* Wait for a reply... */
17505 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
17506 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
17507 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
17508 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
17509 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
17510 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
17511 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
17512 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
17515 api_one_adjacencies_get (vat_main_t * vam)
17517 unformat_input_t *i = vam->input;
17518 vl_api_one_adjacencies_get_t *mp;
17523 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17525 if (unformat (i, "vni %d", &vni))
17531 errmsg ("parse error '%U'", format_unformat_error, i);
17538 errmsg ("vni not set!");
17542 if (!vam->json_output)
17544 print (vam->ofp, "%s %40s", "leid", "reid");
17547 M (ONE_ADJACENCIES_GET, mp);
17548 mp->vni = clib_host_to_net_u32 (vni);
17553 /* Wait for a reply... */
17558 #define api_lisp_adjacencies_get api_one_adjacencies_get
17561 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
17563 unformat_input_t *i = vam->input;
17564 vl_api_gpe_native_fwd_rpaths_get_t *mp;
17566 u8 ip_family_set = 0, is_ip4 = 1;
17568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17570 if (unformat (i, "ip4"))
17575 else if (unformat (i, "ip6"))
17582 errmsg ("parse error '%U'", format_unformat_error, i);
17587 if (!ip_family_set)
17589 errmsg ("ip family not set!");
17593 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
17594 mp->is_ip4 = is_ip4;
17599 /* Wait for a reply... */
17605 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
17607 vl_api_gpe_fwd_entry_vnis_get_t *mp;
17610 if (!vam->json_output)
17612 print (vam->ofp, "VNIs");
17615 M (GPE_FWD_ENTRY_VNIS_GET, mp);
17620 /* Wait for a reply... */
17626 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
17628 unformat_input_t *i = vam->input;
17629 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
17631 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
17632 struct in_addr ip4;
17633 struct in6_addr ip6;
17634 u32 table_id = 0, nh_sw_if_index = ~0;
17636 clib_memset (&ip4, 0, sizeof (ip4));
17637 clib_memset (&ip6, 0, sizeof (ip6));
17639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17641 if (unformat (i, "del"))
17643 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
17644 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17649 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
17650 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17655 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
17659 nh_sw_if_index = ~0;
17661 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
17665 nh_sw_if_index = ~0;
17667 else if (unformat (i, "table %d", &table_id))
17671 errmsg ("parse error '%U'", format_unformat_error, i);
17678 errmsg ("nh addr not set!");
17682 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
17683 mp->is_add = is_add;
17684 mp->table_id = clib_host_to_net_u32 (table_id);
17685 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
17686 mp->is_ip4 = is_ip4;
17688 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
17690 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
17695 /* Wait for a reply... */
17701 api_one_map_server_dump (vat_main_t * vam)
17703 vl_api_one_map_server_dump_t *mp;
17704 vl_api_control_ping_t *mp_ping;
17707 if (!vam->json_output)
17709 print (vam->ofp, "%=20s", "Map server");
17712 M (ONE_MAP_SERVER_DUMP, mp);
17716 /* Use a control ping for synchronization */
17717 MPING (CONTROL_PING, mp_ping);
17720 /* Wait for a reply... */
17725 #define api_lisp_map_server_dump api_one_map_server_dump
17728 api_one_map_resolver_dump (vat_main_t * vam)
17730 vl_api_one_map_resolver_dump_t *mp;
17731 vl_api_control_ping_t *mp_ping;
17734 if (!vam->json_output)
17736 print (vam->ofp, "%=20s", "Map resolver");
17739 M (ONE_MAP_RESOLVER_DUMP, mp);
17743 /* Use a control ping for synchronization */
17744 MPING (CONTROL_PING, mp_ping);
17747 /* Wait for a reply... */
17752 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17755 api_one_stats_flush (vat_main_t * vam)
17757 vl_api_one_stats_flush_t *mp;
17760 M (ONE_STATS_FLUSH, mp);
17767 api_one_stats_dump (vat_main_t * vam)
17769 vl_api_one_stats_dump_t *mp;
17770 vl_api_control_ping_t *mp_ping;
17773 M (ONE_STATS_DUMP, mp);
17777 /* Use a control ping for synchronization */
17778 MPING (CONTROL_PING, mp_ping);
17781 /* Wait for a reply... */
17787 api_show_one_status (vat_main_t * vam)
17789 vl_api_show_one_status_t *mp;
17792 if (!vam->json_output)
17794 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17797 M (SHOW_ONE_STATUS, mp);
17800 /* Wait for a reply... */
17805 #define api_show_lisp_status api_show_one_status
17808 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17810 vl_api_gpe_fwd_entry_path_dump_t *mp;
17811 vl_api_control_ping_t *mp_ping;
17812 unformat_input_t *i = vam->input;
17813 u32 fwd_entry_index = ~0;
17816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17818 if (unformat (i, "index %d", &fwd_entry_index))
17824 if (~0 == fwd_entry_index)
17826 errmsg ("no index specified!");
17830 if (!vam->json_output)
17832 print (vam->ofp, "first line");
17835 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17839 /* Use a control ping for synchronization */
17840 MPING (CONTROL_PING, mp_ping);
17843 /* Wait for a reply... */
17849 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17851 vl_api_one_get_map_request_itr_rlocs_t *mp;
17854 if (!vam->json_output)
17856 print (vam->ofp, "%=20s", "itr-rlocs:");
17859 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17862 /* Wait for a reply... */
17867 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17870 api_af_packet_create (vat_main_t * vam)
17872 unformat_input_t *i = vam->input;
17873 vl_api_af_packet_create_t *mp;
17874 u8 *host_if_name = 0;
17876 u8 random_hw_addr = 1;
17879 clib_memset (hw_addr, 0, sizeof (hw_addr));
17881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17883 if (unformat (i, "name %s", &host_if_name))
17884 vec_add1 (host_if_name, 0);
17885 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17886 random_hw_addr = 0;
17891 if (!vec_len (host_if_name))
17893 errmsg ("host-interface name must be specified");
17897 if (vec_len (host_if_name) > 64)
17899 errmsg ("host-interface name too long");
17903 M (AF_PACKET_CREATE, mp);
17905 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17906 clib_memcpy (mp->hw_addr, hw_addr, 6);
17907 mp->use_random_hw_addr = random_hw_addr;
17908 vec_free (host_if_name);
17916 fprintf (vam->ofp ? vam->ofp : stderr,
17917 " new sw_if_index = %d\n", vam->sw_if_index);
17924 api_af_packet_delete (vat_main_t * vam)
17926 unformat_input_t *i = vam->input;
17927 vl_api_af_packet_delete_t *mp;
17928 u8 *host_if_name = 0;
17931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17933 if (unformat (i, "name %s", &host_if_name))
17934 vec_add1 (host_if_name, 0);
17939 if (!vec_len (host_if_name))
17941 errmsg ("host-interface name must be specified");
17945 if (vec_len (host_if_name) > 64)
17947 errmsg ("host-interface name too long");
17951 M (AF_PACKET_DELETE, mp);
17953 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17954 vec_free (host_if_name);
17961 static void vl_api_af_packet_details_t_handler
17962 (vl_api_af_packet_details_t * mp)
17964 vat_main_t *vam = &vat_main;
17966 print (vam->ofp, "%-16s %d",
17967 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17970 static void vl_api_af_packet_details_t_handler_json
17971 (vl_api_af_packet_details_t * mp)
17973 vat_main_t *vam = &vat_main;
17974 vat_json_node_t *node = NULL;
17976 if (VAT_JSON_ARRAY != vam->json_tree.type)
17978 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17979 vat_json_init_array (&vam->json_tree);
17981 node = vat_json_array_add (&vam->json_tree);
17983 vat_json_init_object (node);
17984 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17985 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17989 api_af_packet_dump (vat_main_t * vam)
17991 vl_api_af_packet_dump_t *mp;
17992 vl_api_control_ping_t *mp_ping;
17995 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17996 /* Get list of tap interfaces */
17997 M (AF_PACKET_DUMP, mp);
18000 /* Use a control ping for synchronization */
18001 MPING (CONTROL_PING, mp_ping);
18009 api_policer_add_del (vat_main_t * vam)
18011 unformat_input_t *i = vam->input;
18012 vl_api_policer_add_del_t *mp;
18022 u8 color_aware = 0;
18023 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18026 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18027 conform_action.dscp = 0;
18028 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18029 exceed_action.dscp = 0;
18030 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18031 violate_action.dscp = 0;
18033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18035 if (unformat (i, "del"))
18037 else if (unformat (i, "name %s", &name))
18038 vec_add1 (name, 0);
18039 else if (unformat (i, "cir %u", &cir))
18041 else if (unformat (i, "eir %u", &eir))
18043 else if (unformat (i, "cb %u", &cb))
18045 else if (unformat (i, "eb %u", &eb))
18047 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18050 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18053 else if (unformat (i, "type %U", unformat_policer_type, &type))
18055 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18058 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18061 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18064 else if (unformat (i, "color-aware"))
18070 if (!vec_len (name))
18072 errmsg ("policer name must be specified");
18076 if (vec_len (name) > 64)
18078 errmsg ("policer name too long");
18082 M (POLICER_ADD_DEL, mp);
18084 clib_memcpy (mp->name, name, vec_len (name));
18086 mp->is_add = is_add;
18087 mp->cir = ntohl (cir);
18088 mp->eir = ntohl (eir);
18089 mp->cb = clib_net_to_host_u64 (cb);
18090 mp->eb = clib_net_to_host_u64 (eb);
18091 mp->rate_type = rate_type;
18092 mp->round_type = round_type;
18094 mp->conform_action_type = conform_action.action_type;
18095 mp->conform_dscp = conform_action.dscp;
18096 mp->exceed_action_type = exceed_action.action_type;
18097 mp->exceed_dscp = exceed_action.dscp;
18098 mp->violate_action_type = violate_action.action_type;
18099 mp->violate_dscp = violate_action.dscp;
18100 mp->color_aware = color_aware;
18108 api_policer_dump (vat_main_t * vam)
18110 unformat_input_t *i = vam->input;
18111 vl_api_policer_dump_t *mp;
18112 vl_api_control_ping_t *mp_ping;
18113 u8 *match_name = 0;
18114 u8 match_name_valid = 0;
18117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18119 if (unformat (i, "name %s", &match_name))
18121 vec_add1 (match_name, 0);
18122 match_name_valid = 1;
18128 M (POLICER_DUMP, mp);
18129 mp->match_name_valid = match_name_valid;
18130 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18131 vec_free (match_name);
18135 /* Use a control ping for synchronization */
18136 MPING (CONTROL_PING, mp_ping);
18139 /* Wait for a reply... */
18145 api_policer_classify_set_interface (vat_main_t * vam)
18147 unformat_input_t *i = vam->input;
18148 vl_api_policer_classify_set_interface_t *mp;
18150 int sw_if_index_set;
18151 u32 ip4_table_index = ~0;
18152 u32 ip6_table_index = ~0;
18153 u32 l2_table_index = ~0;
18157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18159 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18160 sw_if_index_set = 1;
18161 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18162 sw_if_index_set = 1;
18163 else if (unformat (i, "del"))
18165 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18167 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18169 else if (unformat (i, "l2-table %d", &l2_table_index))
18173 clib_warning ("parse error '%U'", format_unformat_error, i);
18178 if (sw_if_index_set == 0)
18180 errmsg ("missing interface name or sw_if_index");
18184 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18186 mp->sw_if_index = ntohl (sw_if_index);
18187 mp->ip4_table_index = ntohl (ip4_table_index);
18188 mp->ip6_table_index = ntohl (ip6_table_index);
18189 mp->l2_table_index = ntohl (l2_table_index);
18190 mp->is_add = is_add;
18198 api_policer_classify_dump (vat_main_t * vam)
18200 unformat_input_t *i = vam->input;
18201 vl_api_policer_classify_dump_t *mp;
18202 vl_api_control_ping_t *mp_ping;
18203 u8 type = POLICER_CLASSIFY_N_TABLES;
18206 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18210 errmsg ("classify table type must be specified");
18214 if (!vam->json_output)
18216 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18219 M (POLICER_CLASSIFY_DUMP, mp);
18224 /* Use a control ping for synchronization */
18225 MPING (CONTROL_PING, mp_ping);
18228 /* Wait for a reply... */
18234 api_netmap_create (vat_main_t * vam)
18236 unformat_input_t *i = vam->input;
18237 vl_api_netmap_create_t *mp;
18240 u8 random_hw_addr = 1;
18245 clib_memset (hw_addr, 0, sizeof (hw_addr));
18247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18249 if (unformat (i, "name %s", &if_name))
18250 vec_add1 (if_name, 0);
18251 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18252 random_hw_addr = 0;
18253 else if (unformat (i, "pipe"))
18255 else if (unformat (i, "master"))
18257 else if (unformat (i, "slave"))
18263 if (!vec_len (if_name))
18265 errmsg ("interface name must be specified");
18269 if (vec_len (if_name) > 64)
18271 errmsg ("interface name too long");
18275 M (NETMAP_CREATE, mp);
18277 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18278 clib_memcpy (mp->hw_addr, hw_addr, 6);
18279 mp->use_random_hw_addr = random_hw_addr;
18280 mp->is_pipe = is_pipe;
18281 mp->is_master = is_master;
18282 vec_free (if_name);
18290 api_netmap_delete (vat_main_t * vam)
18292 unformat_input_t *i = vam->input;
18293 vl_api_netmap_delete_t *mp;
18297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18299 if (unformat (i, "name %s", &if_name))
18300 vec_add1 (if_name, 0);
18305 if (!vec_len (if_name))
18307 errmsg ("interface name must be specified");
18311 if (vec_len (if_name) > 64)
18313 errmsg ("interface name too long");
18317 M (NETMAP_DELETE, mp);
18319 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18320 vec_free (if_name);
18328 format_fib_api_path_nh_proto (u8 * s, va_list * args)
18330 vl_api_fib_path_nh_proto_t proto =
18331 va_arg (*args, vl_api_fib_path_nh_proto_t);
18335 case FIB_API_PATH_NH_PROTO_IP4:
18336 s = format (s, "ip4");
18338 case FIB_API_PATH_NH_PROTO_IP6:
18339 s = format (s, "ip6");
18341 case FIB_API_PATH_NH_PROTO_MPLS:
18342 s = format (s, "mpls");
18344 case FIB_API_PATH_NH_PROTO_BIER:
18345 s = format (s, "bier");
18347 case FIB_API_PATH_NH_PROTO_ETHERNET:
18348 s = format (s, "ethernet");
18356 format_vl_api_ip_address_union (u8 * s, va_list * args)
18358 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
18359 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
18364 s = format (s, "%U", format_ip4_address, u->ip4);
18367 s = format (s, "%U", format_ip6_address, u->ip6);
18374 format_vl_api_fib_path_type (u8 * s, va_list * args)
18376 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
18380 case FIB_API_PATH_TYPE_NORMAL:
18381 s = format (s, "normal");
18383 case FIB_API_PATH_TYPE_LOCAL:
18384 s = format (s, "local");
18386 case FIB_API_PATH_TYPE_DROP:
18387 s = format (s, "drop");
18389 case FIB_API_PATH_TYPE_UDP_ENCAP:
18390 s = format (s, "udp-encap");
18392 case FIB_API_PATH_TYPE_BIER_IMP:
18393 s = format (s, "bier-imp");
18395 case FIB_API_PATH_TYPE_ICMP_UNREACH:
18396 s = format (s, "unreach");
18398 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
18399 s = format (s, "prohibit");
18401 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
18402 s = format (s, "src-lookup");
18404 case FIB_API_PATH_TYPE_DVR:
18405 s = format (s, "dvr");
18407 case FIB_API_PATH_TYPE_INTERFACE_RX:
18408 s = format (s, "interface-rx");
18410 case FIB_API_PATH_TYPE_CLASSIFY:
18411 s = format (s, "classify");
18419 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
18422 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
18423 ntohl (fp->weight), ntohl (fp->sw_if_index),
18424 format_vl_api_fib_path_type, fp->type,
18425 format_fib_api_path_nh_proto, fp->proto,
18426 format_vl_api_ip_address_union, &fp->nh.address);
18430 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18431 vl_api_fib_path_t * fp)
18433 struct in_addr ip4;
18434 struct in6_addr ip6;
18436 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18437 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18438 vat_json_object_add_uint (node, "type", fp->type);
18439 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
18440 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18442 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
18443 vat_json_object_add_ip4 (node, "next_hop", ip4);
18445 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18447 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
18448 vat_json_object_add_ip6 (node, "next_hop", ip6);
18453 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18455 vat_main_t *vam = &vat_main;
18456 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18457 vl_api_fib_path_t *fp;
18460 print (vam->ofp, "sw_if_index %d via:",
18461 ntohl (mp->mt_tunnel.mt_sw_if_index));
18462 fp = mp->mt_tunnel.mt_paths;
18463 for (i = 0; i < count; i++)
18465 vl_api_fib_path_print (vam, fp);
18469 print (vam->ofp, "");
18472 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18473 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18476 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18478 vat_main_t *vam = &vat_main;
18479 vat_json_node_t *node = NULL;
18480 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18481 vl_api_fib_path_t *fp;
18484 if (VAT_JSON_ARRAY != vam->json_tree.type)
18486 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18487 vat_json_init_array (&vam->json_tree);
18489 node = vat_json_array_add (&vam->json_tree);
18491 vat_json_init_object (node);
18492 vat_json_object_add_uint (node, "sw_if_index",
18493 ntohl (mp->mt_tunnel.mt_sw_if_index));
18495 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
18497 fp = mp->mt_tunnel.mt_paths;
18498 for (i = 0; i < count; i++)
18500 vl_api_mpls_fib_path_json_print (node, fp);
18506 api_mpls_tunnel_dump (vat_main_t * vam)
18508 vl_api_mpls_tunnel_dump_t *mp;
18509 vl_api_control_ping_t *mp_ping;
18512 M (MPLS_TUNNEL_DUMP, mp);
18516 /* Use a control ping for synchronization */
18517 MPING (CONTROL_PING, mp_ping);
18524 #define vl_api_mpls_table_details_t_endian vl_noop_handler
18525 #define vl_api_mpls_table_details_t_print vl_noop_handler
18529 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
18531 vat_main_t *vam = &vat_main;
18533 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
18536 static void vl_api_mpls_table_details_t_handler_json
18537 (vl_api_mpls_table_details_t * mp)
18539 vat_main_t *vam = &vat_main;
18540 vat_json_node_t *node = NULL;
18542 if (VAT_JSON_ARRAY != vam->json_tree.type)
18544 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18545 vat_json_init_array (&vam->json_tree);
18547 node = vat_json_array_add (&vam->json_tree);
18549 vat_json_init_object (node);
18550 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
18554 api_mpls_table_dump (vat_main_t * vam)
18556 vl_api_mpls_table_dump_t *mp;
18557 vl_api_control_ping_t *mp_ping;
18560 M (MPLS_TABLE_DUMP, mp);
18563 /* Use a control ping for synchronization */
18564 MPING (CONTROL_PING, mp_ping);
18571 #define vl_api_mpls_route_details_t_endian vl_noop_handler
18572 #define vl_api_mpls_route_details_t_print vl_noop_handler
18575 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
18577 vat_main_t *vam = &vat_main;
18578 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
18579 vl_api_fib_path_t *fp;
18583 "table-id %d, label %u, ess_bit %u",
18584 ntohl (mp->mr_route.mr_table_id),
18585 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
18586 fp = mp->mr_route.mr_paths;
18587 for (i = 0; i < count; i++)
18589 vl_api_fib_path_print (vam, fp);
18594 static void vl_api_mpls_route_details_t_handler_json
18595 (vl_api_mpls_route_details_t * mp)
18597 vat_main_t *vam = &vat_main;
18598 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
18599 vat_json_node_t *node = NULL;
18600 vl_api_fib_path_t *fp;
18603 if (VAT_JSON_ARRAY != vam->json_tree.type)
18605 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18606 vat_json_init_array (&vam->json_tree);
18608 node = vat_json_array_add (&vam->json_tree);
18610 vat_json_init_object (node);
18611 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
18612 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
18613 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
18614 vat_json_object_add_uint (node, "path_count", count);
18615 fp = mp->mr_route.mr_paths;
18616 for (i = 0; i < count; i++)
18618 vl_api_mpls_fib_path_json_print (node, fp);
18624 api_mpls_route_dump (vat_main_t * vam)
18626 unformat_input_t *input = vam->input;
18627 vl_api_mpls_route_dump_t *mp;
18628 vl_api_control_ping_t *mp_ping;
18632 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18634 if (unformat (input, "table_id %d", &table_id))
18639 if (table_id == ~0)
18641 errmsg ("missing table id");
18645 M (MPLS_ROUTE_DUMP, mp);
18647 mp->table.mt_table_id = ntohl (table_id);
18650 /* Use a control ping for synchronization */
18651 MPING (CONTROL_PING, mp_ping);
18658 #define vl_api_ip_table_details_t_endian vl_noop_handler
18659 #define vl_api_ip_table_details_t_print vl_noop_handler
18662 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
18664 vat_main_t *vam = &vat_main;
18667 "%s; table-id %d, prefix %U/%d",
18668 mp->table.name, ntohl (mp->table.table_id));
18672 static void vl_api_ip_table_details_t_handler_json
18673 (vl_api_ip_table_details_t * mp)
18675 vat_main_t *vam = &vat_main;
18676 vat_json_node_t *node = NULL;
18678 if (VAT_JSON_ARRAY != vam->json_tree.type)
18680 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18681 vat_json_init_array (&vam->json_tree);
18683 node = vat_json_array_add (&vam->json_tree);
18685 vat_json_init_object (node);
18686 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
18690 api_ip_table_dump (vat_main_t * vam)
18692 vl_api_ip_table_dump_t *mp;
18693 vl_api_control_ping_t *mp_ping;
18696 M (IP_TABLE_DUMP, mp);
18699 /* Use a control ping for synchronization */
18700 MPING (CONTROL_PING, mp_ping);
18708 api_ip_mtable_dump (vat_main_t * vam)
18710 vl_api_ip_mtable_dump_t *mp;
18711 vl_api_control_ping_t *mp_ping;
18714 M (IP_MTABLE_DUMP, mp);
18717 /* Use a control ping for synchronization */
18718 MPING (CONTROL_PING, mp_ping);
18726 api_ip_mroute_dump (vat_main_t * vam)
18728 unformat_input_t *input = vam->input;
18729 vl_api_control_ping_t *mp_ping;
18730 vl_api_ip_mroute_dump_t *mp;
18735 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18737 if (unformat (input, "table_id %d", &table_id))
18739 else if (unformat (input, "ip6"))
18741 else if (unformat (input, "ip4"))
18746 if (table_id == ~0)
18748 errmsg ("missing table id");
18752 M (IP_MROUTE_DUMP, mp);
18753 mp->table.table_id = table_id;
18754 mp->table.is_ip6 = is_ip6;
18757 /* Use a control ping for synchronization */
18758 MPING (CONTROL_PING, mp_ping);
18765 static void vl_api_ip_neighbor_details_t_handler
18766 (vl_api_ip_neighbor_details_t * mp)
18768 vat_main_t *vam = &vat_main;
18770 print (vam->ofp, "%c %U %U",
18771 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
18772 format_vl_api_mac_address, &mp->neighbor.mac_address,
18773 format_vl_api_address, &mp->neighbor.ip_address);
18776 static void vl_api_ip_neighbor_details_t_handler_json
18777 (vl_api_ip_neighbor_details_t * mp)
18780 vat_main_t *vam = &vat_main;
18781 vat_json_node_t *node;
18783 if (VAT_JSON_ARRAY != vam->json_tree.type)
18785 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18786 vat_json_init_array (&vam->json_tree);
18788 node = vat_json_array_add (&vam->json_tree);
18790 vat_json_init_object (node);
18791 vat_json_object_add_string_copy
18793 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
18794 (u8 *) "static" : (u8 *) "dynamic"));
18796 vat_json_object_add_string_copy (node, "link_layer",
18797 format (0, "%U", format_vl_api_mac_address,
18798 &mp->neighbor.mac_address));
18799 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
18803 api_ip_neighbor_dump (vat_main_t * vam)
18805 unformat_input_t *i = vam->input;
18806 vl_api_ip_neighbor_dump_t *mp;
18807 vl_api_control_ping_t *mp_ping;
18809 u32 sw_if_index = ~0;
18812 /* Parse args required to build the message */
18813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18815 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18817 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18819 else if (unformat (i, "ip6"))
18825 if (sw_if_index == ~0)
18827 errmsg ("missing interface name or sw_if_index");
18831 M (IP_NEIGHBOR_DUMP, mp);
18832 mp->is_ipv6 = (u8) is_ipv6;
18833 mp->sw_if_index = ntohl (sw_if_index);
18836 /* Use a control ping for synchronization */
18837 MPING (CONTROL_PING, mp_ping);
18844 #define vl_api_ip_route_details_t_endian vl_noop_handler
18845 #define vl_api_ip_route_details_t_print vl_noop_handler
18848 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
18850 vat_main_t *vam = &vat_main;
18851 u8 count = mp->route.n_paths;
18852 vl_api_fib_path_t *fp;
18856 "table-id %d, prefix %U/%d",
18857 ntohl (mp->route.table_id),
18858 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
18859 for (i = 0; i < count; i++)
18861 fp = &mp->route.paths[i];
18863 vl_api_fib_path_print (vam, fp);
18868 static void vl_api_ip_route_details_t_handler_json
18869 (vl_api_ip_route_details_t * mp)
18871 vat_main_t *vam = &vat_main;
18872 u8 count = mp->route.n_paths;
18873 vat_json_node_t *node = NULL;
18874 struct in_addr ip4;
18875 struct in6_addr ip6;
18876 vl_api_fib_path_t *fp;
18879 if (VAT_JSON_ARRAY != vam->json_tree.type)
18881 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18882 vat_json_init_array (&vam->json_tree);
18884 node = vat_json_array_add (&vam->json_tree);
18886 vat_json_init_object (node);
18887 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18888 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18890 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18891 vat_json_object_add_ip6 (node, "prefix", ip6);
18895 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18896 vat_json_object_add_ip4 (node, "prefix", ip4);
18898 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18899 vat_json_object_add_uint (node, "path_count", count);
18900 for (i = 0; i < count; i++)
18902 fp = &mp->route.paths[i];
18903 vl_api_mpls_fib_path_json_print (node, fp);
18908 api_ip_route_dump (vat_main_t * vam)
18910 unformat_input_t *input = vam->input;
18911 vl_api_ip_route_dump_t *mp;
18912 vl_api_control_ping_t *mp_ping;
18918 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18920 if (unformat (input, "table_id %d", &table_id))
18922 else if (unformat (input, "ip6"))
18924 else if (unformat (input, "ip4"))
18929 if (table_id == ~0)
18931 errmsg ("missing table id");
18935 M (IP_ROUTE_DUMP, mp);
18937 mp->table.table_id = table_id;
18938 mp->table.is_ip6 = is_ip6;
18942 /* Use a control ping for synchronization */
18943 MPING (CONTROL_PING, mp_ping);
18951 api_classify_table_ids (vat_main_t * vam)
18953 vl_api_classify_table_ids_t *mp;
18956 /* Construct the API message */
18957 M (CLASSIFY_TABLE_IDS, mp);
18966 api_classify_table_by_interface (vat_main_t * vam)
18968 unformat_input_t *input = vam->input;
18969 vl_api_classify_table_by_interface_t *mp;
18971 u32 sw_if_index = ~0;
18973 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18975 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18977 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18982 if (sw_if_index == ~0)
18984 errmsg ("missing interface name or sw_if_index");
18988 /* Construct the API message */
18989 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18991 mp->sw_if_index = ntohl (sw_if_index);
18999 api_classify_table_info (vat_main_t * vam)
19001 unformat_input_t *input = vam->input;
19002 vl_api_classify_table_info_t *mp;
19006 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19008 if (unformat (input, "table_id %d", &table_id))
19013 if (table_id == ~0)
19015 errmsg ("missing table id");
19019 /* Construct the API message */
19020 M (CLASSIFY_TABLE_INFO, mp);
19022 mp->table_id = ntohl (table_id);
19030 api_classify_session_dump (vat_main_t * vam)
19032 unformat_input_t *input = vam->input;
19033 vl_api_classify_session_dump_t *mp;
19034 vl_api_control_ping_t *mp_ping;
19038 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19040 if (unformat (input, "table_id %d", &table_id))
19045 if (table_id == ~0)
19047 errmsg ("missing table id");
19051 /* Construct the API message */
19052 M (CLASSIFY_SESSION_DUMP, mp);
19054 mp->table_id = ntohl (table_id);
19057 /* Use a control ping for synchronization */
19058 MPING (CONTROL_PING, mp_ping);
19066 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19068 vat_main_t *vam = &vat_main;
19070 print (vam->ofp, "collector_address %U, collector_port %d, "
19071 "src_address %U, vrf_id %d, path_mtu %u, "
19072 "template_interval %u, udp_checksum %d",
19073 format_ip4_address, mp->collector_address,
19074 ntohs (mp->collector_port),
19075 format_ip4_address, mp->src_address,
19076 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19077 ntohl (mp->template_interval), mp->udp_checksum);
19080 vam->result_ready = 1;
19084 vl_api_ipfix_exporter_details_t_handler_json
19085 (vl_api_ipfix_exporter_details_t * mp)
19087 vat_main_t *vam = &vat_main;
19088 vat_json_node_t node;
19089 struct in_addr collector_address;
19090 struct in_addr src_address;
19092 vat_json_init_object (&node);
19093 clib_memcpy (&collector_address, &mp->collector_address,
19094 sizeof (collector_address));
19095 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19096 vat_json_object_add_uint (&node, "collector_port",
19097 ntohs (mp->collector_port));
19098 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19099 vat_json_object_add_ip4 (&node, "src_address", src_address);
19100 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19101 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19102 vat_json_object_add_uint (&node, "template_interval",
19103 ntohl (mp->template_interval));
19104 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19106 vat_json_print (vam->ofp, &node);
19107 vat_json_free (&node);
19109 vam->result_ready = 1;
19113 api_ipfix_exporter_dump (vat_main_t * vam)
19115 vl_api_ipfix_exporter_dump_t *mp;
19118 /* Construct the API message */
19119 M (IPFIX_EXPORTER_DUMP, mp);
19128 api_ipfix_classify_stream_dump (vat_main_t * vam)
19130 vl_api_ipfix_classify_stream_dump_t *mp;
19133 /* Construct the API message */
19134 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19145 vl_api_ipfix_classify_stream_details_t_handler
19146 (vl_api_ipfix_classify_stream_details_t * mp)
19148 vat_main_t *vam = &vat_main;
19149 print (vam->ofp, "domain_id %d, src_port %d",
19150 ntohl (mp->domain_id), ntohs (mp->src_port));
19152 vam->result_ready = 1;
19156 vl_api_ipfix_classify_stream_details_t_handler_json
19157 (vl_api_ipfix_classify_stream_details_t * mp)
19159 vat_main_t *vam = &vat_main;
19160 vat_json_node_t node;
19162 vat_json_init_object (&node);
19163 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19164 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19166 vat_json_print (vam->ofp, &node);
19167 vat_json_free (&node);
19169 vam->result_ready = 1;
19173 api_ipfix_classify_table_dump (vat_main_t * vam)
19175 vl_api_ipfix_classify_table_dump_t *mp;
19176 vl_api_control_ping_t *mp_ping;
19179 if (!vam->json_output)
19181 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19182 "transport_protocol");
19185 /* Construct the API message */
19186 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19191 /* Use a control ping for synchronization */
19192 MPING (CONTROL_PING, mp_ping);
19200 vl_api_ipfix_classify_table_details_t_handler
19201 (vl_api_ipfix_classify_table_details_t * mp)
19203 vat_main_t *vam = &vat_main;
19204 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19205 mp->transport_protocol);
19209 vl_api_ipfix_classify_table_details_t_handler_json
19210 (vl_api_ipfix_classify_table_details_t * mp)
19212 vat_json_node_t *node = NULL;
19213 vat_main_t *vam = &vat_main;
19215 if (VAT_JSON_ARRAY != vam->json_tree.type)
19217 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19218 vat_json_init_array (&vam->json_tree);
19221 node = vat_json_array_add (&vam->json_tree);
19222 vat_json_init_object (node);
19224 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19225 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19226 vat_json_object_add_uint (node, "transport_protocol",
19227 mp->transport_protocol);
19231 api_sw_interface_span_enable_disable (vat_main_t * vam)
19233 unformat_input_t *i = vam->input;
19234 vl_api_sw_interface_span_enable_disable_t *mp;
19235 u32 src_sw_if_index = ~0;
19236 u32 dst_sw_if_index = ~0;
19241 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19244 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19246 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19250 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19252 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19254 else if (unformat (i, "disable"))
19256 else if (unformat (i, "rx"))
19258 else if (unformat (i, "tx"))
19260 else if (unformat (i, "both"))
19262 else if (unformat (i, "l2"))
19268 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19270 mp->sw_if_index_from = htonl (src_sw_if_index);
19271 mp->sw_if_index_to = htonl (dst_sw_if_index);
19281 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19284 vat_main_t *vam = &vat_main;
19285 u8 *sw_if_from_name = 0;
19286 u8 *sw_if_to_name = 0;
19287 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19288 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19289 char *states[] = { "none", "rx", "tx", "both" };
19293 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19295 if ((u32) p->value[0] == sw_if_index_from)
19297 sw_if_from_name = (u8 *)(p->key);
19301 if ((u32) p->value[0] == sw_if_index_to)
19303 sw_if_to_name = (u8 *)(p->key);
19304 if (sw_if_from_name)
19309 print (vam->ofp, "%20s => %20s (%s) %s",
19310 sw_if_from_name, sw_if_to_name, states[mp->state],
19311 mp->is_l2 ? "l2" : "device");
19315 vl_api_sw_interface_span_details_t_handler_json
19316 (vl_api_sw_interface_span_details_t * mp)
19318 vat_main_t *vam = &vat_main;
19319 vat_json_node_t *node = NULL;
19320 u8 *sw_if_from_name = 0;
19321 u8 *sw_if_to_name = 0;
19322 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19323 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19327 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19329 if ((u32) p->value[0] == sw_if_index_from)
19331 sw_if_from_name = (u8 *)(p->key);
19335 if ((u32) p->value[0] == sw_if_index_to)
19337 sw_if_to_name = (u8 *)(p->key);
19338 if (sw_if_from_name)
19344 if (VAT_JSON_ARRAY != vam->json_tree.type)
19346 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19347 vat_json_init_array (&vam->json_tree);
19349 node = vat_json_array_add (&vam->json_tree);
19351 vat_json_init_object (node);
19352 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19353 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19354 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19355 if (0 != sw_if_to_name)
19357 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19359 vat_json_object_add_uint (node, "state", mp->state);
19360 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19364 api_sw_interface_span_dump (vat_main_t * vam)
19366 unformat_input_t *input = vam->input;
19367 vl_api_sw_interface_span_dump_t *mp;
19368 vl_api_control_ping_t *mp_ping;
19372 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19374 if (unformat (input, "l2"))
19380 M (SW_INTERFACE_SPAN_DUMP, mp);
19384 /* Use a control ping for synchronization */
19385 MPING (CONTROL_PING, mp_ping);
19393 api_pg_create_interface (vat_main_t * vam)
19395 unformat_input_t *input = vam->input;
19396 vl_api_pg_create_interface_t *mp;
19398 u32 if_id = ~0, gso_size = 0;
19399 u8 gso_enabled = 0;
19401 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19403 if (unformat (input, "if_id %d", &if_id))
19405 else if (unformat (input, "gso-enabled"))
19408 if (unformat (input, "gso-size %u", &gso_size))
19412 errmsg ("missing gso-size");
19421 errmsg ("missing pg interface index");
19425 /* Construct the API message */
19426 M (PG_CREATE_INTERFACE, mp);
19428 mp->interface_id = ntohl (if_id);
19429 mp->gso_enabled = gso_enabled;
19437 api_pg_capture (vat_main_t * vam)
19439 unformat_input_t *input = vam->input;
19440 vl_api_pg_capture_t *mp;
19445 u8 pcap_file_set = 0;
19448 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19450 if (unformat (input, "if_id %d", &if_id))
19452 else if (unformat (input, "pcap %s", &pcap_file))
19454 else if (unformat (input, "count %d", &count))
19456 else if (unformat (input, "disable"))
19463 errmsg ("missing pg interface index");
19466 if (pcap_file_set > 0)
19468 if (vec_len (pcap_file) > 255)
19470 errmsg ("pcap file name is too long");
19475 u32 name_len = vec_len (pcap_file);
19476 /* Construct the API message */
19477 M (PG_CAPTURE, mp);
19479 mp->interface_id = ntohl (if_id);
19480 mp->is_enabled = enable;
19481 mp->count = ntohl (count);
19482 mp->pcap_name_length = ntohl (name_len);
19483 if (pcap_file_set != 0)
19485 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19487 vec_free (pcap_file);
19495 api_pg_enable_disable (vat_main_t * vam)
19497 unformat_input_t *input = vam->input;
19498 vl_api_pg_enable_disable_t *mp;
19501 u8 stream_name_set = 0;
19502 u8 *stream_name = 0;
19504 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19506 if (unformat (input, "stream %s", &stream_name))
19507 stream_name_set = 1;
19508 else if (unformat (input, "disable"))
19514 if (stream_name_set > 0)
19516 if (vec_len (stream_name) > 255)
19518 errmsg ("stream name too long");
19523 u32 name_len = vec_len (stream_name);
19524 /* Construct the API message */
19525 M (PG_ENABLE_DISABLE, mp);
19527 mp->is_enabled = enable;
19528 if (stream_name_set != 0)
19530 mp->stream_name_length = ntohl (name_len);
19531 clib_memcpy (mp->stream_name, stream_name, name_len);
19533 vec_free (stream_name);
19541 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19543 unformat_input_t *input = vam->input;
19544 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19546 u16 *low_ports = 0;
19547 u16 *high_ports = 0;
19550 vl_api_prefix_t prefix;
19557 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19559 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
19561 else if (unformat (input, "vrf %d", &vrf_id))
19563 else if (unformat (input, "del"))
19565 else if (unformat (input, "port %d", &tmp))
19567 if (tmp == 0 || tmp > 65535)
19569 errmsg ("port %d out of range", tmp);
19573 this_hi = this_low + 1;
19574 vec_add1 (low_ports, this_low);
19575 vec_add1 (high_ports, this_hi);
19577 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19579 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19581 errmsg ("incorrect range parameters");
19585 /* Note: in debug CLI +1 is added to high before
19586 passing to real fn that does "the work"
19587 (ip_source_and_port_range_check_add_del).
19588 This fn is a wrapper around the binary API fn a
19589 control plane will call, which expects this increment
19590 to have occurred. Hence letting the binary API control
19591 plane fn do the increment for consistency between VAT
19592 and other control planes.
19595 vec_add1 (low_ports, this_low);
19596 vec_add1 (high_ports, this_hi);
19602 if (prefix_set == 0)
19604 errmsg ("<address>/<mask> not specified");
19610 errmsg ("VRF ID required, not specified");
19617 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19621 if (vec_len (low_ports) == 0)
19623 errmsg ("At least one port or port range required");
19627 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
19629 mp->is_add = is_add;
19631 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
19633 mp->number_of_ranges = vec_len (low_ports);
19635 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
19636 vec_free (low_ports);
19638 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
19639 vec_free (high_ports);
19641 mp->vrf_id = ntohl (vrf_id);
19649 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
19651 unformat_input_t *input = vam->input;
19652 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
19653 u32 sw_if_index = ~0;
19655 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
19656 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
19660 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19662 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19664 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19666 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
19668 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
19670 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
19672 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
19674 else if (unformat (input, "del"))
19680 if (sw_if_index == ~0)
19682 errmsg ("Interface required but not specified");
19688 errmsg ("VRF ID required but not specified");
19692 if (tcp_out_vrf_id == 0
19693 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
19696 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19700 /* Construct the API message */
19701 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
19703 mp->sw_if_index = ntohl (sw_if_index);
19704 mp->is_add = is_add;
19705 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
19706 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
19707 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
19708 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
19713 /* Wait for a reply... */
19719 api_set_punt (vat_main_t * vam)
19721 unformat_input_t *i = vam->input;
19722 vl_api_address_family_t af;
19723 vl_api_set_punt_t *mp;
19729 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19731 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
19733 else if (unformat (i, "protocol %d", &protocol))
19735 else if (unformat (i, "port %d", &port))
19737 else if (unformat (i, "del"))
19741 clib_warning ("parse error '%U'", format_unformat_error, i);
19748 mp->is_add = (u8) is_add;
19749 mp->punt.type = PUNT_API_TYPE_L4;
19750 mp->punt.punt.l4.af = af;
19751 mp->punt.punt.l4.protocol = (u8) protocol;
19752 mp->punt.punt.l4.port = htons ((u16) port);
19760 api_delete_subif (vat_main_t * vam)
19762 unformat_input_t *i = vam->input;
19763 vl_api_delete_subif_t *mp;
19764 u32 sw_if_index = ~0;
19767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19769 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19771 if (unformat (i, "sw_if_index %d", &sw_if_index))
19777 if (sw_if_index == ~0)
19779 errmsg ("missing sw_if_index");
19783 /* Construct the API message */
19784 M (DELETE_SUBIF, mp);
19785 mp->sw_if_index = ntohl (sw_if_index);
19792 #define foreach_pbb_vtr_op \
19793 _("disable", L2_VTR_DISABLED) \
19794 _("pop", L2_VTR_POP_2) \
19795 _("push", L2_VTR_PUSH_2)
19798 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
19800 unformat_input_t *i = vam->input;
19801 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
19802 u32 sw_if_index = ~0, vtr_op = ~0;
19803 u16 outer_tag = ~0;
19804 u8 dmac[6], smac[6];
19805 u8 dmac_set = 0, smac_set = 0;
19811 /* Shut up coverity */
19812 clib_memset (dmac, 0, sizeof (dmac));
19813 clib_memset (smac, 0, sizeof (smac));
19815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19817 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19819 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19821 else if (unformat (i, "vtr_op %d", &vtr_op))
19823 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
19826 else if (unformat (i, "translate_pbb_stag"))
19828 if (unformat (i, "%d", &tmp))
19830 vtr_op = L2_VTR_TRANSLATE_2_1;
19836 ("translate_pbb_stag operation requires outer tag definition");
19840 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
19842 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
19844 else if (unformat (i, "sid %d", &sid))
19846 else if (unformat (i, "vlanid %d", &tmp))
19850 clib_warning ("parse error '%U'", format_unformat_error, i);
19855 if ((sw_if_index == ~0) || (vtr_op == ~0))
19857 errmsg ("missing sw_if_index or vtr operation");
19860 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19861 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19864 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19868 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19869 mp->sw_if_index = ntohl (sw_if_index);
19870 mp->vtr_op = ntohl (vtr_op);
19871 mp->outer_tag = ntohs (outer_tag);
19872 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19873 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19874 mp->b_vlanid = ntohs (vlanid);
19875 mp->i_sid = ntohl (sid);
19883 api_flow_classify_set_interface (vat_main_t * vam)
19885 unformat_input_t *i = vam->input;
19886 vl_api_flow_classify_set_interface_t *mp;
19888 int sw_if_index_set;
19889 u32 ip4_table_index = ~0;
19890 u32 ip6_table_index = ~0;
19894 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19896 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19897 sw_if_index_set = 1;
19898 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19899 sw_if_index_set = 1;
19900 else if (unformat (i, "del"))
19902 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19904 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19908 clib_warning ("parse error '%U'", format_unformat_error, i);
19913 if (sw_if_index_set == 0)
19915 errmsg ("missing interface name or sw_if_index");
19919 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19921 mp->sw_if_index = ntohl (sw_if_index);
19922 mp->ip4_table_index = ntohl (ip4_table_index);
19923 mp->ip6_table_index = ntohl (ip6_table_index);
19924 mp->is_add = is_add;
19932 api_flow_classify_dump (vat_main_t * vam)
19934 unformat_input_t *i = vam->input;
19935 vl_api_flow_classify_dump_t *mp;
19936 vl_api_control_ping_t *mp_ping;
19937 u8 type = FLOW_CLASSIFY_N_TABLES;
19940 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19944 errmsg ("classify table type must be specified");
19948 if (!vam->json_output)
19950 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19953 M (FLOW_CLASSIFY_DUMP, mp);
19958 /* Use a control ping for synchronization */
19959 MPING (CONTROL_PING, mp_ping);
19962 /* Wait for a reply... */
19968 api_feature_enable_disable (vat_main_t * vam)
19970 unformat_input_t *i = vam->input;
19971 vl_api_feature_enable_disable_t *mp;
19973 u8 *feature_name = 0;
19974 u32 sw_if_index = ~0;
19978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19980 if (unformat (i, "arc_name %s", &arc_name))
19982 else if (unformat (i, "feature_name %s", &feature_name))
19985 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19987 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19989 else if (unformat (i, "disable"))
19997 errmsg ("missing arc name");
20000 if (vec_len (arc_name) > 63)
20002 errmsg ("arc name too long");
20005 if (feature_name == 0)
20007 errmsg ("missing feature name");
20010 if (vec_len (feature_name) > 63)
20012 errmsg ("feature name too long");
20015 if (sw_if_index == ~0)
20017 errmsg ("missing interface name or sw_if_index");
20021 /* Construct the API message */
20022 M (FEATURE_ENABLE_DISABLE, mp);
20023 mp->sw_if_index = ntohl (sw_if_index);
20024 mp->enable = enable;
20025 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20026 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20027 vec_free (arc_name);
20028 vec_free (feature_name);
20036 api_feature_gso_enable_disable (vat_main_t * vam)
20038 unformat_input_t *i = vam->input;
20039 vl_api_feature_gso_enable_disable_t *mp;
20040 u32 sw_if_index = ~0;
20044 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20046 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20048 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20050 else if (unformat (i, "enable"))
20052 else if (unformat (i, "disable"))
20058 if (sw_if_index == ~0)
20060 errmsg ("missing interface name or sw_if_index");
20064 /* Construct the API message */
20065 M (FEATURE_GSO_ENABLE_DISABLE, mp);
20066 mp->sw_if_index = ntohl (sw_if_index);
20067 mp->enable_disable = enable;
20075 api_sw_interface_tag_add_del (vat_main_t * vam)
20077 unformat_input_t *i = vam->input;
20078 vl_api_sw_interface_tag_add_del_t *mp;
20079 u32 sw_if_index = ~0;
20084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20086 if (unformat (i, "tag %s", &tag))
20088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20092 else if (unformat (i, "del"))
20098 if (sw_if_index == ~0)
20100 errmsg ("missing interface name or sw_if_index");
20104 if (enable && (tag == 0))
20106 errmsg ("no tag specified");
20110 /* Construct the API message */
20111 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20112 mp->sw_if_index = ntohl (sw_if_index);
20113 mp->is_add = enable;
20115 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20124 api_sw_interface_add_del_mac_address (vat_main_t * vam)
20126 unformat_input_t *i = vam->input;
20127 vl_api_mac_address_t mac = { 0 };
20128 vl_api_sw_interface_add_del_mac_address_t *mp;
20129 u32 sw_if_index = ~0;
20134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20140 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
20142 else if (unformat (i, "del"))
20148 if (sw_if_index == ~0)
20150 errmsg ("missing interface name or sw_if_index");
20156 errmsg ("missing MAC address");
20160 /* Construct the API message */
20161 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
20162 mp->sw_if_index = ntohl (sw_if_index);
20163 mp->is_add = is_add;
20164 clib_memcpy (&mp->addr, &mac, sizeof (mac));
20171 static void vl_api_l2_xconnect_details_t_handler
20172 (vl_api_l2_xconnect_details_t * mp)
20174 vat_main_t *vam = &vat_main;
20176 print (vam->ofp, "%15d%15d",
20177 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20180 static void vl_api_l2_xconnect_details_t_handler_json
20181 (vl_api_l2_xconnect_details_t * mp)
20183 vat_main_t *vam = &vat_main;
20184 vat_json_node_t *node = NULL;
20186 if (VAT_JSON_ARRAY != vam->json_tree.type)
20188 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20189 vat_json_init_array (&vam->json_tree);
20191 node = vat_json_array_add (&vam->json_tree);
20193 vat_json_init_object (node);
20194 vat_json_object_add_uint (node, "rx_sw_if_index",
20195 ntohl (mp->rx_sw_if_index));
20196 vat_json_object_add_uint (node, "tx_sw_if_index",
20197 ntohl (mp->tx_sw_if_index));
20201 api_l2_xconnect_dump (vat_main_t * vam)
20203 vl_api_l2_xconnect_dump_t *mp;
20204 vl_api_control_ping_t *mp_ping;
20207 if (!vam->json_output)
20209 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20212 M (L2_XCONNECT_DUMP, mp);
20216 /* Use a control ping for synchronization */
20217 MPING (CONTROL_PING, mp_ping);
20225 api_hw_interface_set_mtu (vat_main_t * vam)
20227 unformat_input_t *i = vam->input;
20228 vl_api_hw_interface_set_mtu_t *mp;
20229 u32 sw_if_index = ~0;
20233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20235 if (unformat (i, "mtu %d", &mtu))
20237 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20239 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20245 if (sw_if_index == ~0)
20247 errmsg ("missing interface name or sw_if_index");
20253 errmsg ("no mtu specified");
20257 /* Construct the API message */
20258 M (HW_INTERFACE_SET_MTU, mp);
20259 mp->sw_if_index = ntohl (sw_if_index);
20260 mp->mtu = ntohs ((u16) mtu);
20268 api_p2p_ethernet_add (vat_main_t * vam)
20270 unformat_input_t *i = vam->input;
20271 vl_api_p2p_ethernet_add_t *mp;
20272 u32 parent_if_index = ~0;
20278 clib_memset (remote_mac, 0, sizeof (remote_mac));
20279 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20281 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20283 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20287 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20289 else if (unformat (i, "sub_id %d", &sub_id))
20293 clib_warning ("parse error '%U'", format_unformat_error, i);
20298 if (parent_if_index == ~0)
20300 errmsg ("missing interface name or sw_if_index");
20305 errmsg ("missing remote mac address");
20310 errmsg ("missing sub-interface id");
20314 M (P2P_ETHERNET_ADD, mp);
20315 mp->parent_if_index = ntohl (parent_if_index);
20316 mp->subif_id = ntohl (sub_id);
20317 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20325 api_p2p_ethernet_del (vat_main_t * vam)
20327 unformat_input_t *i = vam->input;
20328 vl_api_p2p_ethernet_del_t *mp;
20329 u32 parent_if_index = ~0;
20334 clib_memset (remote_mac, 0, sizeof (remote_mac));
20335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20337 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20339 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20343 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20347 clib_warning ("parse error '%U'", format_unformat_error, i);
20352 if (parent_if_index == ~0)
20354 errmsg ("missing interface name or sw_if_index");
20359 errmsg ("missing remote mac address");
20363 M (P2P_ETHERNET_DEL, mp);
20364 mp->parent_if_index = ntohl (parent_if_index);
20365 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20373 api_lldp_config (vat_main_t * vam)
20375 unformat_input_t *i = vam->input;
20376 vl_api_lldp_config_t *mp;
20378 int tx_interval = 0;
20379 u8 *sys_name = NULL;
20382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20384 if (unformat (i, "system-name %s", &sys_name))
20386 else if (unformat (i, "tx-hold %d", &tx_hold))
20388 else if (unformat (i, "tx-interval %d", &tx_interval))
20392 clib_warning ("parse error '%U'", format_unformat_error, i);
20397 vec_add1 (sys_name, 0);
20399 M (LLDP_CONFIG, mp);
20400 mp->tx_hold = htonl (tx_hold);
20401 mp->tx_interval = htonl (tx_interval);
20402 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20403 vec_free (sys_name);
20411 api_sw_interface_set_lldp (vat_main_t * vam)
20413 unformat_input_t *i = vam->input;
20414 vl_api_sw_interface_set_lldp_t *mp;
20415 u32 sw_if_index = ~0;
20417 u8 *port_desc = NULL, *mgmt_oid = NULL;
20418 ip4_address_t ip4_addr;
20419 ip6_address_t ip6_addr;
20422 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
20423 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
20425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20427 if (unformat (i, "disable"))
20430 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20432 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20434 else if (unformat (i, "port-desc %s", &port_desc))
20436 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20438 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20440 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20446 if (sw_if_index == ~0)
20448 errmsg ("missing interface name or sw_if_index");
20452 /* Construct the API message */
20453 vec_add1 (port_desc, 0);
20454 vec_add1 (mgmt_oid, 0);
20455 M (SW_INTERFACE_SET_LLDP, mp);
20456 mp->sw_if_index = ntohl (sw_if_index);
20457 mp->enable = enable;
20458 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20459 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20460 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20461 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20462 vec_free (port_desc);
20463 vec_free (mgmt_oid);
20471 api_tcp_configure_src_addresses (vat_main_t * vam)
20473 vl_api_tcp_configure_src_addresses_t *mp;
20474 unformat_input_t *i = vam->input;
20475 ip4_address_t v4first, v4last;
20476 ip6_address_t v6first, v6last;
20481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20483 if (unformat (i, "%U - %U",
20484 unformat_ip4_address, &v4first,
20485 unformat_ip4_address, &v4last))
20489 errmsg ("one range per message (range already set)");
20494 else if (unformat (i, "%U - %U",
20495 unformat_ip6_address, &v6first,
20496 unformat_ip6_address, &v6last))
20500 errmsg ("one range per message (range already set)");
20505 else if (unformat (i, "vrf %d", &vrf_id))
20511 if (range_set == 0)
20513 errmsg ("address range not set");
20517 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20518 mp->vrf_id = ntohl (vrf_id);
20520 if (range_set == 2)
20523 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20524 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20529 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20530 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20537 static void vl_api_app_namespace_add_del_reply_t_handler
20538 (vl_api_app_namespace_add_del_reply_t * mp)
20540 vat_main_t *vam = &vat_main;
20541 i32 retval = ntohl (mp->retval);
20542 if (vam->async_mode)
20544 vam->async_errors += (retval < 0);
20548 vam->retval = retval;
20550 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
20551 vam->result_ready = 1;
20555 static void vl_api_app_namespace_add_del_reply_t_handler_json
20556 (vl_api_app_namespace_add_del_reply_t * mp)
20558 vat_main_t *vam = &vat_main;
20559 vat_json_node_t node;
20561 vat_json_init_object (&node);
20562 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
20563 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
20565 vat_json_print (vam->ofp, &node);
20566 vat_json_free (&node);
20568 vam->retval = ntohl (mp->retval);
20569 vam->result_ready = 1;
20573 api_app_namespace_add_del (vat_main_t * vam)
20575 vl_api_app_namespace_add_del_t *mp;
20576 unformat_input_t *i = vam->input;
20577 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
20578 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
20582 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20584 if (unformat (i, "id %_%v%_", &ns_id))
20586 else if (unformat (i, "secret %lu", &secret))
20588 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20589 sw_if_index_set = 1;
20590 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
20592 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
20597 if (!ns_id || !secret_set || !sw_if_index_set)
20599 errmsg ("namespace id, secret and sw_if_index must be set");
20602 if (vec_len (ns_id) > 64)
20604 errmsg ("namespace id too long");
20607 M (APP_NAMESPACE_ADD_DEL, mp);
20609 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
20610 mp->namespace_id_len = vec_len (ns_id);
20611 mp->secret = clib_host_to_net_u64 (secret);
20612 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20613 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
20614 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
20622 api_sock_init_shm (vat_main_t * vam)
20624 #if VPP_API_TEST_BUILTIN == 0
20625 unformat_input_t *i = vam->input;
20626 vl_api_shm_elem_config_t *config = 0;
20627 u64 size = 64 << 20;
20630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20632 if (unformat (i, "size %U", unformat_memory_size, &size))
20639 * Canned custom ring allocator config.
20640 * Should probably parse all of this
20642 vec_validate (config, 6);
20643 config[0].type = VL_API_VLIB_RING;
20644 config[0].size = 256;
20645 config[0].count = 32;
20647 config[1].type = VL_API_VLIB_RING;
20648 config[1].size = 1024;
20649 config[1].count = 16;
20651 config[2].type = VL_API_VLIB_RING;
20652 config[2].size = 4096;
20653 config[2].count = 2;
20655 config[3].type = VL_API_CLIENT_RING;
20656 config[3].size = 256;
20657 config[3].count = 32;
20659 config[4].type = VL_API_CLIENT_RING;
20660 config[4].size = 1024;
20661 config[4].count = 16;
20663 config[5].type = VL_API_CLIENT_RING;
20664 config[5].size = 4096;
20665 config[5].count = 2;
20667 config[6].type = VL_API_QUEUE;
20668 config[6].count = 128;
20669 config[6].size = sizeof (uword);
20671 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
20673 vam->client_index_invalid = 1;
20681 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
20683 vat_main_t *vam = &vat_main;
20688 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
20689 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
20690 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
20691 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
20692 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
20693 clib_net_to_host_u32 (mp->action_index), mp->tag);
20698 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
20699 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
20700 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
20701 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
20702 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
20703 clib_net_to_host_u32 (mp->action_index), mp->tag);
20708 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
20711 vat_main_t *vam = &vat_main;
20712 vat_json_node_t *node = NULL;
20713 struct in6_addr ip6;
20714 struct in_addr ip4;
20716 if (VAT_JSON_ARRAY != vam->json_tree.type)
20718 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20719 vat_json_init_array (&vam->json_tree);
20721 node = vat_json_array_add (&vam->json_tree);
20722 vat_json_init_object (node);
20724 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
20725 vat_json_object_add_uint (node, "appns_index",
20726 clib_net_to_host_u32 (mp->appns_index));
20727 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
20728 vat_json_object_add_uint (node, "scope", mp->scope);
20729 vat_json_object_add_uint (node, "action_index",
20730 clib_net_to_host_u32 (mp->action_index));
20731 vat_json_object_add_uint (node, "lcl_port",
20732 clib_net_to_host_u16 (mp->lcl_port));
20733 vat_json_object_add_uint (node, "rmt_port",
20734 clib_net_to_host_u16 (mp->rmt_port));
20735 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
20736 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
20737 vat_json_object_add_string_copy (node, "tag", mp->tag);
20740 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
20741 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
20742 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
20743 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
20747 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
20748 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
20749 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
20750 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
20755 api_session_rule_add_del (vat_main_t * vam)
20757 vl_api_session_rule_add_del_t *mp;
20758 unformat_input_t *i = vam->input;
20759 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
20760 u32 appns_index = 0, scope = 0;
20761 ip4_address_t lcl_ip4, rmt_ip4;
20762 ip6_address_t lcl_ip6, rmt_ip6;
20763 u8 is_ip4 = 1, conn_set = 0;
20764 u8 is_add = 1, *tag = 0;
20767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20769 if (unformat (i, "del"))
20771 else if (unformat (i, "add"))
20773 else if (unformat (i, "proto tcp"))
20775 else if (unformat (i, "proto udp"))
20777 else if (unformat (i, "appns %d", &appns_index))
20779 else if (unformat (i, "scope %d", &scope))
20781 else if (unformat (i, "tag %_%v%_", &tag))
20785 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
20786 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
20794 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
20795 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
20801 else if (unformat (i, "action %d", &action))
20806 if (proto == ~0 || !conn_set || action == ~0)
20808 errmsg ("transport proto, connection and action must be set");
20814 errmsg ("scope should be 0-3");
20818 M (SESSION_RULE_ADD_DEL, mp);
20820 mp->is_ip4 = is_ip4;
20821 mp->transport_proto = proto;
20822 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
20823 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
20824 mp->lcl_plen = lcl_plen;
20825 mp->rmt_plen = rmt_plen;
20826 mp->action_index = clib_host_to_net_u32 (action);
20827 mp->appns_index = clib_host_to_net_u32 (appns_index);
20829 mp->is_add = is_add;
20832 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
20833 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
20837 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
20838 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
20842 clib_memcpy (mp->tag, tag, vec_len (tag));
20852 api_session_rules_dump (vat_main_t * vam)
20854 vl_api_session_rules_dump_t *mp;
20855 vl_api_control_ping_t *mp_ping;
20858 if (!vam->json_output)
20860 print (vam->ofp, "%=20s", "Session Rules");
20863 M (SESSION_RULES_DUMP, mp);
20867 /* Use a control ping for synchronization */
20868 MPING (CONTROL_PING, mp_ping);
20871 /* Wait for a reply... */
20877 api_ip_container_proxy_add_del (vat_main_t * vam)
20879 vl_api_ip_container_proxy_add_del_t *mp;
20880 unformat_input_t *i = vam->input;
20881 u32 sw_if_index = ~0;
20882 vl_api_prefix_t pfx = { };
20886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20888 if (unformat (i, "del"))
20890 else if (unformat (i, "add"))
20892 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20894 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20899 if (sw_if_index == ~0 || pfx.len == 0)
20901 errmsg ("address and sw_if_index must be set");
20905 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20907 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20908 mp->is_add = is_add;
20909 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20917 api_qos_record_enable_disable (vat_main_t * vam)
20919 unformat_input_t *i = vam->input;
20920 vl_api_qos_record_enable_disable_t *mp;
20921 u32 sw_if_index, qs = 0xff;
20922 u8 sw_if_index_set = 0;
20926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20928 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20929 sw_if_index_set = 1;
20930 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20931 sw_if_index_set = 1;
20932 else if (unformat (i, "%U", unformat_qos_source, &qs))
20934 else if (unformat (i, "disable"))
20938 clib_warning ("parse error '%U'", format_unformat_error, i);
20943 if (sw_if_index_set == 0)
20945 errmsg ("missing interface name or sw_if_index");
20950 errmsg ("input location must be specified");
20954 M (QOS_RECORD_ENABLE_DISABLE, mp);
20956 mp->record.sw_if_index = ntohl (sw_if_index);
20957 mp->record.input_source = qs;
20958 mp->enable = enable;
20967 q_or_quit (vat_main_t * vam)
20969 #if VPP_API_TEST_BUILTIN == 0
20970 longjmp (vam->jump_buf, 1);
20972 return 0; /* not so much */
20976 q (vat_main_t * vam)
20978 return q_or_quit (vam);
20982 quit (vat_main_t * vam)
20984 return q_or_quit (vam);
20988 comment (vat_main_t * vam)
20994 elog_save (vat_main_t * vam)
20996 #if VPP_API_TEST_BUILTIN == 0
20997 elog_main_t *em = &vam->elog_main;
20998 unformat_input_t *i = vam->input;
20999 char *file, *chroot_file;
21000 clib_error_t *error;
21002 if (!unformat (i, "%s", &file))
21004 errmsg ("expected file name, got `%U'", format_unformat_error, i);
21008 /* It's fairly hard to get "../oopsie" through unformat; just in case */
21009 if (strstr (file, "..") || index (file, '/'))
21011 errmsg ("illegal characters in filename '%s'", file);
21015 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
21019 errmsg ("Saving %wd of %wd events to %s",
21020 elog_n_events_in_buffer (em),
21021 elog_buffer_capacity (em), chroot_file);
21023 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
21024 vec_free (chroot_file);
21027 clib_error_report (error);
21029 errmsg ("Use the vpp event loger...");
21036 elog_setup (vat_main_t * vam)
21038 #if VPP_API_TEST_BUILTIN == 0
21039 elog_main_t *em = &vam->elog_main;
21040 unformat_input_t *i = vam->input;
21041 u32 nevents = 128 << 10;
21043 (void) unformat (i, "nevents %d", &nevents);
21045 elog_init (em, nevents);
21046 vl_api_set_elog_main (em);
21047 vl_api_set_elog_trace_api_messages (1);
21048 errmsg ("Event logger initialized with %u events", nevents);
21050 errmsg ("Use the vpp event loger...");
21056 elog_enable (vat_main_t * vam)
21058 #if VPP_API_TEST_BUILTIN == 0
21059 elog_main_t *em = &vam->elog_main;
21061 elog_enable_disable (em, 1 /* enable */ );
21062 vl_api_set_elog_trace_api_messages (1);
21063 errmsg ("Event logger enabled...");
21065 errmsg ("Use the vpp event loger...");
21071 elog_disable (vat_main_t * vam)
21073 #if VPP_API_TEST_BUILTIN == 0
21074 elog_main_t *em = &vam->elog_main;
21076 elog_enable_disable (em, 0 /* enable */ );
21077 vl_api_set_elog_trace_api_messages (1);
21078 errmsg ("Event logger disabled...");
21080 errmsg ("Use the vpp event loger...");
21086 statseg (vat_main_t * vam)
21088 ssvm_private_t *ssvmp = &vam->stat_segment;
21089 ssvm_shared_header_t *shared_header = ssvmp->sh;
21090 vlib_counter_t **counters;
21091 u64 thread0_index1_packets;
21092 u64 thread0_index1_bytes;
21093 f64 vector_rate, input_rate;
21096 uword *counter_vector_by_name;
21097 if (vam->stat_segment_lockp == 0)
21099 errmsg ("Stat segment not mapped...");
21103 /* look up "/if/rx for sw_if_index 1 as a test */
21105 clib_spinlock_lock (vam->stat_segment_lockp);
21107 counter_vector_by_name = (uword *) shared_header->opaque[1];
21109 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21112 clib_spinlock_unlock (vam->stat_segment_lockp);
21113 errmsg ("/if/tx not found?");
21117 /* Fish per-thread vector of combined counters from shared memory */
21118 counters = (vlib_counter_t **) p[0];
21120 if (vec_len (counters[0]) < 2)
21122 clib_spinlock_unlock (vam->stat_segment_lockp);
21123 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21127 /* Read thread 0 sw_if_index 1 counter */
21128 thread0_index1_packets = counters[0][1].packets;
21129 thread0_index1_bytes = counters[0][1].bytes;
21131 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21134 clib_spinlock_unlock (vam->stat_segment_lockp);
21135 errmsg ("vector_rate not found?");
21139 vector_rate = *(f64 *) (p[0]);
21140 p = hash_get_mem (counter_vector_by_name, "input_rate");
21143 clib_spinlock_unlock (vam->stat_segment_lockp);
21144 errmsg ("input_rate not found?");
21147 input_rate = *(f64 *) (p[0]);
21149 clib_spinlock_unlock (vam->stat_segment_lockp);
21151 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21152 vector_rate, input_rate);
21153 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21154 thread0_index1_packets, thread0_index1_bytes);
21160 cmd_cmp (void *a1, void *a2)
21165 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21169 help (vat_main_t * vam)
21174 unformat_input_t *i = vam->input;
21177 if (unformat (i, "%s", &name))
21181 vec_add1 (name, 0);
21183 hs = hash_get_mem (vam->help_by_name, name);
21185 print (vam->ofp, "usage: %s %s", name, hs[0]);
21187 print (vam->ofp, "No such msg / command '%s'", name);
21192 print (vam->ofp, "Help is available for the following:");
21195 hash_foreach_pair (p, vam->function_by_name,
21197 vec_add1 (cmds, (u8 *)(p->key));
21201 vec_sort_with_function (cmds, cmd_cmp);
21203 for (j = 0; j < vec_len (cmds); j++)
21204 print (vam->ofp, "%s", cmds[j]);
21211 set (vat_main_t * vam)
21213 u8 *name = 0, *value = 0;
21214 unformat_input_t *i = vam->input;
21216 if (unformat (i, "%s", &name))
21218 /* The input buffer is a vector, not a string. */
21219 value = vec_dup (i->buffer);
21220 vec_delete (value, i->index, 0);
21221 /* Almost certainly has a trailing newline */
21222 if (value[vec_len (value) - 1] == '\n')
21223 value[vec_len (value) - 1] = 0;
21224 /* Make sure it's a proper string, one way or the other */
21225 vec_add1 (value, 0);
21226 (void) clib_macro_set_value (&vam->macro_main,
21227 (char *) name, (char *) value);
21230 errmsg ("usage: set <name> <value>");
21238 unset (vat_main_t * vam)
21242 if (unformat (vam->input, "%s", &name))
21243 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21244 errmsg ("unset: %s wasn't set", name);
21257 macro_sort_cmp (void *a1, void *a2)
21259 macro_sort_t *s1 = a1;
21260 macro_sort_t *s2 = a2;
21262 return strcmp ((char *) (s1->name), (char *) (s2->name));
21266 dump_macro_table (vat_main_t * vam)
21268 macro_sort_t *sort_me = 0, *sm;
21273 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21275 vec_add2 (sort_me, sm, 1);
21276 sm->name = (u8 *)(p->key);
21277 sm->value = (u8 *) (p->value[0]);
21281 vec_sort_with_function (sort_me, macro_sort_cmp);
21283 if (vec_len (sort_me))
21284 print (vam->ofp, "%-15s%s", "Name", "Value");
21286 print (vam->ofp, "The macro table is empty...");
21288 for (i = 0; i < vec_len (sort_me); i++)
21289 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21294 dump_node_table (vat_main_t * vam)
21297 vlib_node_t *node, *next_node;
21299 if (vec_len (vam->graph_nodes) == 0)
21301 print (vam->ofp, "Node table empty, issue get_node_graph...");
21305 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
21307 node = vam->graph_nodes[0][i];
21308 print (vam->ofp, "[%d] %s", i, node->name);
21309 for (j = 0; j < vec_len (node->next_nodes); j++)
21311 if (node->next_nodes[j] != ~0)
21313 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21314 print (vam->ofp, " [%d] %s", j, next_node->name);
21322 value_sort_cmp (void *a1, void *a2)
21324 name_sort_t *n1 = a1;
21325 name_sort_t *n2 = a2;
21327 if (n1->value < n2->value)
21329 if (n1->value > n2->value)
21336 dump_msg_api_table (vat_main_t * vam)
21338 api_main_t *am = vlibapi_get_main ();
21339 name_sort_t *nses = 0, *ns;
21344 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21346 vec_add2 (nses, ns, 1);
21347 ns->name = (u8 *)(hp->key);
21348 ns->value = (u32) hp->value[0];
21352 vec_sort_with_function (nses, value_sort_cmp);
21354 for (i = 0; i < vec_len (nses); i++)
21355 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21361 get_msg_id (vat_main_t * vam)
21366 if (unformat (vam->input, "%s", &name_and_crc))
21368 message_index = vl_msg_api_get_msg_index (name_and_crc);
21369 if (message_index == ~0)
21371 print (vam->ofp, " '%s' not found", name_and_crc);
21374 print (vam->ofp, " '%s' has message index %d",
21375 name_and_crc, message_index);
21378 errmsg ("name_and_crc required...");
21383 search_node_table (vat_main_t * vam)
21385 unformat_input_t *line_input = vam->input;
21388 vlib_node_t *node, *next_node;
21391 if (vam->graph_node_index_by_name == 0)
21393 print (vam->ofp, "Node table empty, issue get_node_graph...");
21397 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21399 if (unformat (line_input, "%s", &node_to_find))
21401 vec_add1 (node_to_find, 0);
21402 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21405 print (vam->ofp, "%s not found...", node_to_find);
21408 node = vam->graph_nodes[0][p[0]];
21409 print (vam->ofp, "[%d] %s", p[0], node->name);
21410 for (j = 0; j < vec_len (node->next_nodes); j++)
21412 if (node->next_nodes[j] != ~0)
21414 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21415 print (vam->ofp, " [%d] %s", j, next_node->name);
21422 clib_warning ("parse error '%U'", format_unformat_error,
21428 vec_free (node_to_find);
21437 script (vat_main_t * vam)
21439 #if (VPP_API_TEST_BUILTIN==0)
21441 char *save_current_file;
21442 unformat_input_t save_input;
21443 jmp_buf save_jump_buf;
21444 u32 save_line_number;
21446 FILE *new_fp, *save_ifp;
21448 if (unformat (vam->input, "%s", &s))
21450 new_fp = fopen ((char *) s, "r");
21453 errmsg ("Couldn't open script file %s", s);
21460 errmsg ("Missing script name");
21464 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21465 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21466 save_ifp = vam->ifp;
21467 save_line_number = vam->input_line_number;
21468 save_current_file = (char *) vam->current_file;
21470 vam->input_line_number = 0;
21472 vam->current_file = s;
21475 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
21476 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21477 vam->ifp = save_ifp;
21478 vam->input_line_number = save_line_number;
21479 vam->current_file = (u8 *) save_current_file;
21484 clib_warning ("use the exec command...");
21490 echo (vat_main_t * vam)
21492 print (vam->ofp, "%v", vam->input->buffer);
21496 /* List of API message constructors, CLI names map to api_xxx */
21497 #define foreach_vpe_api_msg \
21498 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21499 _(sw_interface_dump,"") \
21500 _(sw_interface_set_flags, \
21501 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21502 _(sw_interface_add_del_address, \
21503 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
21504 _(sw_interface_set_rx_mode, \
21505 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
21506 _(sw_interface_set_rx_placement, \
21507 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
21508 _(sw_interface_rx_placement_dump, \
21509 "[<intfc> | sw_if_index <id>]") \
21510 _(sw_interface_set_table, \
21511 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
21512 _(sw_interface_set_mpls_enable, \
21513 "<intfc> | sw_if_index [disable | dis]") \
21514 _(sw_interface_set_vpath, \
21515 "<intfc> | sw_if_index <id> enable | disable") \
21516 _(sw_interface_set_vxlan_bypass, \
21517 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21518 _(sw_interface_set_geneve_bypass, \
21519 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21520 _(sw_interface_set_l2_xconnect, \
21521 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21522 "enable | disable") \
21523 _(sw_interface_set_l2_bridge, \
21524 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
21525 "[shg <split-horizon-group>] [bvi]\n" \
21526 "enable | disable") \
21527 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
21528 _(bridge_domain_add_del, \
21529 "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") \
21530 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
21532 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
21533 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
21534 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
21536 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21538 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21540 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
21542 "<vpp-if-name> | sw_if_index <id>") \
21543 _(sw_interface_tap_v2_dump, "") \
21544 _(virtio_pci_create, \
21545 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
21546 _(virtio_pci_delete, \
21547 "<vpp-if-name> | sw_if_index <id>") \
21548 _(sw_interface_virtio_pci_dump, "") \
21550 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
21551 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
21554 "<vpp-if-name> | sw_if_index <id>") \
21556 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
21557 _(bond_detach_slave, \
21558 "sw_if_index <n>") \
21559 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
21560 _(sw_interface_bond_dump, "") \
21561 _(sw_interface_slave_dump, \
21562 "<vpp-if-name> | sw_if_index <id>") \
21563 _(ip_table_add_del, \
21564 "table <n> [ipv6] [add | del]\n") \
21565 _(ip_route_add_del, \
21566 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
21567 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
21568 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
21569 "[multipath] [count <n>] [del]") \
21570 _(ip_mroute_add_del, \
21571 "<src> <grp>/<mask> [table-id <n>]\n" \
21572 "[<intfc> | sw_if_index <id>] [local] [del]") \
21573 _(mpls_table_add_del, \
21574 "table <n> [add | del]\n") \
21575 _(mpls_route_add_del, \
21576 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
21577 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
21578 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
21579 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
21580 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
21581 "[count <n>] [del]") \
21582 _(mpls_ip_bind_unbind, \
21583 "<label> <addr/len>") \
21584 _(mpls_tunnel_add_del, \
21585 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
21586 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
21587 "[l2-only] [out-label <n>]") \
21588 _(sr_mpls_policy_add, \
21589 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
21590 _(sr_mpls_policy_del, \
21592 _(bier_table_add_del, \
21593 "<label> <sub-domain> <set> <bsl> [del]") \
21594 _(bier_route_add_del, \
21595 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
21596 "[<intfc> | sw_if_index <id>]" \
21597 "[weight <n>] [del] [multipath]") \
21598 _(proxy_arp_add_del, \
21599 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
21600 _(proxy_arp_intfc_enable_disable, \
21601 "<intfc> | sw_if_index <id> enable | disable") \
21602 _(sw_interface_set_unnumbered, \
21603 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
21604 _(ip_neighbor_add_del, \
21605 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
21606 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
21607 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
21608 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
21609 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
21610 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
21611 "[outer_vlan_id_any][inner_vlan_id_any]") \
21612 _(ip_table_replace_begin, "table <n> [ipv6]") \
21613 _(ip_table_flush, "table <n> [ipv6]") \
21614 _(ip_table_replace_end, "table <n> [ipv6]") \
21615 _(set_ip_flow_hash, \
21616 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
21617 _(sw_interface_ip6_enable_disable, \
21618 "<intfc> | sw_if_index <id> enable | disable") \
21619 _(ip6nd_proxy_add_del, \
21620 "<intfc> | sw_if_index <id> <ip6-address>") \
21621 _(ip6nd_proxy_dump, "") \
21622 _(sw_interface_ip6nd_ra_prefix, \
21623 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
21624 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
21625 "[nolink] [isno]") \
21626 _(sw_interface_ip6nd_ra_config, \
21627 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
21628 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
21629 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
21630 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
21631 _(l2_patch_add_del, \
21632 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21633 "enable | disable") \
21634 _(sr_localsid_add_del, \
21635 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
21636 "fib-table <num> (end.psp) sw_if_index <num>") \
21637 _(classify_add_del_table, \
21638 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
21639 " [del] [del-chain] mask <mask-value>\n" \
21640 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
21641 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
21642 _(classify_add_del_session, \
21643 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
21644 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
21645 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
21646 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
21647 _(classify_set_interface_ip_table, \
21648 "<intfc> | sw_if_index <nn> table <nn>") \
21649 _(classify_set_interface_l2_tables, \
21650 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21651 " [other-table <nn>]") \
21652 _(get_node_index, "node <node-name") \
21653 _(add_node_next, "node <node-name> next <next-node-name>") \
21654 _(l2tpv3_create_tunnel, \
21655 "client_address <ip6-addr> our_address <ip6-addr>\n" \
21656 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
21657 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
21658 _(l2tpv3_set_tunnel_cookies, \
21659 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
21660 "[new_remote_cookie <nn>]\n") \
21661 _(l2tpv3_interface_enable_disable, \
21662 "<intfc> | sw_if_index <nn> enable | disable") \
21663 _(l2tpv3_set_lookup_key, \
21664 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
21665 _(sw_if_l2tpv3_tunnel_dump, "") \
21666 _(vxlan_offload_rx, \
21667 "hw { <interface name> | hw_if_index <nn>} " \
21668 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
21669 _(vxlan_add_del_tunnel, \
21670 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21671 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
21672 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21673 _(geneve_add_del_tunnel, \
21674 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21675 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21676 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21677 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21678 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21679 _(gre_tunnel_add_del, \
21680 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
21681 "[teb | erspan <session-id>] [del]") \
21682 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21683 _(l2_fib_clear_table, "") \
21684 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
21685 _(l2_interface_vlan_tag_rewrite, \
21686 "<intfc> | sw_if_index <nn> \n" \
21687 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
21688 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
21689 _(create_vhost_user_if, \
21690 "socket <filename> [server] [renumber <dev_instance>] " \
21691 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
21692 "[mac <mac_address>]") \
21693 _(modify_vhost_user_if, \
21694 "<intfc> | sw_if_index <nn> socket <filename>\n" \
21695 "[server] [renumber <dev_instance>] [gso]") \
21696 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
21697 _(sw_interface_vhost_user_dump, "") \
21698 _(show_version, "") \
21699 _(show_threads, "") \
21700 _(vxlan_gpe_add_del_tunnel, \
21701 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
21702 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21703 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
21704 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
21705 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21706 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
21707 _(interface_name_renumber, \
21708 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
21709 _(input_acl_set_interface, \
21710 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21711 " [l2-table <nn>] [del]") \
21712 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
21713 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
21714 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
21715 _(want_ip4_arp_events, "address <ip4-address> [del]") \
21716 _(want_ip6_nd_events, "address <ip6-address> [del]") \
21717 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
21718 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
21719 _(ip_dump, "ipv4 | ipv6") \
21720 _(ipsec_spd_add_del, "spd_id <n> [del]") \
21721 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
21723 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
21724 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
21725 " integ_alg <alg> integ_key <hex>") \
21726 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
21727 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
21728 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
21729 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
21730 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
21731 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
21732 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
21733 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
21734 " [instance <n>]") \
21735 _(ipsec_sa_dump, "[sa_id <n>]") \
21736 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
21737 _(delete_loopback,"sw_if_index <nn>") \
21738 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
21739 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
21740 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
21741 _(want_interface_events, "enable|disable") \
21742 _(get_first_msg_id, "client <name>") \
21743 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
21744 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
21745 "fib-id <nn> [ip4][ip6][default]") \
21746 _(get_node_graph, " ") \
21747 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
21748 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
21749 _(ioam_disable, "") \
21750 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
21751 " sw_if_index <sw_if_index> p <priority> " \
21752 "w <weight>] [del]") \
21753 _(one_add_del_locator, "locator-set <locator_name> " \
21754 "iface <intf> | sw_if_index <sw_if_index> " \
21755 "p <priority> w <weight> [del]") \
21756 _(one_add_del_local_eid,"vni <vni> eid " \
21757 "<ipv4|ipv6>/<prefix> | <L2 address> " \
21758 "locator-set <locator_name> [del]" \
21759 "[key-id sha1|sha256 secret-key <secret-key>]")\
21760 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
21761 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
21762 _(one_enable_disable, "enable|disable") \
21763 _(one_map_register_enable_disable, "enable|disable") \
21764 _(one_map_register_fallback_threshold, "<value>") \
21765 _(one_rloc_probe_enable_disable, "enable|disable") \
21766 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
21768 "rloc <locator> p <prio> " \
21769 "w <weight> [rloc <loc> ... ] " \
21770 "action <action> [del-all]") \
21771 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21773 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21774 _(one_use_petr, "ip-address> | disable") \
21775 _(one_map_request_mode, "src-dst|dst-only") \
21776 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21777 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21778 _(one_locator_set_dump, "[local | remote]") \
21779 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
21780 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21781 "[local] | [remote]") \
21782 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
21783 _(one_ndp_bd_get, "") \
21784 _(one_ndp_entries_get, "bd <bridge-domain>") \
21785 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
21786 _(one_l2_arp_bd_get, "") \
21787 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
21788 _(one_stats_enable_disable, "enable|disable") \
21789 _(show_one_stats_enable_disable, "") \
21790 _(one_eid_table_vni_dump, "") \
21791 _(one_eid_table_map_dump, "l2|l3") \
21792 _(one_map_resolver_dump, "") \
21793 _(one_map_server_dump, "") \
21794 _(one_adjacencies_get, "vni <vni>") \
21795 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
21796 _(show_one_rloc_probe_state, "") \
21797 _(show_one_map_register_state, "") \
21798 _(show_one_status, "") \
21799 _(one_stats_dump, "") \
21800 _(one_stats_flush, "") \
21801 _(one_get_map_request_itr_rlocs, "") \
21802 _(one_map_register_set_ttl, "<ttl>") \
21803 _(one_set_transport_protocol, "udp|api") \
21804 _(one_get_transport_protocol, "") \
21805 _(one_enable_disable_xtr_mode, "enable|disable") \
21806 _(one_show_xtr_mode, "") \
21807 _(one_enable_disable_pitr_mode, "enable|disable") \
21808 _(one_show_pitr_mode, "") \
21809 _(one_enable_disable_petr_mode, "enable|disable") \
21810 _(one_show_petr_mode, "") \
21811 _(show_one_nsh_mapping, "") \
21812 _(show_one_pitr, "") \
21813 _(show_one_use_petr, "") \
21814 _(show_one_map_request_mode, "") \
21815 _(show_one_map_register_ttl, "") \
21816 _(show_one_map_register_fallback_threshold, "") \
21817 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
21818 " sw_if_index <sw_if_index> p <priority> " \
21819 "w <weight>] [del]") \
21820 _(lisp_add_del_locator, "locator-set <locator_name> " \
21821 "iface <intf> | sw_if_index <sw_if_index> " \
21822 "p <priority> w <weight> [del]") \
21823 _(lisp_add_del_local_eid,"vni <vni> eid " \
21824 "<ipv4|ipv6>/<prefix> | <L2 address> " \
21825 "locator-set <locator_name> [del]" \
21826 "[key-id sha1|sha256 secret-key <secret-key>]") \
21827 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
21828 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
21829 _(lisp_enable_disable, "enable|disable") \
21830 _(lisp_map_register_enable_disable, "enable|disable") \
21831 _(lisp_rloc_probe_enable_disable, "enable|disable") \
21832 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
21834 "rloc <locator> p <prio> " \
21835 "w <weight> [rloc <loc> ... ] " \
21836 "action <action> [del-all]") \
21837 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21839 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21840 _(lisp_use_petr, "<ip-address> | disable") \
21841 _(lisp_map_request_mode, "src-dst|dst-only") \
21842 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21843 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21844 _(lisp_locator_set_dump, "[local | remote]") \
21845 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
21846 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21847 "[local] | [remote]") \
21848 _(lisp_eid_table_vni_dump, "") \
21849 _(lisp_eid_table_map_dump, "l2|l3") \
21850 _(lisp_map_resolver_dump, "") \
21851 _(lisp_map_server_dump, "") \
21852 _(lisp_adjacencies_get, "vni <vni>") \
21853 _(gpe_fwd_entry_vnis_get, "") \
21854 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
21855 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
21856 "[table <table-id>]") \
21857 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
21858 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
21859 _(gpe_set_encap_mode, "lisp|vxlan") \
21860 _(gpe_get_encap_mode, "") \
21861 _(lisp_gpe_add_del_iface, "up|down") \
21862 _(lisp_gpe_enable_disable, "enable|disable") \
21863 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
21864 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
21865 _(show_lisp_rloc_probe_state, "") \
21866 _(show_lisp_map_register_state, "") \
21867 _(show_lisp_status, "") \
21868 _(lisp_get_map_request_itr_rlocs, "") \
21869 _(show_lisp_pitr, "") \
21870 _(show_lisp_use_petr, "") \
21871 _(show_lisp_map_request_mode, "") \
21872 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
21873 _(af_packet_delete, "name <host interface name>") \
21874 _(af_packet_dump, "") \
21875 _(policer_add_del, "name <policer name> <params> [del]") \
21876 _(policer_dump, "[name <policer name>]") \
21877 _(policer_classify_set_interface, \
21878 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21879 " [l2-table <nn>] [del]") \
21880 _(policer_classify_dump, "type [ip4|ip6|l2]") \
21881 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
21882 "[master|slave]") \
21883 _(netmap_delete, "name <interface name>") \
21884 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
21885 _(mpls_table_dump, "") \
21886 _(mpls_route_dump, "table-id <ID>") \
21887 _(classify_table_ids, "") \
21888 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
21889 _(classify_table_info, "table_id <nn>") \
21890 _(classify_session_dump, "table_id <nn>") \
21891 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
21892 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
21893 "[template_interval <nn>] [udp_checksum]") \
21894 _(ipfix_exporter_dump, "") \
21895 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
21896 _(ipfix_classify_stream_dump, "") \
21897 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
21898 _(ipfix_classify_table_dump, "") \
21899 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
21900 _(sw_interface_span_dump, "[l2]") \
21901 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
21902 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
21903 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
21904 _(pg_enable_disable, "[stream <id>] disable") \
21905 _(ip_source_and_port_range_check_add_del, \
21906 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21907 _(ip_source_and_port_range_check_interface_add_del, \
21908 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21909 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21910 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21911 _(l2_interface_pbb_tag_rewrite, \
21912 "<intfc> | sw_if_index <nn> \n" \
21913 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21914 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21915 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21916 _(flow_classify_set_interface, \
21917 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21918 _(flow_classify_dump, "type [ip4|ip6]") \
21919 _(ip_table_dump, "") \
21920 _(ip_route_dump, "table-id [ip4|ip6]") \
21921 _(ip_mtable_dump, "") \
21922 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21923 _(feature_enable_disable, "arc_name <arc_name> " \
21924 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21925 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21926 "[enable | disable] ") \
21927 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21929 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21930 "mac <mac-address> [del]") \
21931 _(l2_xconnect_dump, "") \
21932 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21933 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
21934 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21935 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21936 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21937 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21938 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21939 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21940 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21941 _(sock_init_shm, "size <nnn>") \
21942 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21943 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21944 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21945 _(session_rules_dump, "") \
21946 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21947 _(output_acl_set_interface, \
21948 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21949 " [l2-table <nn>] [del]") \
21950 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21952 /* List of command functions, CLI names map directly to functions */
21953 #define foreach_cli_function \
21954 _(comment, "usage: comment <ignore-rest-of-line>") \
21955 _(dump_interface_table, "usage: dump_interface_table") \
21956 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21957 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21958 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21959 _(dump_macro_table, "usage: dump_macro_table ") \
21960 _(dump_node_table, "usage: dump_node_table") \
21961 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21962 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21963 _(elog_disable, "usage: elog_disable") \
21964 _(elog_enable, "usage: elog_enable") \
21965 _(elog_save, "usage: elog_save <filename>") \
21966 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21967 _(echo, "usage: echo <message>") \
21968 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21969 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21970 _(help, "usage: help") \
21971 _(q, "usage: quit") \
21972 _(quit, "usage: quit") \
21973 _(search_node_table, "usage: search_node_table <name>...") \
21974 _(set, "usage: set <variable-name> <value>") \
21975 _(script, "usage: script <file-name>") \
21976 _(statseg, "usage: statseg") \
21977 _(unset, "usage: unset <variable-name>")
21980 static void vl_api_##n##_t_handler_uni \
21981 (vl_api_##n##_t * mp) \
21983 vat_main_t * vam = &vat_main; \
21984 if (vam->json_output) { \
21985 vl_api_##n##_t_handler_json(mp); \
21987 vl_api_##n##_t_handler(mp); \
21990 foreach_vpe_api_reply_msg;
21991 #if VPP_API_TEST_BUILTIN == 0
21992 foreach_standalone_reply_msg;
21997 vat_api_hookup (vat_main_t * vam)
22000 vl_msg_api_set_handlers(VL_API_##N, #n, \
22001 vl_api_##n##_t_handler_uni, \
22003 vl_api_##n##_t_endian, \
22004 vl_api_##n##_t_print, \
22005 sizeof(vl_api_##n##_t), 1);
22006 foreach_vpe_api_reply_msg;
22007 #if VPP_API_TEST_BUILTIN == 0
22008 foreach_standalone_reply_msg;
22012 #if (VPP_API_TEST_BUILTIN==0)
22013 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22015 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22017 vam->function_by_name = hash_create_string (0, sizeof (uword));
22019 vam->help_by_name = hash_create_string (0, sizeof (uword));
22022 /* API messages we can send */
22023 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22024 foreach_vpe_api_msg;
22028 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22029 foreach_vpe_api_msg;
22032 /* CLI functions */
22033 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22034 foreach_cli_function;
22038 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22039 foreach_cli_function;
22043 #if VPP_API_TEST_BUILTIN
22044 static clib_error_t *
22045 vat_api_hookup_shim (vlib_main_t * vm)
22047 vat_api_hookup (&vat_main);
22051 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22055 * fd.io coding-style-patch-verification: ON
22058 * eval: (c-set-style "gnu")