2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2020 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/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/ip/ip6_hop_by_hop.h>
47 #include <vnet/ip/ip_source_and_port_range_check.h>
48 #include <vnet/policer/xlate.h>
49 #include <vnet/span/span.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
52 #include <vnet/mfib/mfib_types.h>
53 #include <vnet/bonding/node.h>
54 #include <vnet/qos/qos_types.h>
55 #include <vnet/ethernet/ethernet_types_api.h>
56 #include <vnet/ip/ip_types_api.h>
57 #include "vat/json_format.h"
58 #include <vnet/ip/ip_types_api.h>
59 #include <vnet/ethernet/ethernet_types_api.h>
64 #define vl_typedefs /* define message structures */
65 #include <vpp/api/vpe_all_api_h.h>
68 /* declare message handlers for each api */
70 #define vl_endianfun /* define message structures */
71 #include <vpp/api/vpe_all_api_h.h>
74 /* instantiate all the print functions we know about */
75 #if VPP_API_TEST_BUILTIN == 0
76 #define vl_print(handle, ...)
78 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
81 #include <vpp/api/vpe_all_api_h.h>
84 #define __plugin_msg_base 0
85 #include <vlibapi/vat_helper_macros.h>
87 #include <vnet/format_fns.h>
89 void vl_api_set_elog_main (elog_main_t * m);
90 int vl_api_set_elog_trace_api_messages (int enable);
92 #if VPP_API_TEST_BUILTIN == 0
102 vat_socket_connect (vat_main_t * vam)
105 api_main_t *am = vlibapi_get_main ();
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 */ )))
112 /* vpp expects the client index in network order */
113 vam->my_client_index = htonl (socket_client_main.client_index);
114 am->my_client_index = vam->my_client_index;
117 #else /* vpp built-in case, we don't do sockets... */
119 vat_socket_connect (vat_main_t * vam)
125 vl_socket_client_read (int wait)
131 vl_socket_client_write ()
137 vl_socket_client_msg_alloc (int nbytes)
145 vat_time_now (vat_main_t * vam)
147 #if VPP_API_TEST_BUILTIN
148 return vlib_time_now (vam->vlib_main);
150 return clib_time_now (&vam->clib_time);
155 errmsg (char *fmt, ...)
157 vat_main_t *vam = &vat_main;
162 s = va_format (0, fmt, &va);
167 #if VPP_API_TEST_BUILTIN
168 vlib_cli_output (vam->vlib_main, (char *) s);
171 if (vam->ifp != stdin)
172 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
173 vam->input_line_number);
175 fformat (vam->ofp, "%s\n", (char *) s);
183 #if VPP_API_TEST_BUILTIN == 0
185 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
187 vat_main_t *vam = va_arg (*args, vat_main_t *);
188 u32 *result = va_arg (*args, u32 *);
192 if (!unformat (input, "%s", &if_name))
195 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
203 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
208 /* Parse an IP4 address %d.%d.%d.%d. */
210 unformat_ip4_address (unformat_input_t * input, va_list * args)
212 u8 *result = va_arg (*args, u8 *);
215 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
218 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
230 unformat_ethernet_address (unformat_input_t * input, va_list * args)
232 u8 *result = va_arg (*args, u8 *);
235 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
236 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
240 for (i = 0; i < 6; i++)
241 if (a[i] >= (1 << 8))
244 for (i = 0; i < 6; i++)
250 /* Returns ethernet type as an int in host byte order. */
252 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
255 u16 *result = va_arg (*args, u16 *);
259 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
261 if (type >= (1 << 16))
269 /* Parse an IP46 address. */
271 unformat_ip46_address (unformat_input_t * input, va_list * args)
273 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
274 ip46_type_t type = va_arg (*args, ip46_type_t);
275 if ((type != IP46_TYPE_IP6) &&
276 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
278 ip46_address_mask_ip4 (ip46);
281 else if ((type != IP46_TYPE_IP4) &&
282 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
289 /* Parse an IP6 address. */
291 unformat_ip6_address (unformat_input_t * input, va_list * args)
293 ip6_address_t *result = va_arg (*args, ip6_address_t *);
295 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
296 uword c, n_colon, double_colon_index;
298 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
299 double_colon_index = ARRAY_LEN (hex_quads);
300 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
303 if (c >= '0' && c <= '9')
305 else if (c >= 'a' && c <= 'f')
306 hex_digit = c + 10 - 'a';
307 else if (c >= 'A' && c <= 'F')
308 hex_digit = c + 10 - 'A';
309 else if (c == ':' && n_colon < 2)
313 unformat_put_input (input);
317 /* Too many hex quads. */
318 if (n_hex_quads >= ARRAY_LEN (hex_quads))
323 hex_quad = (hex_quad << 4) | hex_digit;
325 /* Hex quad must fit in 16 bits. */
326 if (n_hex_digits >= 4)
333 /* Save position of :: */
336 /* More than one :: ? */
337 if (double_colon_index < ARRAY_LEN (hex_quads))
339 double_colon_index = n_hex_quads;
342 if (n_colon > 0 && n_hex_digits > 0)
344 hex_quads[n_hex_quads++] = hex_quad;
350 if (n_hex_digits > 0)
351 hex_quads[n_hex_quads++] = hex_quad;
356 /* Expand :: to appropriate number of zero hex quads. */
357 if (double_colon_index < ARRAY_LEN (hex_quads))
359 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
361 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
362 hex_quads[n_zero + i] = hex_quads[i];
364 for (i = 0; i < n_zero; i++)
365 hex_quads[double_colon_index + i] = 0;
367 n_hex_quads = ARRAY_LEN (hex_quads);
370 /* Too few hex quads given. */
371 if (n_hex_quads < ARRAY_LEN (hex_quads))
374 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
375 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
382 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
384 u32 *r = va_arg (*args, u32 *);
387 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
388 foreach_ipsec_policy_action
396 format_ipsec_crypto_alg (u8 * s, va_list * args)
398 u32 i = va_arg (*args, u32);
403 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
404 foreach_ipsec_crypto_alg
407 return format (s, "unknown");
409 return format (s, "%s", t);
413 format_ipsec_integ_alg (u8 * s, va_list * args)
415 u32 i = va_arg (*args, u32);
420 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
421 foreach_ipsec_integ_alg
424 return format (s, "unknown");
426 return format (s, "%s", t);
429 #else /* VPP_API_TEST_BUILTIN == 1 */
431 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
433 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
434 vnet_main_t *vnm = vnet_get_main ();
435 u32 *result = va_arg (*args, u32 *);
437 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
441 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
443 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
444 vnet_main_t *vnm = vnet_get_main ();
445 u32 *result = va_arg (*args, u32 *);
447 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
450 #endif /* VPP_API_TEST_BUILTIN */
453 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
455 u32 *r = va_arg (*args, u32 *);
458 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
459 foreach_ipsec_crypto_alg
467 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
469 u32 *r = va_arg (*args, u32 *);
472 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
473 foreach_ipsec_integ_alg
481 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
483 u8 *r = va_arg (*args, u8 *);
485 if (unformat (input, "kbps"))
486 *r = SSE2_QOS_RATE_KBPS;
487 else if (unformat (input, "pps"))
488 *r = SSE2_QOS_RATE_PPS;
495 unformat_policer_round_type (unformat_input_t * input, va_list * args)
497 u8 *r = va_arg (*args, u8 *);
499 if (unformat (input, "closest"))
500 *r = SSE2_QOS_ROUND_TO_CLOSEST;
501 else if (unformat (input, "up"))
502 *r = SSE2_QOS_ROUND_TO_UP;
503 else if (unformat (input, "down"))
504 *r = SSE2_QOS_ROUND_TO_DOWN;
511 unformat_policer_type (unformat_input_t * input, va_list * args)
513 u8 *r = va_arg (*args, u8 *);
515 if (unformat (input, "1r2c"))
516 *r = SSE2_QOS_POLICER_TYPE_1R2C;
517 else if (unformat (input, "1r3c"))
518 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
519 else if (unformat (input, "2r3c-2698"))
520 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
521 else if (unformat (input, "2r3c-4115"))
522 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
523 else if (unformat (input, "2r3c-mef5cf1"))
524 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
531 unformat_dscp (unformat_input_t * input, va_list * va)
533 u8 *r = va_arg (*va, u8 *);
536 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
545 unformat_policer_action_type (unformat_input_t * input, va_list * va)
547 sse2_qos_pol_action_params_st *a
548 = va_arg (*va, sse2_qos_pol_action_params_st *);
550 if (unformat (input, "drop"))
551 a->action_type = SSE2_QOS_ACTION_DROP;
552 else if (unformat (input, "transmit"))
553 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
554 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
555 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
562 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
564 u32 *r = va_arg (*va, u32 *);
567 if (unformat (input, "ip4"))
568 tid = POLICER_CLASSIFY_TABLE_IP4;
569 else if (unformat (input, "ip6"))
570 tid = POLICER_CLASSIFY_TABLE_IP6;
571 else if (unformat (input, "l2"))
572 tid = POLICER_CLASSIFY_TABLE_L2;
581 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
583 u32 *r = va_arg (*va, u32 *);
586 if (unformat (input, "ip4"))
587 tid = FLOW_CLASSIFY_TABLE_IP4;
588 else if (unformat (input, "ip6"))
589 tid = FLOW_CLASSIFY_TABLE_IP6;
597 #if (VPP_API_TEST_BUILTIN==0)
599 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
600 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
601 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
602 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
605 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
607 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
608 mfib_itf_attribute_t attr;
611 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
613 if (unformat (input, mfib_itf_flag_long_names[attr]))
614 *iflags |= (1 << attr);
616 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
618 if (unformat (input, mfib_itf_flag_names[attr]))
619 *iflags |= (1 << attr);
622 return (old == *iflags ? 0 : 1);
626 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
628 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
629 mfib_entry_attribute_t attr;
632 FOR_EACH_MFIB_ATTRIBUTE (attr)
634 if (unformat (input, mfib_flag_long_names[attr]))
635 *eflags |= (1 << attr);
637 FOR_EACH_MFIB_ATTRIBUTE (attr)
639 if (unformat (input, mfib_flag_names[attr]))
640 *eflags |= (1 << attr);
643 return (old == *eflags ? 0 : 1);
647 format_ip4_address (u8 * s, va_list * args)
649 u8 *a = va_arg (*args, u8 *);
650 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
654 format_ip6_address (u8 * s, va_list * args)
656 ip6_address_t *a = va_arg (*args, ip6_address_t *);
657 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
659 i_max_n_zero = ARRAY_LEN (a->as_u16);
661 i_first_zero = i_max_n_zero;
663 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
665 u32 is_zero = a->as_u16[i] == 0;
666 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
672 if ((!is_zero && n_zeros > max_n_zeros)
673 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
675 i_max_n_zero = i_first_zero;
676 max_n_zeros = n_zeros;
677 i_first_zero = ARRAY_LEN (a->as_u16);
682 last_double_colon = 0;
683 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
685 if (i == i_max_n_zero && max_n_zeros > 1)
687 s = format (s, "::");
688 i += max_n_zeros - 1;
689 last_double_colon = 1;
693 s = format (s, "%s%x",
694 (last_double_colon || i == 0) ? "" : ":",
695 clib_net_to_host_u16 (a->as_u16[i]));
696 last_double_colon = 0;
703 /* Format an IP46 address. */
705 format_ip46_address (u8 * s, va_list * args)
707 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
708 ip46_type_t type = va_arg (*args, ip46_type_t);
714 is_ip4 = ip46_address_is_ip4 (ip46);
725 format (s, "%U", format_ip4_address, &ip46->ip4) :
726 format (s, "%U", format_ip6_address, &ip46->ip6);
730 format_ethernet_address (u8 * s, va_list * args)
732 u8 *a = va_arg (*args, u8 *);
734 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
735 a[0], a[1], a[2], a[3], a[4], a[5]);
740 increment_v4_address (vl_api_ip4_address_t * i)
742 ip4_address_t *a = (ip4_address_t *) i;
745 v = ntohl (a->as_u32) + 1;
746 a->as_u32 = ntohl (v);
750 increment_v6_address (vl_api_ip6_address_t * i)
752 ip6_address_t *a = (ip6_address_t *) i;
755 v0 = clib_net_to_host_u64 (a->as_u64[0]);
756 v1 = clib_net_to_host_u64 (a->as_u64[1]);
761 a->as_u64[0] = clib_net_to_host_u64 (v0);
762 a->as_u64[1] = clib_net_to_host_u64 (v1);
766 increment_address (vl_api_address_t * a)
768 if (a->af == ADDRESS_IP4)
769 increment_v4_address (&a->un.ip4);
770 else if (a->af == ADDRESS_IP6)
771 increment_v6_address (&a->un.ip6);
775 set_ip4_address (vl_api_address_t * a, u32 v)
777 if (a->af == ADDRESS_IP4)
779 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
785 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
788 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
790 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
791 sizeof (ip6_address_t));
795 increment_mac_address (u8 * mac)
797 u64 tmp = *((u64 *) mac);
798 tmp = clib_net_to_host_u64 (tmp);
799 tmp += 1 << 16; /* skip unused (least significant) octets */
800 tmp = clib_host_to_net_u64 (tmp);
802 clib_memcpy (mac, &tmp, 6);
806 vat_json_object_add_address (vat_json_node_t * node,
807 const char *str, const vl_api_address_t * addr)
809 if (ADDRESS_IP6 == addr->af)
813 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
814 vat_json_object_add_ip6 (node, str, ip6);
820 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
821 vat_json_object_add_ip4 (node, str, ip4);
826 vat_json_object_add_prefix (vat_json_node_t * node,
827 const vl_api_prefix_t * prefix)
829 vat_json_object_add_uint (node, "len", prefix->len);
830 vat_json_object_add_address (node, "address", &prefix->address);
833 static void vl_api_create_loopback_reply_t_handler
834 (vl_api_create_loopback_reply_t * mp)
836 vat_main_t *vam = &vat_main;
837 i32 retval = ntohl (mp->retval);
839 vam->retval = retval;
840 vam->regenerate_interface_table = 1;
841 vam->sw_if_index = ntohl (mp->sw_if_index);
842 vam->result_ready = 1;
845 static void vl_api_create_loopback_reply_t_handler_json
846 (vl_api_create_loopback_reply_t * mp)
848 vat_main_t *vam = &vat_main;
849 vat_json_node_t node;
851 vat_json_init_object (&node);
852 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
853 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
855 vat_json_print (vam->ofp, &node);
856 vat_json_free (&node);
857 vam->retval = ntohl (mp->retval);
858 vam->result_ready = 1;
861 static void vl_api_create_loopback_instance_reply_t_handler
862 (vl_api_create_loopback_instance_reply_t * mp)
864 vat_main_t *vam = &vat_main;
865 i32 retval = ntohl (mp->retval);
867 vam->retval = retval;
868 vam->regenerate_interface_table = 1;
869 vam->sw_if_index = ntohl (mp->sw_if_index);
870 vam->result_ready = 1;
873 static void vl_api_create_loopback_instance_reply_t_handler_json
874 (vl_api_create_loopback_instance_reply_t * mp)
876 vat_main_t *vam = &vat_main;
877 vat_json_node_t node;
879 vat_json_init_object (&node);
880 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
881 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
883 vat_json_print (vam->ofp, &node);
884 vat_json_free (&node);
885 vam->retval = ntohl (mp->retval);
886 vam->result_ready = 1;
889 static void vl_api_af_packet_create_reply_t_handler
890 (vl_api_af_packet_create_reply_t * mp)
892 vat_main_t *vam = &vat_main;
893 i32 retval = ntohl (mp->retval);
895 vam->retval = retval;
896 vam->regenerate_interface_table = 1;
897 vam->sw_if_index = ntohl (mp->sw_if_index);
898 vam->result_ready = 1;
901 static void vl_api_af_packet_create_reply_t_handler_json
902 (vl_api_af_packet_create_reply_t * mp)
904 vat_main_t *vam = &vat_main;
905 vat_json_node_t node;
907 vat_json_init_object (&node);
908 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
909 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
911 vat_json_print (vam->ofp, &node);
912 vat_json_free (&node);
914 vam->retval = ntohl (mp->retval);
915 vam->result_ready = 1;
918 static void vl_api_create_vlan_subif_reply_t_handler
919 (vl_api_create_vlan_subif_reply_t * mp)
921 vat_main_t *vam = &vat_main;
922 i32 retval = ntohl (mp->retval);
924 vam->retval = retval;
925 vam->regenerate_interface_table = 1;
926 vam->sw_if_index = ntohl (mp->sw_if_index);
927 vam->result_ready = 1;
930 static void vl_api_create_vlan_subif_reply_t_handler_json
931 (vl_api_create_vlan_subif_reply_t * mp)
933 vat_main_t *vam = &vat_main;
934 vat_json_node_t node;
936 vat_json_init_object (&node);
937 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
938 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
940 vat_json_print (vam->ofp, &node);
941 vat_json_free (&node);
943 vam->retval = ntohl (mp->retval);
944 vam->result_ready = 1;
947 static void vl_api_create_subif_reply_t_handler
948 (vl_api_create_subif_reply_t * mp)
950 vat_main_t *vam = &vat_main;
951 i32 retval = ntohl (mp->retval);
953 vam->retval = retval;
954 vam->regenerate_interface_table = 1;
955 vam->sw_if_index = ntohl (mp->sw_if_index);
956 vam->result_ready = 1;
959 static void vl_api_create_subif_reply_t_handler_json
960 (vl_api_create_subif_reply_t * mp)
962 vat_main_t *vam = &vat_main;
963 vat_json_node_t node;
965 vat_json_init_object (&node);
966 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
967 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
969 vat_json_print (vam->ofp, &node);
970 vat_json_free (&node);
972 vam->retval = ntohl (mp->retval);
973 vam->result_ready = 1;
976 static void vl_api_interface_name_renumber_reply_t_handler
977 (vl_api_interface_name_renumber_reply_t * mp)
979 vat_main_t *vam = &vat_main;
980 i32 retval = ntohl (mp->retval);
982 vam->retval = retval;
983 vam->regenerate_interface_table = 1;
984 vam->result_ready = 1;
987 static void vl_api_interface_name_renumber_reply_t_handler_json
988 (vl_api_interface_name_renumber_reply_t * mp)
990 vat_main_t *vam = &vat_main;
991 vat_json_node_t node;
993 vat_json_init_object (&node);
994 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
996 vat_json_print (vam->ofp, &node);
997 vat_json_free (&node);
999 vam->retval = ntohl (mp->retval);
1000 vam->result_ready = 1;
1004 * Special-case: build the interface table, maintain
1005 * the next loopback sw_if_index vbl.
1007 static void vl_api_sw_interface_details_t_handler
1008 (vl_api_sw_interface_details_t * mp)
1010 vat_main_t *vam = &vat_main;
1011 u8 *s = format (0, "%s%c", mp->interface_name, 0);
1013 hash_set_mem (vam->sw_if_index_by_interface_name, s,
1014 ntohl (mp->sw_if_index));
1016 /* In sub interface case, fill the sub interface table entry */
1017 if (mp->sw_if_index != mp->sup_sw_if_index)
1019 sw_interface_subif_t *sub = NULL;
1021 vec_add2 (vam->sw_if_subif_table, sub, 1);
1023 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
1024 strncpy ((char *) sub->interface_name, (char *) s,
1025 vec_len (sub->interface_name));
1026 sub->sw_if_index = ntohl (mp->sw_if_index);
1027 sub->sub_id = ntohl (mp->sub_id);
1029 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
1031 sub->sub_number_of_tags = mp->sub_number_of_tags;
1032 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1033 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1035 /* vlan tag rewrite */
1036 sub->vtr_op = ntohl (mp->vtr_op);
1037 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1038 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1039 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1043 static void vl_api_sw_interface_details_t_handler_json
1044 (vl_api_sw_interface_details_t * mp)
1046 vat_main_t *vam = &vat_main;
1047 vat_json_node_t *node = NULL;
1049 if (VAT_JSON_ARRAY != vam->json_tree.type)
1051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1052 vat_json_init_array (&vam->json_tree);
1054 node = vat_json_array_add (&vam->json_tree);
1056 vat_json_init_object (node);
1057 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1058 vat_json_object_add_uint (node, "sup_sw_if_index",
1059 ntohl (mp->sup_sw_if_index));
1060 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1061 sizeof (mp->l2_address));
1062 vat_json_object_add_string_copy (node, "interface_name",
1063 mp->interface_name);
1064 vat_json_object_add_string_copy (node, "interface_dev_type",
1065 mp->interface_dev_type);
1066 vat_json_object_add_uint (node, "flags", mp->flags);
1067 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1068 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1069 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1070 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1071 vat_json_object_add_uint (node, "sub_number_of_tags",
1072 mp->sub_number_of_tags);
1073 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1074 ntohs (mp->sub_outer_vlan_id));
1075 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1076 ntohs (mp->sub_inner_vlan_id));
1077 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1078 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1079 vat_json_object_add_uint (node, "vtr_push_dot1q",
1080 ntohl (mp->vtr_push_dot1q));
1081 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1082 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1083 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1085 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1087 format_ethernet_address,
1089 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1091 format_ethernet_address,
1093 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1094 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1098 #if VPP_API_TEST_BUILTIN == 0
1099 static void vl_api_sw_interface_event_t_handler
1100 (vl_api_sw_interface_event_t * mp)
1102 vat_main_t *vam = &vat_main;
1103 if (vam->interface_event_display)
1104 errmsg ("interface flags: sw_if_index %d %s %s",
1105 ntohl (mp->sw_if_index),
1106 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1107 "admin-up" : "admin-down",
1108 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1109 "link-up" : "link-down");
1113 __clib_unused static void
1114 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1116 /* JSON output not supported */
1120 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1122 vat_main_t *vam = &vat_main;
1123 i32 retval = ntohl (mp->retval);
1125 vam->retval = retval;
1126 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1127 vam->result_ready = 1;
1131 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1133 vat_main_t *vam = &vat_main;
1134 vat_json_node_t node;
1138 vat_json_init_object (&node);
1139 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1140 vat_json_object_add_uint (&node, "reply_in_shmem",
1141 ntohl (mp->reply_in_shmem));
1142 /* Toss the shared-memory original... */
1143 oldheap = vl_msg_push_heap ();
1145 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1148 vl_msg_pop_heap (oldheap);
1150 vat_json_print (vam->ofp, &node);
1151 vat_json_free (&node);
1153 vam->retval = ntohl (mp->retval);
1154 vam->result_ready = 1;
1158 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1160 vat_main_t *vam = &vat_main;
1161 i32 retval = ntohl (mp->retval);
1163 vec_reset_length (vam->cmd_reply);
1165 vam->retval = retval;
1167 vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1168 vam->result_ready = 1;
1172 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1174 vat_main_t *vam = &vat_main;
1175 vat_json_node_t node;
1176 u8 *reply = 0; /* reply vector */
1178 reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
1179 vec_reset_length (vam->cmd_reply);
1181 vat_json_init_object (&node);
1182 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1183 vat_json_object_add_string_copy (&node, "reply", reply);
1185 vat_json_print (vam->ofp, &node);
1186 vat_json_free (&node);
1189 vam->retval = ntohl (mp->retval);
1190 vam->result_ready = 1;
1193 static void vl_api_classify_add_del_table_reply_t_handler
1194 (vl_api_classify_add_del_table_reply_t * mp)
1196 vat_main_t *vam = &vat_main;
1197 i32 retval = ntohl (mp->retval);
1198 if (vam->async_mode)
1200 vam->async_errors += (retval < 0);
1204 vam->retval = retval;
1206 ((mp->new_table_index != 0xFFFFFFFF) ||
1207 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1208 (mp->match_n_vectors != 0xFFFFFFFF)))
1210 * Note: this is just barely thread-safe, depends on
1211 * the main thread spinning waiting for an answer...
1213 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1214 ntohl (mp->new_table_index),
1215 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1216 vam->result_ready = 1;
1220 static void vl_api_classify_add_del_table_reply_t_handler_json
1221 (vl_api_classify_add_del_table_reply_t * mp)
1223 vat_main_t *vam = &vat_main;
1224 vat_json_node_t node;
1226 vat_json_init_object (&node);
1227 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1228 vat_json_object_add_uint (&node, "new_table_index",
1229 ntohl (mp->new_table_index));
1230 vat_json_object_add_uint (&node, "skip_n_vectors",
1231 ntohl (mp->skip_n_vectors));
1232 vat_json_object_add_uint (&node, "match_n_vectors",
1233 ntohl (mp->match_n_vectors));
1235 vat_json_print (vam->ofp, &node);
1236 vat_json_free (&node);
1238 vam->retval = ntohl (mp->retval);
1239 vam->result_ready = 1;
1242 static void vl_api_get_node_index_reply_t_handler
1243 (vl_api_get_node_index_reply_t * mp)
1245 vat_main_t *vam = &vat_main;
1246 i32 retval = ntohl (mp->retval);
1247 if (vam->async_mode)
1249 vam->async_errors += (retval < 0);
1253 vam->retval = retval;
1255 errmsg ("node index %d", ntohl (mp->node_index));
1256 vam->result_ready = 1;
1260 static void vl_api_get_node_index_reply_t_handler_json
1261 (vl_api_get_node_index_reply_t * mp)
1263 vat_main_t *vam = &vat_main;
1264 vat_json_node_t node;
1266 vat_json_init_object (&node);
1267 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1268 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1270 vat_json_print (vam->ofp, &node);
1271 vat_json_free (&node);
1273 vam->retval = ntohl (mp->retval);
1274 vam->result_ready = 1;
1277 static void vl_api_get_next_index_reply_t_handler
1278 (vl_api_get_next_index_reply_t * mp)
1280 vat_main_t *vam = &vat_main;
1281 i32 retval = ntohl (mp->retval);
1282 if (vam->async_mode)
1284 vam->async_errors += (retval < 0);
1288 vam->retval = retval;
1290 errmsg ("next node index %d", ntohl (mp->next_index));
1291 vam->result_ready = 1;
1295 static void vl_api_get_next_index_reply_t_handler_json
1296 (vl_api_get_next_index_reply_t * mp)
1298 vat_main_t *vam = &vat_main;
1299 vat_json_node_t node;
1301 vat_json_init_object (&node);
1302 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1303 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1305 vat_json_print (vam->ofp, &node);
1306 vat_json_free (&node);
1308 vam->retval = ntohl (mp->retval);
1309 vam->result_ready = 1;
1312 static void vl_api_add_node_next_reply_t_handler
1313 (vl_api_add_node_next_reply_t * mp)
1315 vat_main_t *vam = &vat_main;
1316 i32 retval = ntohl (mp->retval);
1317 if (vam->async_mode)
1319 vam->async_errors += (retval < 0);
1323 vam->retval = retval;
1325 errmsg ("next index %d", ntohl (mp->next_index));
1326 vam->result_ready = 1;
1330 static void vl_api_add_node_next_reply_t_handler_json
1331 (vl_api_add_node_next_reply_t * mp)
1333 vat_main_t *vam = &vat_main;
1334 vat_json_node_t node;
1336 vat_json_init_object (&node);
1337 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1338 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1340 vat_json_print (vam->ofp, &node);
1341 vat_json_free (&node);
1343 vam->retval = ntohl (mp->retval);
1344 vam->result_ready = 1;
1347 static void vl_api_show_version_reply_t_handler
1348 (vl_api_show_version_reply_t * mp)
1350 vat_main_t *vam = &vat_main;
1351 i32 retval = ntohl (mp->retval);
1355 errmsg (" program: %s", mp->program);
1356 errmsg (" version: %s", mp->version);
1357 errmsg (" build date: %s", mp->build_date);
1358 errmsg ("build directory: %s", mp->build_directory);
1360 vam->retval = retval;
1361 vam->result_ready = 1;
1364 static void vl_api_show_version_reply_t_handler_json
1365 (vl_api_show_version_reply_t * mp)
1367 vat_main_t *vam = &vat_main;
1368 vat_json_node_t node;
1370 vat_json_init_object (&node);
1371 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1372 vat_json_object_add_string_copy (&node, "program", mp->program);
1373 vat_json_object_add_string_copy (&node, "version", mp->version);
1374 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1375 vat_json_object_add_string_copy (&node, "build_directory",
1376 mp->build_directory);
1378 vat_json_print (vam->ofp, &node);
1379 vat_json_free (&node);
1381 vam->retval = ntohl (mp->retval);
1382 vam->result_ready = 1;
1385 static void vl_api_show_threads_reply_t_handler
1386 (vl_api_show_threads_reply_t * mp)
1388 vat_main_t *vam = &vat_main;
1389 i32 retval = ntohl (mp->retval);
1393 count = ntohl (mp->count);
1395 for (i = 0; i < count; i++)
1397 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1398 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1399 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1400 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1401 ntohl (mp->thread_data[i].cpu_socket));
1403 vam->retval = retval;
1404 vam->result_ready = 1;
1407 static void vl_api_show_threads_reply_t_handler_json
1408 (vl_api_show_threads_reply_t * mp)
1410 vat_main_t *vam = &vat_main;
1411 vat_json_node_t node;
1412 vl_api_thread_data_t *td;
1413 i32 retval = ntohl (mp->retval);
1417 count = ntohl (mp->count);
1419 vat_json_init_object (&node);
1420 vat_json_object_add_int (&node, "retval", retval);
1421 vat_json_object_add_uint (&node, "count", count);
1423 for (i = 0; i < count; i++)
1425 td = &mp->thread_data[i];
1426 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1427 vat_json_object_add_string_copy (&node, "name", td->name);
1428 vat_json_object_add_string_copy (&node, "type", td->type);
1429 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1430 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1431 vat_json_object_add_int (&node, "core", ntohl (td->id));
1432 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1435 vat_json_print (vam->ofp, &node);
1436 vat_json_free (&node);
1438 vam->retval = retval;
1439 vam->result_ready = 1;
1443 api_show_threads (vat_main_t * vam)
1445 vl_api_show_threads_t *mp;
1449 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1450 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1452 M (SHOW_THREADS, mp);
1460 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1462 u32 n_macs = ntohl (mp->n_macs);
1463 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1464 ntohl (mp->pid), mp->client_index, n_macs);
1466 for (i = 0; i < n_macs; i++)
1468 vl_api_mac_entry_t *mac = &mp->mac[i];
1469 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1470 i + 1, ntohl (mac->sw_if_index),
1471 format_ethernet_address, mac->mac_addr, mac->action);
1478 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1480 /* JSON output not supported */
1483 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1484 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1487 * Special-case: build the bridge domain table, maintain
1488 * the next bd id vbl.
1490 static void vl_api_bridge_domain_details_t_handler
1491 (vl_api_bridge_domain_details_t * mp)
1493 vat_main_t *vam = &vat_main;
1494 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1497 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1498 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1500 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1501 ntohl (mp->bd_id), mp->learn, mp->forward,
1502 mp->flood, ntohl (mp->bvi_sw_if_index),
1503 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1507 vl_api_bridge_domain_sw_if_t *sw_ifs;
1508 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1511 sw_ifs = mp->sw_if_details;
1512 for (i = 0; i < n_sw_ifs; i++)
1518 sw_if_index = ntohl (sw_ifs->sw_if_index);
1521 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1523 if ((u32) p->value[0] == sw_if_index)
1525 sw_if_name = (u8 *)(p->key);
1530 print (vam->ofp, "%7d %3d %s", sw_if_index,
1531 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1532 "sw_if_index not found!");
1539 static void vl_api_bridge_domain_details_t_handler_json
1540 (vl_api_bridge_domain_details_t * mp)
1542 vat_main_t *vam = &vat_main;
1543 vat_json_node_t *node, *array = NULL;
1544 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1546 if (VAT_JSON_ARRAY != vam->json_tree.type)
1548 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1549 vat_json_init_array (&vam->json_tree);
1551 node = vat_json_array_add (&vam->json_tree);
1553 vat_json_init_object (node);
1554 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1555 vat_json_object_add_uint (node, "flood", mp->flood);
1556 vat_json_object_add_uint (node, "forward", mp->forward);
1557 vat_json_object_add_uint (node, "learn", mp->learn);
1558 vat_json_object_add_uint (node, "bvi_sw_if_index",
1559 ntohl (mp->bvi_sw_if_index));
1560 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1561 array = vat_json_object_add (node, "sw_if");
1562 vat_json_init_array (array);
1568 vl_api_bridge_domain_sw_if_t *sw_ifs;
1571 sw_ifs = mp->sw_if_details;
1572 for (i = 0; i < n_sw_ifs; i++)
1574 node = vat_json_array_add (array);
1575 vat_json_init_object (node);
1576 vat_json_object_add_uint (node, "sw_if_index",
1577 ntohl (sw_ifs->sw_if_index));
1578 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1584 static void vl_api_control_ping_reply_t_handler
1585 (vl_api_control_ping_reply_t * mp)
1587 vat_main_t *vam = &vat_main;
1588 i32 retval = ntohl (mp->retval);
1589 if (vam->async_mode)
1591 vam->async_errors += (retval < 0);
1595 vam->retval = retval;
1596 vam->result_ready = 1;
1598 if (vam->socket_client_main)
1599 vam->socket_client_main->control_pings_outstanding--;
1602 static void vl_api_control_ping_reply_t_handler_json
1603 (vl_api_control_ping_reply_t * mp)
1605 vat_main_t *vam = &vat_main;
1606 i32 retval = ntohl (mp->retval);
1608 if (VAT_JSON_NONE != vam->json_tree.type)
1610 vat_json_print (vam->ofp, &vam->json_tree);
1611 vat_json_free (&vam->json_tree);
1612 vam->json_tree.type = VAT_JSON_NONE;
1617 vat_json_init_array (&vam->json_tree);
1618 vat_json_print (vam->ofp, &vam->json_tree);
1619 vam->json_tree.type = VAT_JSON_NONE;
1622 vam->retval = retval;
1623 vam->result_ready = 1;
1627 vl_api_bridge_domain_set_mac_age_reply_t_handler
1628 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1630 vat_main_t *vam = &vat_main;
1631 i32 retval = ntohl (mp->retval);
1632 if (vam->async_mode)
1634 vam->async_errors += (retval < 0);
1638 vam->retval = retval;
1639 vam->result_ready = 1;
1643 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1644 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1646 vat_main_t *vam = &vat_main;
1647 vat_json_node_t node;
1649 vat_json_init_object (&node);
1650 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1652 vat_json_print (vam->ofp, &node);
1653 vat_json_free (&node);
1655 vam->retval = ntohl (mp->retval);
1656 vam->result_ready = 1;
1660 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1662 vat_main_t *vam = &vat_main;
1663 i32 retval = ntohl (mp->retval);
1664 if (vam->async_mode)
1666 vam->async_errors += (retval < 0);
1670 vam->retval = retval;
1671 vam->result_ready = 1;
1675 static void vl_api_l2_flags_reply_t_handler_json
1676 (vl_api_l2_flags_reply_t * mp)
1678 vat_main_t *vam = &vat_main;
1679 vat_json_node_t node;
1681 vat_json_init_object (&node);
1682 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1683 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1684 ntohl (mp->resulting_feature_bitmap));
1686 vat_json_print (vam->ofp, &node);
1687 vat_json_free (&node);
1689 vam->retval = ntohl (mp->retval);
1690 vam->result_ready = 1;
1693 static void vl_api_bridge_flags_reply_t_handler
1694 (vl_api_bridge_flags_reply_t * mp)
1696 vat_main_t *vam = &vat_main;
1697 i32 retval = ntohl (mp->retval);
1698 if (vam->async_mode)
1700 vam->async_errors += (retval < 0);
1704 vam->retval = retval;
1705 vam->result_ready = 1;
1709 static void vl_api_bridge_flags_reply_t_handler_json
1710 (vl_api_bridge_flags_reply_t * mp)
1712 vat_main_t *vam = &vat_main;
1713 vat_json_node_t node;
1715 vat_json_init_object (&node);
1716 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1717 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1718 ntohl (mp->resulting_feature_bitmap));
1720 vat_json_print (vam->ofp, &node);
1721 vat_json_free (&node);
1723 vam->retval = ntohl (mp->retval);
1724 vam->result_ready = 1;
1728 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1730 vat_main_t *vam = &vat_main;
1731 i32 retval = ntohl (mp->retval);
1732 if (vam->async_mode)
1734 vam->async_errors += (retval < 0);
1738 vam->retval = retval;
1739 vam->sw_if_index = ntohl (mp->sw_if_index);
1740 vam->result_ready = 1;
1745 static void vl_api_tap_create_v2_reply_t_handler_json
1746 (vl_api_tap_create_v2_reply_t * mp)
1748 vat_main_t *vam = &vat_main;
1749 vat_json_node_t node;
1751 vat_json_init_object (&node);
1752 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1753 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1755 vat_json_print (vam->ofp, &node);
1756 vat_json_free (&node);
1758 vam->retval = ntohl (mp->retval);
1759 vam->result_ready = 1;
1764 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1766 vat_main_t *vam = &vat_main;
1767 i32 retval = ntohl (mp->retval);
1768 if (vam->async_mode)
1770 vam->async_errors += (retval < 0);
1774 vam->retval = retval;
1775 vam->result_ready = 1;
1779 static void vl_api_tap_delete_v2_reply_t_handler_json
1780 (vl_api_tap_delete_v2_reply_t * mp)
1782 vat_main_t *vam = &vat_main;
1783 vat_json_node_t node;
1785 vat_json_init_object (&node);
1786 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1788 vat_json_print (vam->ofp, &node);
1789 vat_json_free (&node);
1791 vam->retval = ntohl (mp->retval);
1792 vam->result_ready = 1;
1796 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1799 vat_main_t *vam = &vat_main;
1800 i32 retval = ntohl (mp->retval);
1801 if (vam->async_mode)
1803 vam->async_errors += (retval < 0);
1807 vam->retval = retval;
1808 vam->sw_if_index = ntohl (mp->sw_if_index);
1809 vam->result_ready = 1;
1813 static void vl_api_virtio_pci_create_reply_t_handler_json
1814 (vl_api_virtio_pci_create_reply_t * mp)
1816 vat_main_t *vam = &vat_main;
1817 vat_json_node_t node;
1819 vat_json_init_object (&node);
1820 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1821 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1823 vat_json_print (vam->ofp, &node);
1824 vat_json_free (&node);
1826 vam->retval = ntohl (mp->retval);
1827 vam->result_ready = 1;
1832 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1835 vat_main_t *vam = &vat_main;
1836 i32 retval = ntohl (mp->retval);
1837 if (vam->async_mode)
1839 vam->async_errors += (retval < 0);
1843 vam->retval = retval;
1844 vam->result_ready = 1;
1848 static void vl_api_virtio_pci_delete_reply_t_handler_json
1849 (vl_api_virtio_pci_delete_reply_t * mp)
1851 vat_main_t *vam = &vat_main;
1852 vat_json_node_t node;
1854 vat_json_init_object (&node);
1855 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1857 vat_json_print (vam->ofp, &node);
1858 vat_json_free (&node);
1860 vam->retval = ntohl (mp->retval);
1861 vam->result_ready = 1;
1865 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1867 vat_main_t *vam = &vat_main;
1868 i32 retval = ntohl (mp->retval);
1870 if (vam->async_mode)
1872 vam->async_errors += (retval < 0);
1876 vam->retval = retval;
1877 vam->sw_if_index = ntohl (mp->sw_if_index);
1878 vam->result_ready = 1;
1882 static void vl_api_bond_create_reply_t_handler_json
1883 (vl_api_bond_create_reply_t * mp)
1885 vat_main_t *vam = &vat_main;
1886 vat_json_node_t node;
1888 vat_json_init_object (&node);
1889 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1890 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1892 vat_json_print (vam->ofp, &node);
1893 vat_json_free (&node);
1895 vam->retval = ntohl (mp->retval);
1896 vam->result_ready = 1;
1900 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1902 vat_main_t *vam = &vat_main;
1903 i32 retval = ntohl (mp->retval);
1905 if (vam->async_mode)
1907 vam->async_errors += (retval < 0);
1911 vam->retval = retval;
1912 vam->result_ready = 1;
1916 static void vl_api_bond_delete_reply_t_handler_json
1917 (vl_api_bond_delete_reply_t * mp)
1919 vat_main_t *vam = &vat_main;
1920 vat_json_node_t node;
1922 vat_json_init_object (&node);
1923 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1925 vat_json_print (vam->ofp, &node);
1926 vat_json_free (&node);
1928 vam->retval = ntohl (mp->retval);
1929 vam->result_ready = 1;
1933 vl_api_bond_add_member_reply_t_handler (vl_api_bond_add_member_reply_t * mp)
1935 vat_main_t *vam = &vat_main;
1936 i32 retval = ntohl (mp->retval);
1938 if (vam->async_mode)
1940 vam->async_errors += (retval < 0);
1944 vam->retval = retval;
1945 vam->result_ready = 1;
1949 static void vl_api_bond_add_member_reply_t_handler_json
1950 (vl_api_bond_add_member_reply_t * mp)
1952 vat_main_t *vam = &vat_main;
1953 vat_json_node_t node;
1955 vat_json_init_object (&node);
1956 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1958 vat_json_print (vam->ofp, &node);
1959 vat_json_free (&node);
1961 vam->retval = ntohl (mp->retval);
1962 vam->result_ready = 1;
1966 vl_api_bond_detach_member_reply_t_handler (vl_api_bond_detach_member_reply_t *
1969 vat_main_t *vam = &vat_main;
1970 i32 retval = ntohl (mp->retval);
1972 if (vam->async_mode)
1974 vam->async_errors += (retval < 0);
1978 vam->retval = retval;
1979 vam->result_ready = 1;
1983 static void vl_api_bond_detach_member_reply_t_handler_json
1984 (vl_api_bond_detach_member_reply_t * mp)
1986 vat_main_t *vam = &vat_main;
1987 vat_json_node_t node;
1989 vat_json_init_object (&node);
1990 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1992 vat_json_print (vam->ofp, &node);
1993 vat_json_free (&node);
1995 vam->retval = ntohl (mp->retval);
1996 vam->result_ready = 1;
2000 api_sw_interface_set_bond_weight (vat_main_t * vam)
2002 unformat_input_t *i = vam->input;
2003 vl_api_sw_interface_set_bond_weight_t *mp;
2004 u32 sw_if_index = ~0;
2006 u8 weight_enter = 0;
2009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2013 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2015 else if (unformat (i, "weight %u", &weight))
2021 if (sw_if_index == ~0)
2023 errmsg ("missing interface name or sw_if_index");
2026 if (weight_enter == 0)
2028 errmsg ("missing valid weight");
2032 /* Construct the API message */
2033 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2034 mp->sw_if_index = ntohl (sw_if_index);
2035 mp->weight = ntohl (weight);
2042 static void vl_api_sw_bond_interface_details_t_handler
2043 (vl_api_sw_bond_interface_details_t * mp)
2045 vat_main_t *vam = &vat_main;
2048 "%-16s %-12d %-12U %-13U %-14u %-14u",
2049 mp->interface_name, ntohl (mp->sw_if_index),
2050 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2051 ntohl (mp->lb), ntohl (mp->active_members), ntohl (mp->members));
2054 static void vl_api_sw_bond_interface_details_t_handler_json
2055 (vl_api_sw_bond_interface_details_t * mp)
2057 vat_main_t *vam = &vat_main;
2058 vat_json_node_t *node = NULL;
2060 if (VAT_JSON_ARRAY != vam->json_tree.type)
2062 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2063 vat_json_init_array (&vam->json_tree);
2065 node = vat_json_array_add (&vam->json_tree);
2067 vat_json_init_object (node);
2068 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2069 vat_json_object_add_string_copy (node, "interface_name",
2070 mp->interface_name);
2071 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2072 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2073 vat_json_object_add_uint (node, "active_members",
2074 ntohl (mp->active_members));
2075 vat_json_object_add_uint (node, "members", ntohl (mp->members));
2079 api_sw_bond_interface_dump (vat_main_t * vam)
2081 unformat_input_t *i = vam->input;
2082 vl_api_sw_bond_interface_dump_t *mp;
2083 vl_api_control_ping_t *mp_ping;
2085 u32 sw_if_index = ~0;
2087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2089 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2091 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2098 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2099 "interface name", "sw_if_index", "mode", "load balance",
2100 "active members", "members");
2102 /* Get list of bond interfaces */
2103 M (SW_BOND_INTERFACE_DUMP, mp);
2104 mp->sw_if_index = ntohl (sw_if_index);
2107 /* Use a control ping for synchronization */
2108 MPING (CONTROL_PING, mp_ping);
2115 static void vl_api_sw_member_interface_details_t_handler
2116 (vl_api_sw_member_interface_details_t * mp)
2118 vat_main_t *vam = &vat_main;
2121 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2122 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2123 ntohl (mp->weight), mp->is_local_numa);
2126 static void vl_api_sw_member_interface_details_t_handler_json
2127 (vl_api_sw_member_interface_details_t * mp)
2129 vat_main_t *vam = &vat_main;
2130 vat_json_node_t *node = NULL;
2132 if (VAT_JSON_ARRAY != vam->json_tree.type)
2134 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2135 vat_json_init_array (&vam->json_tree);
2137 node = vat_json_array_add (&vam->json_tree);
2139 vat_json_init_object (node);
2140 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2141 vat_json_object_add_string_copy (node, "interface_name",
2142 mp->interface_name);
2143 vat_json_object_add_uint (node, "passive", mp->is_passive);
2144 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2145 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2146 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2150 api_sw_member_interface_dump (vat_main_t * vam)
2152 unformat_input_t *i = vam->input;
2153 vl_api_sw_member_interface_dump_t *mp;
2154 vl_api_control_ping_t *mp_ping;
2155 u32 sw_if_index = ~0;
2156 u8 sw_if_index_set = 0;
2159 /* Parse args required to build the message */
2160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2163 sw_if_index_set = 1;
2164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2165 sw_if_index_set = 1;
2170 if (sw_if_index_set == 0)
2172 errmsg ("missing vpp interface name. ");
2177 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2178 "member interface name", "sw_if_index", "passive", "long_timeout",
2179 "weight", "local numa");
2181 /* Get list of bond interfaces */
2182 M (SW_MEMBER_INTERFACE_DUMP, mp);
2183 mp->sw_if_index = ntohl (sw_if_index);
2186 /* Use a control ping for synchronization */
2187 MPING (CONTROL_PING, mp_ping);
2194 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2195 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2197 vat_main_t *vam = &vat_main;
2198 i32 retval = ntohl (mp->retval);
2199 if (vam->async_mode)
2201 vam->async_errors += (retval < 0);
2205 vam->retval = retval;
2206 vam->sw_if_index = ntohl (mp->sw_if_index);
2207 vam->result_ready = 1;
2209 vam->regenerate_interface_table = 1;
2212 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2213 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2215 vat_main_t *vam = &vat_main;
2216 vat_json_node_t node;
2218 vat_json_init_object (&node);
2219 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2220 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2221 ntohl (mp->sw_if_index));
2223 vat_json_print (vam->ofp, &node);
2224 vat_json_free (&node);
2226 vam->retval = ntohl (mp->retval);
2227 vam->result_ready = 1;
2230 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2231 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2233 vat_main_t *vam = &vat_main;
2234 i32 retval = ntohl (mp->retval);
2235 if (vam->async_mode)
2237 vam->async_errors += (retval < 0);
2241 vam->retval = retval;
2242 vam->sw_if_index = ntohl (mp->sw_if_index);
2243 vam->result_ready = 1;
2247 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2248 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2250 vat_main_t *vam = &vat_main;
2251 vat_json_node_t node;
2253 vat_json_init_object (&node);
2254 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2255 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2257 vat_json_print (vam->ofp, &node);
2258 vat_json_free (&node);
2260 vam->retval = ntohl (mp->retval);
2261 vam->result_ready = 1;
2264 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2265 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2267 vat_main_t *vam = &vat_main;
2268 i32 retval = ntohl (mp->retval);
2269 if (vam->async_mode)
2271 vam->async_errors += (retval < 0);
2275 vam->retval = retval;
2276 vam->result_ready = 1;
2280 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2281 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2283 vat_main_t *vam = &vat_main;
2284 vat_json_node_t node;
2286 vat_json_init_object (&node);
2287 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2288 vat_json_object_add_uint (&node, "fwd_entry_index",
2289 clib_net_to_host_u32 (mp->fwd_entry_index));
2291 vat_json_print (vam->ofp, &node);
2292 vat_json_free (&node);
2294 vam->retval = ntohl (mp->retval);
2295 vam->result_ready = 1;
2299 format_lisp_transport_protocol (u8 * s, va_list * args)
2301 u32 proto = va_arg (*args, u32);
2306 return format (s, "udp");
2308 return format (s, "api");
2315 static void vl_api_one_get_transport_protocol_reply_t_handler
2316 (vl_api_one_get_transport_protocol_reply_t * mp)
2318 vat_main_t *vam = &vat_main;
2319 i32 retval = ntohl (mp->retval);
2320 if (vam->async_mode)
2322 vam->async_errors += (retval < 0);
2326 u32 proto = mp->protocol;
2327 print (vam->ofp, "Transport protocol: %U",
2328 format_lisp_transport_protocol, proto);
2329 vam->retval = retval;
2330 vam->result_ready = 1;
2334 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2335 (vl_api_one_get_transport_protocol_reply_t * mp)
2337 vat_main_t *vam = &vat_main;
2338 vat_json_node_t node;
2341 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2344 vat_json_init_object (&node);
2345 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2346 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2349 vat_json_print (vam->ofp, &node);
2350 vat_json_free (&node);
2352 vam->retval = ntohl (mp->retval);
2353 vam->result_ready = 1;
2356 static void vl_api_one_add_del_locator_set_reply_t_handler
2357 (vl_api_one_add_del_locator_set_reply_t * mp)
2359 vat_main_t *vam = &vat_main;
2360 i32 retval = ntohl (mp->retval);
2361 if (vam->async_mode)
2363 vam->async_errors += (retval < 0);
2367 vam->retval = retval;
2368 vam->result_ready = 1;
2372 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2373 (vl_api_one_add_del_locator_set_reply_t * mp)
2375 vat_main_t *vam = &vat_main;
2376 vat_json_node_t node;
2378 vat_json_init_object (&node);
2379 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2380 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2382 vat_json_print (vam->ofp, &node);
2383 vat_json_free (&node);
2385 vam->retval = ntohl (mp->retval);
2386 vam->result_ready = 1;
2389 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2390 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2392 vat_main_t *vam = &vat_main;
2393 i32 retval = ntohl (mp->retval);
2394 if (vam->async_mode)
2396 vam->async_errors += (retval < 0);
2400 vam->retval = retval;
2401 vam->sw_if_index = ntohl (mp->sw_if_index);
2402 vam->result_ready = 1;
2404 vam->regenerate_interface_table = 1;
2407 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2408 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2410 vat_main_t *vam = &vat_main;
2411 vat_json_node_t node;
2413 vat_json_init_object (&node);
2414 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2415 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2417 vat_json_print (vam->ofp, &node);
2418 vat_json_free (&node);
2420 vam->retval = ntohl (mp->retval);
2421 vam->result_ready = 1;
2424 static void vl_api_vxlan_offload_rx_reply_t_handler
2425 (vl_api_vxlan_offload_rx_reply_t * mp)
2427 vat_main_t *vam = &vat_main;
2428 i32 retval = ntohl (mp->retval);
2429 if (vam->async_mode)
2431 vam->async_errors += (retval < 0);
2435 vam->retval = retval;
2436 vam->result_ready = 1;
2440 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2441 (vl_api_vxlan_offload_rx_reply_t * mp)
2443 vat_main_t *vam = &vat_main;
2444 vat_json_node_t node;
2446 vat_json_init_object (&node);
2447 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2449 vat_json_print (vam->ofp, &node);
2450 vat_json_free (&node);
2452 vam->retval = ntohl (mp->retval);
2453 vam->result_ready = 1;
2456 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2457 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2459 vat_main_t *vam = &vat_main;
2460 i32 retval = ntohl (mp->retval);
2461 if (vam->async_mode)
2463 vam->async_errors += (retval < 0);
2467 vam->retval = retval;
2468 vam->sw_if_index = ntohl (mp->sw_if_index);
2469 vam->result_ready = 1;
2473 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2474 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2476 vat_main_t *vam = &vat_main;
2477 vat_json_node_t node;
2479 vat_json_init_object (&node);
2480 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2481 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2483 vat_json_print (vam->ofp, &node);
2484 vat_json_free (&node);
2486 vam->retval = ntohl (mp->retval);
2487 vam->result_ready = 1;
2490 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2491 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2493 vat_main_t *vam = &vat_main;
2494 i32 retval = ntohl (mp->retval);
2495 if (vam->async_mode)
2497 vam->async_errors += (retval < 0);
2501 vam->retval = retval;
2502 vam->sw_if_index = ntohl (mp->sw_if_index);
2503 vam->result_ready = 1;
2505 vam->regenerate_interface_table = 1;
2508 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2509 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2511 vat_main_t *vam = &vat_main;
2512 vat_json_node_t node;
2514 vat_json_init_object (&node);
2515 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2516 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2518 vat_json_print (vam->ofp, &node);
2519 vat_json_free (&node);
2521 vam->retval = ntohl (mp->retval);
2522 vam->result_ready = 1;
2525 static void vl_api_gre_tunnel_add_del_reply_t_handler
2526 (vl_api_gre_tunnel_add_del_reply_t * mp)
2528 vat_main_t *vam = &vat_main;
2529 i32 retval = ntohl (mp->retval);
2530 if (vam->async_mode)
2532 vam->async_errors += (retval < 0);
2536 vam->retval = retval;
2537 vam->sw_if_index = ntohl (mp->sw_if_index);
2538 vam->result_ready = 1;
2542 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2543 (vl_api_gre_tunnel_add_del_reply_t * mp)
2545 vat_main_t *vam = &vat_main;
2546 vat_json_node_t node;
2548 vat_json_init_object (&node);
2549 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2550 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2552 vat_json_print (vam->ofp, &node);
2553 vat_json_free (&node);
2555 vam->retval = ntohl (mp->retval);
2556 vam->result_ready = 1;
2559 static void vl_api_create_vhost_user_if_reply_t_handler
2560 (vl_api_create_vhost_user_if_reply_t * mp)
2562 vat_main_t *vam = &vat_main;
2563 i32 retval = ntohl (mp->retval);
2564 if (vam->async_mode)
2566 vam->async_errors += (retval < 0);
2570 vam->retval = retval;
2571 vam->sw_if_index = ntohl (mp->sw_if_index);
2572 vam->result_ready = 1;
2574 vam->regenerate_interface_table = 1;
2577 static void vl_api_create_vhost_user_if_reply_t_handler_json
2578 (vl_api_create_vhost_user_if_reply_t * mp)
2580 vat_main_t *vam = &vat_main;
2581 vat_json_node_t node;
2583 vat_json_init_object (&node);
2584 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2585 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2587 vat_json_print (vam->ofp, &node);
2588 vat_json_free (&node);
2590 vam->retval = ntohl (mp->retval);
2591 vam->result_ready = 1;
2594 static void vl_api_ip_address_details_t_handler
2595 (vl_api_ip_address_details_t * mp)
2597 vat_main_t *vam = &vat_main;
2598 static ip_address_details_t empty_ip_address_details = { {0} };
2599 ip_address_details_t *address = NULL;
2600 ip_details_t *current_ip_details = NULL;
2601 ip_details_t *details = NULL;
2603 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2605 if (!details || vam->current_sw_if_index >= vec_len (details)
2606 || !details[vam->current_sw_if_index].present)
2608 errmsg ("ip address details arrived but not stored");
2609 errmsg ("ip_dump should be called first");
2613 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2615 #define addresses (current_ip_details->addr)
2617 vec_validate_init_empty (addresses, vec_len (addresses),
2618 empty_ip_address_details);
2620 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2622 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2623 address->prefix_length = mp->prefix.len;
2627 static void vl_api_ip_address_details_t_handler_json
2628 (vl_api_ip_address_details_t * mp)
2630 vat_main_t *vam = &vat_main;
2631 vat_json_node_t *node = NULL;
2633 if (VAT_JSON_ARRAY != vam->json_tree.type)
2635 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2636 vat_json_init_array (&vam->json_tree);
2638 node = vat_json_array_add (&vam->json_tree);
2640 vat_json_init_object (node);
2641 vat_json_object_add_prefix (node, &mp->prefix);
2645 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2647 vat_main_t *vam = &vat_main;
2648 static ip_details_t empty_ip_details = { 0 };
2649 ip_details_t *ip = NULL;
2650 u32 sw_if_index = ~0;
2652 sw_if_index = ntohl (mp->sw_if_index);
2654 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2655 sw_if_index, empty_ip_details);
2657 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2664 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2666 vat_main_t *vam = &vat_main;
2668 if (VAT_JSON_ARRAY != vam->json_tree.type)
2670 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2671 vat_json_init_array (&vam->json_tree);
2673 vat_json_array_add_uint (&vam->json_tree,
2674 clib_net_to_host_u32 (mp->sw_if_index));
2677 static void vl_api_get_first_msg_id_reply_t_handler
2678 (vl_api_get_first_msg_id_reply_t * mp)
2680 vat_main_t *vam = &vat_main;
2681 i32 retval = ntohl (mp->retval);
2683 if (vam->async_mode)
2685 vam->async_errors += (retval < 0);
2689 vam->retval = retval;
2690 vam->result_ready = 1;
2694 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2698 static void vl_api_get_first_msg_id_reply_t_handler_json
2699 (vl_api_get_first_msg_id_reply_t * mp)
2701 vat_main_t *vam = &vat_main;
2702 vat_json_node_t node;
2704 vat_json_init_object (&node);
2705 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2706 vat_json_object_add_uint (&node, "first_msg_id",
2707 (uint) ntohs (mp->first_msg_id));
2709 vat_json_print (vam->ofp, &node);
2710 vat_json_free (&node);
2712 vam->retval = ntohl (mp->retval);
2713 vam->result_ready = 1;
2716 static void vl_api_get_node_graph_reply_t_handler
2717 (vl_api_get_node_graph_reply_t * mp)
2719 vat_main_t *vam = &vat_main;
2720 i32 retval = ntohl (mp->retval);
2721 u8 *pvt_copy, *reply;
2726 if (vam->async_mode)
2728 vam->async_errors += (retval < 0);
2732 vam->retval = retval;
2733 vam->result_ready = 1;
2736 /* "Should never happen..." */
2740 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2741 pvt_copy = vec_dup (reply);
2743 /* Toss the shared-memory original... */
2744 oldheap = vl_msg_push_heap ();
2748 vl_msg_pop_heap (oldheap);
2750 if (vam->graph_nodes)
2752 hash_free (vam->graph_node_index_by_name);
2754 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2756 node = vam->graph_nodes[0][i];
2757 vec_free (node->name);
2758 vec_free (node->next_nodes);
2761 vec_free (vam->graph_nodes[0]);
2762 vec_free (vam->graph_nodes);
2765 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2766 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2767 vec_free (pvt_copy);
2769 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2771 node = vam->graph_nodes[0][i];
2772 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2776 static void vl_api_get_node_graph_reply_t_handler_json
2777 (vl_api_get_node_graph_reply_t * mp)
2779 vat_main_t *vam = &vat_main;
2781 vat_json_node_t node;
2784 /* $$$$ make this real? */
2785 vat_json_init_object (&node);
2786 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2787 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2789 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2791 /* Toss the shared-memory original... */
2792 oldheap = vl_msg_push_heap ();
2796 vl_msg_pop_heap (oldheap);
2798 vat_json_print (vam->ofp, &node);
2799 vat_json_free (&node);
2801 vam->retval = ntohl (mp->retval);
2802 vam->result_ready = 1;
2806 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2808 vat_main_t *vam = &vat_main;
2813 s = format (s, "%=16d%=16d%=16d",
2814 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2818 s = format (s, "%=16U%=16d%=16d",
2819 format_ip46_address,
2820 mp->ip_address, mp->priority, mp->weight);
2823 print (vam->ofp, "%v", s);
2828 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2830 vat_main_t *vam = &vat_main;
2831 vat_json_node_t *node = NULL;
2832 struct in6_addr ip6;
2835 if (VAT_JSON_ARRAY != vam->json_tree.type)
2837 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2838 vat_json_init_array (&vam->json_tree);
2840 node = vat_json_array_add (&vam->json_tree);
2841 vat_json_init_object (node);
2843 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2844 vat_json_object_add_uint (node, "priority", mp->priority);
2845 vat_json_object_add_uint (node, "weight", mp->weight);
2848 vat_json_object_add_uint (node, "sw_if_index",
2849 clib_net_to_host_u32 (mp->sw_if_index));
2852 if (mp->ip_address.af)
2854 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
2855 vat_json_object_add_ip6 (node, "address", ip6);
2859 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
2860 vat_json_object_add_ip4 (node, "address", ip4);
2866 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2869 vat_main_t *vam = &vat_main;
2872 ls_name = format (0, "%s", mp->ls_name);
2874 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2880 vl_api_one_locator_set_details_t_handler_json
2881 (vl_api_one_locator_set_details_t * mp)
2883 vat_main_t *vam = &vat_main;
2884 vat_json_node_t *node = 0;
2887 ls_name = format (0, "%s", mp->ls_name);
2888 vec_add1 (ls_name, 0);
2890 if (VAT_JSON_ARRAY != vam->json_tree.type)
2892 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2893 vat_json_init_array (&vam->json_tree);
2895 node = vat_json_array_add (&vam->json_tree);
2897 vat_json_init_object (node);
2898 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2899 vat_json_object_add_uint (node, "ls_index",
2900 clib_net_to_host_u32 (mp->ls_index));
2908 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2911 unformat_nsh_address (unformat_input_t * input, va_list * args)
2913 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2914 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2918 format_nsh_address_vat (u8 * s, va_list * args)
2920 nsh_t *a = va_arg (*args, nsh_t *);
2921 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2925 format_lisp_flat_eid (u8 * s, va_list * args)
2927 vl_api_eid_t *eid = va_arg (*args, vl_api_eid_t *);
2931 case EID_TYPE_API_PREFIX:
2932 if (eid->address.prefix.address.af)
2933 return format (s, "%U/%d", format_ip6_address,
2934 eid->address.prefix.address.un.ip6,
2935 eid->address.prefix.len);
2936 return format (s, "%U/%d", format_ip4_address,
2937 eid->address.prefix.address.un.ip4,
2938 eid->address.prefix.len);
2939 case EID_TYPE_API_MAC:
2940 return format (s, "%U", format_ethernet_address, eid->address.mac);
2941 case EID_TYPE_API_NSH:
2942 return format (s, "%U", format_nsh_address_vat, eid->address.nsh);
2948 format_lisp_eid_vat (u8 * s, va_list * args)
2950 vl_api_eid_t *deid = va_arg (*args, vl_api_eid_t *);
2951 vl_api_eid_t *seid = va_arg (*args, vl_api_eid_t *);
2952 u8 is_src_dst = (u8) va_arg (*args, int);
2955 s = format (s, "%U|", format_lisp_flat_eid, seid);
2957 s = format (s, "%U", format_lisp_flat_eid, deid);
2963 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2965 vat_main_t *vam = &vat_main;
2966 u8 *s = 0, *eid = 0;
2968 if (~0 == mp->locator_set_index)
2969 s = format (0, "action: %d", mp->action);
2971 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2973 eid = format (0, "%U", format_lisp_eid_vat,
2974 &mp->deid, &mp->seid, mp->is_src_dst);
2977 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2978 clib_net_to_host_u32 (mp->vni),
2980 mp->is_local ? "local" : "remote",
2981 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2982 clib_net_to_host_u16 (mp->key.id), mp->key.key);
2989 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2992 vat_main_t *vam = &vat_main;
2993 vat_json_node_t *node = 0;
2996 if (VAT_JSON_ARRAY != vam->json_tree.type)
2998 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2999 vat_json_init_array (&vam->json_tree);
3001 node = vat_json_array_add (&vam->json_tree);
3003 vat_json_init_object (node);
3004 if (~0 == mp->locator_set_index)
3005 vat_json_object_add_uint (node, "action", mp->action);
3007 vat_json_object_add_uint (node, "locator_set_index",
3008 clib_net_to_host_u32 (mp->locator_set_index));
3010 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3011 if (mp->deid.type == 3)
3013 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3014 vat_json_init_object (nsh_json);
3015 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) & mp->deid.address.nsh;
3016 vat_json_object_add_uint (nsh_json, "spi",
3017 clib_net_to_host_u32 (nsh->spi));
3018 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3022 eid = format (0, "%U", format_lisp_eid_vat,
3023 &mp->deid, &mp->seid, mp->is_src_dst);
3025 vat_json_object_add_string_copy (node, "eid", eid);
3028 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3029 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3030 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3034 vat_json_object_add_uint (node, "key_id",
3035 clib_net_to_host_u16 (mp->key.id));
3036 vat_json_object_add_string_copy (node, "key", mp->key.key);
3041 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3043 vat_main_t *vam = &vat_main;
3044 u8 *seid = 0, *deid = 0;
3045 ip46_address_t lloc, rloc;
3047 deid = format (0, "%U", format_lisp_eid_vat, &mp->deid, 0, 0);
3049 seid = format (0, "%U", format_lisp_eid_vat, &mp->seid, 0, 0);
3056 clib_memcpy (&lloc.ip6, mp->lloc.un.ip6, 16);
3057 clib_memcpy (&rloc.ip6, mp->rloc.un.ip6, 16);
3061 clib_memcpy (&lloc.ip4, mp->lloc.un.ip4, 4);
3062 clib_memcpy (&rloc.ip4, mp->rloc.un.ip4, 4);
3066 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3067 clib_net_to_host_u32 (mp->vni),
3069 format_ip46_address, lloc,
3070 format_ip46_address, rloc,
3071 clib_net_to_host_u32 (mp->pkt_count),
3072 clib_net_to_host_u32 (mp->bytes));
3079 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3081 struct in6_addr ip6;
3083 vat_main_t *vam = &vat_main;
3084 vat_json_node_t *node = 0;
3085 u8 *deid = 0, *seid = 0;
3087 if (VAT_JSON_ARRAY != vam->json_tree.type)
3089 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3090 vat_json_init_array (&vam->json_tree);
3092 node = vat_json_array_add (&vam->json_tree);
3094 vat_json_init_object (node);
3095 deid = format (0, "%U", format_lisp_eid_vat, &mp->deid, 0, 0);
3097 seid = format (0, "%U", format_lisp_eid_vat, &mp->seid, 0, 0);
3102 vat_json_object_add_string_copy (node, "seid", seid);
3103 vat_json_object_add_string_copy (node, "deid", deid);
3104 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3108 clib_memcpy (&ip6, mp->lloc.un.ip6, sizeof (ip6));
3109 vat_json_object_add_ip6 (node, "lloc", ip6);
3110 clib_memcpy (&ip6, mp->rloc.un.ip6, sizeof (ip6));
3111 vat_json_object_add_ip6 (node, "rloc", ip6);
3116 clib_memcpy (&ip4, mp->lloc.un.ip4, sizeof (ip4));
3117 vat_json_object_add_ip4 (node, "lloc", ip4);
3118 clib_memcpy (&ip4, mp->rloc.un.ip4, sizeof (ip4));
3119 vat_json_object_add_ip4 (node, "rloc", ip4);
3121 vat_json_object_add_uint (node, "pkt_count",
3122 clib_net_to_host_u32 (mp->pkt_count));
3123 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3130 vl_api_one_eid_table_map_details_t_handler
3131 (vl_api_one_eid_table_map_details_t * mp)
3133 vat_main_t *vam = &vat_main;
3135 u8 *line = format (0, "%=10d%=10d",
3136 clib_net_to_host_u32 (mp->vni),
3137 clib_net_to_host_u32 (mp->dp_table));
3138 print (vam->ofp, "%v", line);
3143 vl_api_one_eid_table_map_details_t_handler_json
3144 (vl_api_one_eid_table_map_details_t * mp)
3146 vat_main_t *vam = &vat_main;
3147 vat_json_node_t *node = NULL;
3149 if (VAT_JSON_ARRAY != vam->json_tree.type)
3151 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3152 vat_json_init_array (&vam->json_tree);
3154 node = vat_json_array_add (&vam->json_tree);
3155 vat_json_init_object (node);
3156 vat_json_object_add_uint (node, "dp_table",
3157 clib_net_to_host_u32 (mp->dp_table));
3158 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3162 vl_api_one_eid_table_vni_details_t_handler
3163 (vl_api_one_eid_table_vni_details_t * mp)
3165 vat_main_t *vam = &vat_main;
3167 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3168 print (vam->ofp, "%v", line);
3173 vl_api_one_eid_table_vni_details_t_handler_json
3174 (vl_api_one_eid_table_vni_details_t * mp)
3176 vat_main_t *vam = &vat_main;
3177 vat_json_node_t *node = NULL;
3179 if (VAT_JSON_ARRAY != vam->json_tree.type)
3181 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3182 vat_json_init_array (&vam->json_tree);
3184 node = vat_json_array_add (&vam->json_tree);
3185 vat_json_init_object (node);
3186 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3190 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3191 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3193 vat_main_t *vam = &vat_main;
3194 int retval = clib_net_to_host_u32 (mp->retval);
3196 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3197 print (vam->ofp, "fallback threshold value: %d", mp->value);
3199 vam->retval = retval;
3200 vam->result_ready = 1;
3204 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3205 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3207 vat_main_t *vam = &vat_main;
3208 vat_json_node_t _node, *node = &_node;
3209 int retval = clib_net_to_host_u32 (mp->retval);
3211 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3212 vat_json_init_object (node);
3213 vat_json_object_add_uint (node, "value", mp->value);
3215 vat_json_print (vam->ofp, node);
3216 vat_json_free (node);
3218 vam->retval = retval;
3219 vam->result_ready = 1;
3223 vl_api_show_one_map_register_state_reply_t_handler
3224 (vl_api_show_one_map_register_state_reply_t * mp)
3226 vat_main_t *vam = &vat_main;
3227 int retval = clib_net_to_host_u32 (mp->retval);
3229 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3231 vam->retval = retval;
3232 vam->result_ready = 1;
3236 vl_api_show_one_map_register_state_reply_t_handler_json
3237 (vl_api_show_one_map_register_state_reply_t * mp)
3239 vat_main_t *vam = &vat_main;
3240 vat_json_node_t _node, *node = &_node;
3241 int retval = clib_net_to_host_u32 (mp->retval);
3243 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3245 vat_json_init_object (node);
3246 vat_json_object_add_string_copy (node, "state", s);
3248 vat_json_print (vam->ofp, node);
3249 vat_json_free (node);
3251 vam->retval = retval;
3252 vam->result_ready = 1;
3257 vl_api_show_one_rloc_probe_state_reply_t_handler
3258 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3260 vat_main_t *vam = &vat_main;
3261 int retval = clib_net_to_host_u32 (mp->retval);
3266 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3268 vam->retval = retval;
3269 vam->result_ready = 1;
3273 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3274 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3276 vat_main_t *vam = &vat_main;
3277 vat_json_node_t _node, *node = &_node;
3278 int retval = clib_net_to_host_u32 (mp->retval);
3280 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3281 vat_json_init_object (node);
3282 vat_json_object_add_string_copy (node, "state", s);
3284 vat_json_print (vam->ofp, node);
3285 vat_json_free (node);
3287 vam->retval = retval;
3288 vam->result_ready = 1;
3293 vl_api_show_one_stats_enable_disable_reply_t_handler
3294 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3296 vat_main_t *vam = &vat_main;
3297 int retval = clib_net_to_host_u32 (mp->retval);
3302 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3304 vam->retval = retval;
3305 vam->result_ready = 1;
3309 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3310 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3312 vat_main_t *vam = &vat_main;
3313 vat_json_node_t _node, *node = &_node;
3314 int retval = clib_net_to_host_u32 (mp->retval);
3316 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3317 vat_json_init_object (node);
3318 vat_json_object_add_string_copy (node, "state", s);
3320 vat_json_print (vam->ofp, node);
3321 vat_json_free (node);
3323 vam->retval = retval;
3324 vam->result_ready = 1;
3329 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3331 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3332 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3333 e->vni = clib_net_to_host_u32 (e->vni);
3337 gpe_fwd_entries_get_reply_t_net_to_host
3338 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3342 mp->count = clib_net_to_host_u32 (mp->count);
3343 for (i = 0; i < mp->count; i++)
3345 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3350 format_gpe_encap_mode (u8 * s, va_list * args)
3352 u32 mode = va_arg (*args, u32);
3357 return format (s, "lisp");
3359 return format (s, "vxlan");
3365 vl_api_gpe_get_encap_mode_reply_t_handler
3366 (vl_api_gpe_get_encap_mode_reply_t * mp)
3368 vat_main_t *vam = &vat_main;
3370 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3371 vam->retval = ntohl (mp->retval);
3372 vam->result_ready = 1;
3376 vl_api_gpe_get_encap_mode_reply_t_handler_json
3377 (vl_api_gpe_get_encap_mode_reply_t * mp)
3379 vat_main_t *vam = &vat_main;
3380 vat_json_node_t node;
3382 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3383 vec_add1 (encap_mode, 0);
3385 vat_json_init_object (&node);
3386 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3388 vec_free (encap_mode);
3389 vat_json_print (vam->ofp, &node);
3390 vat_json_free (&node);
3392 vam->retval = ntohl (mp->retval);
3393 vam->result_ready = 1;
3397 vl_api_gpe_fwd_entry_path_details_t_handler
3398 (vl_api_gpe_fwd_entry_path_details_t * mp)
3400 vat_main_t *vam = &vat_main;
3401 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3403 if (mp->lcl_loc.addr.af)
3404 format_ip_address_fcn = format_ip6_address;
3406 format_ip_address_fcn = format_ip4_address;
3408 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3409 format_ip_address_fcn, &mp->lcl_loc.addr.un,
3410 format_ip_address_fcn, &mp->rmt_loc.addr.un);
3414 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3416 struct in6_addr ip6;
3421 clib_memcpy (&ip6, loc->addr.un.ip6, sizeof (ip6));
3422 vat_json_object_add_ip6 (n, "address", ip6);
3426 clib_memcpy (&ip4, loc->addr.un.ip4, sizeof (ip4));
3427 vat_json_object_add_ip4 (n, "address", ip4);
3429 vat_json_object_add_uint (n, "weight", loc->weight);
3433 vl_api_gpe_fwd_entry_path_details_t_handler_json
3434 (vl_api_gpe_fwd_entry_path_details_t * mp)
3436 vat_main_t *vam = &vat_main;
3437 vat_json_node_t *node = NULL;
3438 vat_json_node_t *loc_node;
3440 if (VAT_JSON_ARRAY != vam->json_tree.type)
3442 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3443 vat_json_init_array (&vam->json_tree);
3445 node = vat_json_array_add (&vam->json_tree);
3446 vat_json_init_object (node);
3448 loc_node = vat_json_object_add (node, "local_locator");
3449 vat_json_init_object (loc_node);
3450 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3452 loc_node = vat_json_object_add (node, "remote_locator");
3453 vat_json_init_object (loc_node);
3454 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3458 vl_api_gpe_fwd_entries_get_reply_t_handler
3459 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3461 vat_main_t *vam = &vat_main;
3463 int retval = clib_net_to_host_u32 (mp->retval);
3464 vl_api_gpe_fwd_entry_t *e;
3469 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3471 for (i = 0; i < mp->count; i++)
3473 e = &mp->entries[i];
3474 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3475 format_lisp_flat_eid, e->leid, format_lisp_flat_eid, e->reid);
3479 vam->retval = retval;
3480 vam->result_ready = 1;
3484 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3485 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3488 vat_main_t *vam = &vat_main;
3489 vat_json_node_t *e = 0, root;
3491 int retval = clib_net_to_host_u32 (mp->retval);
3492 vl_api_gpe_fwd_entry_t *fwd;
3497 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3498 vat_json_init_array (&root);
3500 for (i = 0; i < mp->count; i++)
3502 e = vat_json_array_add (&root);
3503 fwd = &mp->entries[i];
3505 vat_json_init_object (e);
3506 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3507 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3508 vat_json_object_add_int (e, "vni", fwd->vni);
3509 vat_json_object_add_int (e, "action", fwd->action);
3511 s = format (0, "%U", format_lisp_flat_eid, fwd->leid);
3513 vat_json_object_add_string_copy (e, "leid", s);
3516 s = format (0, "%U", format_lisp_flat_eid, fwd->reid);
3518 vat_json_object_add_string_copy (e, "reid", s);
3522 vat_json_print (vam->ofp, &root);
3523 vat_json_free (&root);
3526 vam->retval = retval;
3527 vam->result_ready = 1;
3531 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3532 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3534 vat_main_t *vam = &vat_main;
3536 int retval = clib_net_to_host_u32 (mp->retval);
3537 vl_api_gpe_native_fwd_rpath_t *r;
3542 n = clib_net_to_host_u32 (mp->count);
3544 for (i = 0; i < n; i++)
3546 r = &mp->entries[i];
3547 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3548 clib_net_to_host_u32 (r->fib_index),
3549 clib_net_to_host_u32 (r->nh_sw_if_index),
3550 r->nh_addr.af ? format_ip6_address : format_ip4_address,
3555 vam->retval = retval;
3556 vam->result_ready = 1;
3560 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3561 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3563 vat_main_t *vam = &vat_main;
3564 vat_json_node_t root, *e;
3566 int retval = clib_net_to_host_u32 (mp->retval);
3567 vl_api_gpe_native_fwd_rpath_t *r;
3573 n = clib_net_to_host_u32 (mp->count);
3574 vat_json_init_array (&root);
3576 for (i = 0; i < n; i++)
3578 e = vat_json_array_add (&root);
3579 vat_json_init_object (e);
3580 r = &mp->entries[i];
3583 r->nh_addr.af ? format_ip6_address : format_ip4_address,
3586 vat_json_object_add_string_copy (e, "ip4", s);
3589 vat_json_object_add_uint (e, "fib_index",
3590 clib_net_to_host_u32 (r->fib_index));
3591 vat_json_object_add_uint (e, "nh_sw_if_index",
3592 clib_net_to_host_u32 (r->nh_sw_if_index));
3595 vat_json_print (vam->ofp, &root);
3596 vat_json_free (&root);
3599 vam->retval = retval;
3600 vam->result_ready = 1;
3604 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3605 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3607 vat_main_t *vam = &vat_main;
3609 int retval = clib_net_to_host_u32 (mp->retval);
3614 n = clib_net_to_host_u32 (mp->count);
3616 for (i = 0; i < n; i++)
3617 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3620 vam->retval = retval;
3621 vam->result_ready = 1;
3625 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3626 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3628 vat_main_t *vam = &vat_main;
3629 vat_json_node_t root;
3631 int retval = clib_net_to_host_u32 (mp->retval);
3636 n = clib_net_to_host_u32 (mp->count);
3637 vat_json_init_array (&root);
3639 for (i = 0; i < n; i++)
3640 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3642 vat_json_print (vam->ofp, &root);
3643 vat_json_free (&root);
3646 vam->retval = retval;
3647 vam->result_ready = 1;
3651 vl_api_one_ndp_entries_get_reply_t_handler
3652 (vl_api_one_ndp_entries_get_reply_t * mp)
3654 vat_main_t *vam = &vat_main;
3656 int retval = clib_net_to_host_u32 (mp->retval);
3661 n = clib_net_to_host_u32 (mp->count);
3663 for (i = 0; i < n; i++)
3664 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3665 format_ethernet_address, mp->entries[i].mac);
3668 vam->retval = retval;
3669 vam->result_ready = 1;
3673 vl_api_one_ndp_entries_get_reply_t_handler_json
3674 (vl_api_one_ndp_entries_get_reply_t * mp)
3677 vat_main_t *vam = &vat_main;
3678 vat_json_node_t *e = 0, root;
3680 int retval = clib_net_to_host_u32 (mp->retval);
3681 vl_api_one_ndp_entry_t *arp_entry;
3686 n = clib_net_to_host_u32 (mp->count);
3687 vat_json_init_array (&root);
3689 for (i = 0; i < n; i++)
3691 e = vat_json_array_add (&root);
3692 arp_entry = &mp->entries[i];
3694 vat_json_init_object (e);
3695 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3698 vat_json_object_add_string_copy (e, "mac", s);
3701 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3703 vat_json_object_add_string_copy (e, "ip6", s);
3707 vat_json_print (vam->ofp, &root);
3708 vat_json_free (&root);
3711 vam->retval = retval;
3712 vam->result_ready = 1;
3716 vl_api_one_l2_arp_entries_get_reply_t_handler
3717 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3719 vat_main_t *vam = &vat_main;
3721 int retval = clib_net_to_host_u32 (mp->retval);
3726 n = clib_net_to_host_u32 (mp->count);
3728 for (i = 0; i < n; i++)
3729 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3730 format_ethernet_address, mp->entries[i].mac);
3733 vam->retval = retval;
3734 vam->result_ready = 1;
3738 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3739 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3742 vat_main_t *vam = &vat_main;
3743 vat_json_node_t *e = 0, root;
3745 int retval = clib_net_to_host_u32 (mp->retval);
3746 vl_api_one_l2_arp_entry_t *arp_entry;
3751 n = clib_net_to_host_u32 (mp->count);
3752 vat_json_init_array (&root);
3754 for (i = 0; i < n; i++)
3756 e = vat_json_array_add (&root);
3757 arp_entry = &mp->entries[i];
3759 vat_json_init_object (e);
3760 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3763 vat_json_object_add_string_copy (e, "mac", s);
3766 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3768 vat_json_object_add_string_copy (e, "ip4", s);
3772 vat_json_print (vam->ofp, &root);
3773 vat_json_free (&root);
3776 vam->retval = retval;
3777 vam->result_ready = 1;
3781 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3783 vat_main_t *vam = &vat_main;
3785 int retval = clib_net_to_host_u32 (mp->retval);
3790 n = clib_net_to_host_u32 (mp->count);
3792 for (i = 0; i < n; i++)
3794 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3798 vam->retval = retval;
3799 vam->result_ready = 1;
3803 vl_api_one_ndp_bd_get_reply_t_handler_json
3804 (vl_api_one_ndp_bd_get_reply_t * mp)
3806 vat_main_t *vam = &vat_main;
3807 vat_json_node_t root;
3809 int retval = clib_net_to_host_u32 (mp->retval);
3814 n = clib_net_to_host_u32 (mp->count);
3815 vat_json_init_array (&root);
3817 for (i = 0; i < n; i++)
3819 vat_json_array_add_uint (&root,
3820 clib_net_to_host_u32 (mp->bridge_domains[i]));
3823 vat_json_print (vam->ofp, &root);
3824 vat_json_free (&root);
3827 vam->retval = retval;
3828 vam->result_ready = 1;
3832 vl_api_one_l2_arp_bd_get_reply_t_handler
3833 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3835 vat_main_t *vam = &vat_main;
3837 int retval = clib_net_to_host_u32 (mp->retval);
3842 n = clib_net_to_host_u32 (mp->count);
3844 for (i = 0; i < n; i++)
3846 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3850 vam->retval = retval;
3851 vam->result_ready = 1;
3855 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3856 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3858 vat_main_t *vam = &vat_main;
3859 vat_json_node_t root;
3861 int retval = clib_net_to_host_u32 (mp->retval);
3866 n = clib_net_to_host_u32 (mp->count);
3867 vat_json_init_array (&root);
3869 for (i = 0; i < n; i++)
3871 vat_json_array_add_uint (&root,
3872 clib_net_to_host_u32 (mp->bridge_domains[i]));
3875 vat_json_print (vam->ofp, &root);
3876 vat_json_free (&root);
3879 vam->retval = retval;
3880 vam->result_ready = 1;
3884 vl_api_one_adjacencies_get_reply_t_handler
3885 (vl_api_one_adjacencies_get_reply_t * mp)
3887 vat_main_t *vam = &vat_main;
3889 int retval = clib_net_to_host_u32 (mp->retval);
3890 vl_api_one_adjacency_t *a;
3895 n = clib_net_to_host_u32 (mp->count);
3897 for (i = 0; i < n; i++)
3899 a = &mp->adjacencies[i];
3900 print (vam->ofp, "%U %40U",
3901 format_lisp_flat_eid, a->leid, format_lisp_flat_eid, a->reid);
3905 vam->retval = retval;
3906 vam->result_ready = 1;
3910 vl_api_one_adjacencies_get_reply_t_handler_json
3911 (vl_api_one_adjacencies_get_reply_t * mp)
3914 vat_main_t *vam = &vat_main;
3915 vat_json_node_t *e = 0, root;
3917 int retval = clib_net_to_host_u32 (mp->retval);
3918 vl_api_one_adjacency_t *a;
3923 n = clib_net_to_host_u32 (mp->count);
3924 vat_json_init_array (&root);
3926 for (i = 0; i < n; i++)
3928 e = vat_json_array_add (&root);
3929 a = &mp->adjacencies[i];
3931 vat_json_init_object (e);
3932 s = format (0, "%U", format_lisp_flat_eid, a->leid);
3934 vat_json_object_add_string_copy (e, "leid", s);
3937 s = format (0, "%U", format_lisp_flat_eid, a->reid);
3939 vat_json_object_add_string_copy (e, "reid", s);
3943 vat_json_print (vam->ofp, &root);
3944 vat_json_free (&root);
3947 vam->retval = retval;
3948 vam->result_ready = 1;
3952 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3954 vat_main_t *vam = &vat_main;
3956 print (vam->ofp, "%=20U",
3957 mp->ip_address.af ? format_ip6_address : format_ip4_address,
3962 vl_api_one_map_server_details_t_handler_json
3963 (vl_api_one_map_server_details_t * mp)
3965 vat_main_t *vam = &vat_main;
3966 vat_json_node_t *node = NULL;
3967 struct in6_addr ip6;
3970 if (VAT_JSON_ARRAY != vam->json_tree.type)
3972 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3973 vat_json_init_array (&vam->json_tree);
3975 node = vat_json_array_add (&vam->json_tree);
3977 vat_json_init_object (node);
3978 if (mp->ip_address.af)
3980 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
3981 vat_json_object_add_ip6 (node, "map-server", ip6);
3985 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
3986 vat_json_object_add_ip4 (node, "map-server", ip4);
3991 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3994 vat_main_t *vam = &vat_main;
3996 print (vam->ofp, "%=20U",
3997 mp->ip_address.af ? format_ip6_address : format_ip4_address,
4002 vl_api_one_map_resolver_details_t_handler_json
4003 (vl_api_one_map_resolver_details_t * mp)
4005 vat_main_t *vam = &vat_main;
4006 vat_json_node_t *node = NULL;
4007 struct in6_addr ip6;
4010 if (VAT_JSON_ARRAY != vam->json_tree.type)
4012 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4013 vat_json_init_array (&vam->json_tree);
4015 node = vat_json_array_add (&vam->json_tree);
4017 vat_json_init_object (node);
4018 if (mp->ip_address.af)
4020 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
4021 vat_json_object_add_ip6 (node, "map resolver", ip6);
4025 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
4026 vat_json_object_add_ip4 (node, "map resolver", ip4);
4031 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4033 vat_main_t *vam = &vat_main;
4034 i32 retval = ntohl (mp->retval);
4038 print (vam->ofp, "feature: %s\ngpe: %s",
4039 mp->feature_status ? "enabled" : "disabled",
4040 mp->gpe_status ? "enabled" : "disabled");
4043 vam->retval = retval;
4044 vam->result_ready = 1;
4048 vl_api_show_one_status_reply_t_handler_json
4049 (vl_api_show_one_status_reply_t * mp)
4051 vat_main_t *vam = &vat_main;
4052 vat_json_node_t node;
4053 u8 *gpe_status = NULL;
4054 u8 *feature_status = NULL;
4056 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4057 feature_status = format (0, "%s",
4058 mp->feature_status ? "enabled" : "disabled");
4059 vec_add1 (gpe_status, 0);
4060 vec_add1 (feature_status, 0);
4062 vat_json_init_object (&node);
4063 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4064 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4066 vec_free (gpe_status);
4067 vec_free (feature_status);
4069 vat_json_print (vam->ofp, &node);
4070 vat_json_free (&node);
4072 vam->retval = ntohl (mp->retval);
4073 vam->result_ready = 1;
4077 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4078 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4080 vat_main_t *vam = &vat_main;
4081 i32 retval = ntohl (mp->retval);
4085 print (vam->ofp, "%=20s", mp->locator_set_name);
4088 vam->retval = retval;
4089 vam->result_ready = 1;
4093 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4094 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4096 vat_main_t *vam = &vat_main;
4097 vat_json_node_t *node = NULL;
4099 if (VAT_JSON_ARRAY != vam->json_tree.type)
4101 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4102 vat_json_init_array (&vam->json_tree);
4104 node = vat_json_array_add (&vam->json_tree);
4106 vat_json_init_object (node);
4107 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4109 vat_json_print (vam->ofp, node);
4110 vat_json_free (node);
4112 vam->retval = ntohl (mp->retval);
4113 vam->result_ready = 1;
4117 format_lisp_map_request_mode (u8 * s, va_list * args)
4119 u32 mode = va_arg (*args, u32);
4124 return format (0, "dst-only");
4126 return format (0, "src-dst");
4132 vl_api_show_one_map_request_mode_reply_t_handler
4133 (vl_api_show_one_map_request_mode_reply_t * mp)
4135 vat_main_t *vam = &vat_main;
4136 i32 retval = ntohl (mp->retval);
4140 u32 mode = mp->mode;
4141 print (vam->ofp, "map_request_mode: %U",
4142 format_lisp_map_request_mode, mode);
4145 vam->retval = retval;
4146 vam->result_ready = 1;
4150 vl_api_show_one_map_request_mode_reply_t_handler_json
4151 (vl_api_show_one_map_request_mode_reply_t * mp)
4153 vat_main_t *vam = &vat_main;
4154 vat_json_node_t node;
4159 s = format (0, "%U", format_lisp_map_request_mode, mode);
4162 vat_json_init_object (&node);
4163 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4164 vat_json_print (vam->ofp, &node);
4165 vat_json_free (&node);
4168 vam->retval = ntohl (mp->retval);
4169 vam->result_ready = 1;
4173 vl_api_one_show_xtr_mode_reply_t_handler
4174 (vl_api_one_show_xtr_mode_reply_t * mp)
4176 vat_main_t *vam = &vat_main;
4177 i32 retval = ntohl (mp->retval);
4181 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4184 vam->retval = retval;
4185 vam->result_ready = 1;
4189 vl_api_one_show_xtr_mode_reply_t_handler_json
4190 (vl_api_one_show_xtr_mode_reply_t * mp)
4192 vat_main_t *vam = &vat_main;
4193 vat_json_node_t node;
4196 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4197 vec_add1 (status, 0);
4199 vat_json_init_object (&node);
4200 vat_json_object_add_string_copy (&node, "status", status);
4204 vat_json_print (vam->ofp, &node);
4205 vat_json_free (&node);
4207 vam->retval = ntohl (mp->retval);
4208 vam->result_ready = 1;
4212 vl_api_one_show_pitr_mode_reply_t_handler
4213 (vl_api_one_show_pitr_mode_reply_t * mp)
4215 vat_main_t *vam = &vat_main;
4216 i32 retval = ntohl (mp->retval);
4220 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4223 vam->retval = retval;
4224 vam->result_ready = 1;
4228 vl_api_one_show_pitr_mode_reply_t_handler_json
4229 (vl_api_one_show_pitr_mode_reply_t * mp)
4231 vat_main_t *vam = &vat_main;
4232 vat_json_node_t node;
4235 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4236 vec_add1 (status, 0);
4238 vat_json_init_object (&node);
4239 vat_json_object_add_string_copy (&node, "status", status);
4243 vat_json_print (vam->ofp, &node);
4244 vat_json_free (&node);
4246 vam->retval = ntohl (mp->retval);
4247 vam->result_ready = 1;
4251 vl_api_one_show_petr_mode_reply_t_handler
4252 (vl_api_one_show_petr_mode_reply_t * mp)
4254 vat_main_t *vam = &vat_main;
4255 i32 retval = ntohl (mp->retval);
4259 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4262 vam->retval = retval;
4263 vam->result_ready = 1;
4267 vl_api_one_show_petr_mode_reply_t_handler_json
4268 (vl_api_one_show_petr_mode_reply_t * mp)
4270 vat_main_t *vam = &vat_main;
4271 vat_json_node_t node;
4274 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4275 vec_add1 (status, 0);
4277 vat_json_init_object (&node);
4278 vat_json_object_add_string_copy (&node, "status", status);
4282 vat_json_print (vam->ofp, &node);
4283 vat_json_free (&node);
4285 vam->retval = ntohl (mp->retval);
4286 vam->result_ready = 1;
4290 vl_api_show_one_use_petr_reply_t_handler
4291 (vl_api_show_one_use_petr_reply_t * mp)
4293 vat_main_t *vam = &vat_main;
4294 i32 retval = ntohl (mp->retval);
4298 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4301 print (vam->ofp, "Proxy-ETR address; %U",
4302 mp->ip_address.af ? format_ip6_address : format_ip4_address,
4307 vam->retval = retval;
4308 vam->result_ready = 1;
4312 vl_api_show_one_use_petr_reply_t_handler_json
4313 (vl_api_show_one_use_petr_reply_t * mp)
4315 vat_main_t *vam = &vat_main;
4316 vat_json_node_t node;
4319 struct in6_addr ip6;
4321 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4322 vec_add1 (status, 0);
4324 vat_json_init_object (&node);
4325 vat_json_object_add_string_copy (&node, "status", status);
4328 if (mp->ip_address.af)
4330 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
4331 vat_json_object_add_ip6 (&node, "address", ip6);
4335 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
4336 vat_json_object_add_ip4 (&node, "address", ip4);
4342 vat_json_print (vam->ofp, &node);
4343 vat_json_free (&node);
4345 vam->retval = ntohl (mp->retval);
4346 vam->result_ready = 1;
4350 vl_api_show_one_nsh_mapping_reply_t_handler
4351 (vl_api_show_one_nsh_mapping_reply_t * mp)
4353 vat_main_t *vam = &vat_main;
4354 i32 retval = ntohl (mp->retval);
4358 print (vam->ofp, "%-20s%-16s",
4359 mp->is_set ? "set" : "not-set",
4360 mp->is_set ? (char *) mp->locator_set_name : "");
4363 vam->retval = retval;
4364 vam->result_ready = 1;
4368 vl_api_show_one_nsh_mapping_reply_t_handler_json
4369 (vl_api_show_one_nsh_mapping_reply_t * mp)
4371 vat_main_t *vam = &vat_main;
4372 vat_json_node_t node;
4375 status = format (0, "%s", mp->is_set ? "yes" : "no");
4376 vec_add1 (status, 0);
4378 vat_json_init_object (&node);
4379 vat_json_object_add_string_copy (&node, "is_set", status);
4382 vat_json_object_add_string_copy (&node, "locator_set",
4383 mp->locator_set_name);
4388 vat_json_print (vam->ofp, &node);
4389 vat_json_free (&node);
4391 vam->retval = ntohl (mp->retval);
4392 vam->result_ready = 1;
4396 vl_api_show_one_map_register_ttl_reply_t_handler
4397 (vl_api_show_one_map_register_ttl_reply_t * mp)
4399 vat_main_t *vam = &vat_main;
4400 i32 retval = ntohl (mp->retval);
4402 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4406 print (vam->ofp, "ttl: %u", mp->ttl);
4409 vam->retval = retval;
4410 vam->result_ready = 1;
4414 vl_api_show_one_map_register_ttl_reply_t_handler_json
4415 (vl_api_show_one_map_register_ttl_reply_t * mp)
4417 vat_main_t *vam = &vat_main;
4418 vat_json_node_t node;
4420 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4421 vat_json_init_object (&node);
4422 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4424 vat_json_print (vam->ofp, &node);
4425 vat_json_free (&node);
4427 vam->retval = ntohl (mp->retval);
4428 vam->result_ready = 1;
4432 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4434 vat_main_t *vam = &vat_main;
4435 i32 retval = ntohl (mp->retval);
4439 print (vam->ofp, "%-20s%-16s",
4440 mp->status ? "enabled" : "disabled",
4441 mp->status ? (char *) mp->locator_set_name : "");
4444 vam->retval = retval;
4445 vam->result_ready = 1;
4449 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4451 vat_main_t *vam = &vat_main;
4452 vat_json_node_t node;
4455 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4456 vec_add1 (status, 0);
4458 vat_json_init_object (&node);
4459 vat_json_object_add_string_copy (&node, "status", status);
4462 vat_json_object_add_string_copy (&node, "locator_set",
4463 mp->locator_set_name);
4468 vat_json_print (vam->ofp, &node);
4469 vat_json_free (&node);
4471 vam->retval = ntohl (mp->retval);
4472 vam->result_ready = 1;
4476 format_policer_type (u8 * s, va_list * va)
4478 u32 i = va_arg (*va, u32);
4480 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4481 s = format (s, "1r2c");
4482 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4483 s = format (s, "1r3c");
4484 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4485 s = format (s, "2r3c-2698");
4486 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4487 s = format (s, "2r3c-4115");
4488 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4489 s = format (s, "2r3c-mef5cf1");
4491 s = format (s, "ILLEGAL");
4496 format_policer_rate_type (u8 * s, va_list * va)
4498 u32 i = va_arg (*va, u32);
4500 if (i == SSE2_QOS_RATE_KBPS)
4501 s = format (s, "kbps");
4502 else if (i == SSE2_QOS_RATE_PPS)
4503 s = format (s, "pps");
4505 s = format (s, "ILLEGAL");
4510 format_policer_round_type (u8 * s, va_list * va)
4512 u32 i = va_arg (*va, u32);
4514 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4515 s = format (s, "closest");
4516 else if (i == SSE2_QOS_ROUND_TO_UP)
4517 s = format (s, "up");
4518 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4519 s = format (s, "down");
4521 s = format (s, "ILLEGAL");
4526 format_policer_action_type (u8 * s, va_list * va)
4528 u32 i = va_arg (*va, u32);
4530 if (i == SSE2_QOS_ACTION_DROP)
4531 s = format (s, "drop");
4532 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4533 s = format (s, "transmit");
4534 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4535 s = format (s, "mark-and-transmit");
4537 s = format (s, "ILLEGAL");
4542 format_dscp (u8 * s, va_list * va)
4544 u32 i = va_arg (*va, u32);
4549 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4553 return format (s, "ILLEGAL");
4555 s = format (s, "%s", t);
4560 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4562 vat_main_t *vam = &vat_main;
4563 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4565 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4566 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
4568 conform_dscp_str = format (0, "");
4570 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4571 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
4573 exceed_dscp_str = format (0, "");
4575 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4576 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
4578 violate_dscp_str = format (0, "");
4580 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4581 "rate type %U, round type %U, %s rate, %s color-aware, "
4582 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4583 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4584 "conform action %U%s, exceed action %U%s, violate action %U%s",
4586 format_policer_type, mp->type,
4589 clib_net_to_host_u64 (mp->cb),
4590 clib_net_to_host_u64 (mp->eb),
4591 format_policer_rate_type, mp->rate_type,
4592 format_policer_round_type, mp->round_type,
4593 mp->single_rate ? "single" : "dual",
4594 mp->color_aware ? "is" : "not",
4595 ntohl (mp->cir_tokens_per_period),
4596 ntohl (mp->pir_tokens_per_period),
4598 ntohl (mp->current_limit),
4599 ntohl (mp->current_bucket),
4600 ntohl (mp->extended_limit),
4601 ntohl (mp->extended_bucket),
4602 clib_net_to_host_u64 (mp->last_update_time),
4603 format_policer_action_type, mp->conform_action.type,
4605 format_policer_action_type, mp->exceed_action.type,
4607 format_policer_action_type, mp->violate_action.type,
4610 vec_free (conform_dscp_str);
4611 vec_free (exceed_dscp_str);
4612 vec_free (violate_dscp_str);
4615 static void vl_api_policer_details_t_handler_json
4616 (vl_api_policer_details_t * mp)
4618 vat_main_t *vam = &vat_main;
4619 vat_json_node_t *node;
4620 u8 *rate_type_str, *round_type_str, *type_str;
4621 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4623 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4625 format (0, "%U", format_policer_round_type, mp->round_type);
4626 type_str = format (0, "%U", format_policer_type, mp->type);
4627 conform_action_str = format (0, "%U", format_policer_action_type,
4628 mp->conform_action.type);
4629 exceed_action_str = format (0, "%U", format_policer_action_type,
4630 mp->exceed_action.type);
4631 violate_action_str = format (0, "%U", format_policer_action_type,
4632 mp->violate_action.type);
4634 if (VAT_JSON_ARRAY != vam->json_tree.type)
4636 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4637 vat_json_init_array (&vam->json_tree);
4639 node = vat_json_array_add (&vam->json_tree);
4641 vat_json_init_object (node);
4642 vat_json_object_add_string_copy (node, "name", mp->name);
4643 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4644 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4645 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4646 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4647 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4648 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4649 vat_json_object_add_string_copy (node, "type", type_str);
4650 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4651 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4652 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4653 vat_json_object_add_uint (node, "cir_tokens_per_period",
4654 ntohl (mp->cir_tokens_per_period));
4655 vat_json_object_add_uint (node, "eir_tokens_per_period",
4656 ntohl (mp->pir_tokens_per_period));
4657 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4658 vat_json_object_add_uint (node, "current_bucket",
4659 ntohl (mp->current_bucket));
4660 vat_json_object_add_uint (node, "extended_limit",
4661 ntohl (mp->extended_limit));
4662 vat_json_object_add_uint (node, "extended_bucket",
4663 ntohl (mp->extended_bucket));
4664 vat_json_object_add_uint (node, "last_update_time",
4665 ntohl (mp->last_update_time));
4666 vat_json_object_add_string_copy (node, "conform_action",
4667 conform_action_str);
4668 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4670 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
4671 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4672 vec_free (dscp_str);
4674 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4675 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4677 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
4678 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4679 vec_free (dscp_str);
4681 vat_json_object_add_string_copy (node, "violate_action",
4682 violate_action_str);
4683 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4685 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
4686 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4687 vec_free (dscp_str);
4690 vec_free (rate_type_str);
4691 vec_free (round_type_str);
4692 vec_free (type_str);
4693 vec_free (conform_action_str);
4694 vec_free (exceed_action_str);
4695 vec_free (violate_action_str);
4699 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4702 vat_main_t *vam = &vat_main;
4703 int i, count = ntohl (mp->count);
4706 print (vam->ofp, "classify table ids (%d) : ", count);
4707 for (i = 0; i < count; i++)
4709 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4710 print (vam->ofp, (i < count - 1) ? "," : "");
4712 vam->retval = ntohl (mp->retval);
4713 vam->result_ready = 1;
4717 vl_api_classify_table_ids_reply_t_handler_json
4718 (vl_api_classify_table_ids_reply_t * mp)
4720 vat_main_t *vam = &vat_main;
4721 int i, count = ntohl (mp->count);
4725 vat_json_node_t node;
4727 vat_json_init_object (&node);
4728 for (i = 0; i < count; i++)
4730 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4732 vat_json_print (vam->ofp, &node);
4733 vat_json_free (&node);
4735 vam->retval = ntohl (mp->retval);
4736 vam->result_ready = 1;
4740 vl_api_classify_table_by_interface_reply_t_handler
4741 (vl_api_classify_table_by_interface_reply_t * mp)
4743 vat_main_t *vam = &vat_main;
4746 table_id = ntohl (mp->l2_table_id);
4748 print (vam->ofp, "l2 table id : %d", table_id);
4750 print (vam->ofp, "l2 table id : No input ACL tables configured");
4751 table_id = ntohl (mp->ip4_table_id);
4753 print (vam->ofp, "ip4 table id : %d", table_id);
4755 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4756 table_id = ntohl (mp->ip6_table_id);
4758 print (vam->ofp, "ip6 table id : %d", table_id);
4760 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4761 vam->retval = ntohl (mp->retval);
4762 vam->result_ready = 1;
4766 vl_api_classify_table_by_interface_reply_t_handler_json
4767 (vl_api_classify_table_by_interface_reply_t * mp)
4769 vat_main_t *vam = &vat_main;
4770 vat_json_node_t node;
4772 vat_json_init_object (&node);
4774 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4775 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4776 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4778 vat_json_print (vam->ofp, &node);
4779 vat_json_free (&node);
4781 vam->retval = ntohl (mp->retval);
4782 vam->result_ready = 1;
4785 static void vl_api_policer_add_del_reply_t_handler
4786 (vl_api_policer_add_del_reply_t * mp)
4788 vat_main_t *vam = &vat_main;
4789 i32 retval = ntohl (mp->retval);
4790 if (vam->async_mode)
4792 vam->async_errors += (retval < 0);
4796 vam->retval = retval;
4797 vam->result_ready = 1;
4798 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4800 * Note: this is just barely thread-safe, depends on
4801 * the main thread spinning waiting for an answer...
4803 errmsg ("policer index %d", ntohl (mp->policer_index));
4807 static void vl_api_policer_add_del_reply_t_handler_json
4808 (vl_api_policer_add_del_reply_t * mp)
4810 vat_main_t *vam = &vat_main;
4811 vat_json_node_t node;
4813 vat_json_init_object (&node);
4814 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4815 vat_json_object_add_uint (&node, "policer_index",
4816 ntohl (mp->policer_index));
4818 vat_json_print (vam->ofp, &node);
4819 vat_json_free (&node);
4821 vam->retval = ntohl (mp->retval);
4822 vam->result_ready = 1;
4825 /* Format hex dump. */
4827 format_hex_bytes (u8 * s, va_list * va)
4829 u8 *bytes = va_arg (*va, u8 *);
4830 int n_bytes = va_arg (*va, int);
4833 /* Print short or long form depending on byte count. */
4834 uword short_form = n_bytes <= 32;
4835 u32 indent = format_get_indent (s);
4840 for (i = 0; i < n_bytes; i++)
4842 if (!short_form && (i % 32) == 0)
4843 s = format (s, "%08x: ", i);
4844 s = format (s, "%02x", bytes[i]);
4845 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4846 s = format (s, "\n%U", format_white_space, indent);
4853 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4856 vat_main_t *vam = &vat_main;
4857 i32 retval = ntohl (mp->retval);
4860 print (vam->ofp, "classify table info :");
4861 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4862 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4863 ntohl (mp->miss_next_index));
4864 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4865 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4866 ntohl (mp->match_n_vectors));
4867 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4868 ntohl (mp->mask_length));
4870 vam->retval = retval;
4871 vam->result_ready = 1;
4875 vl_api_classify_table_info_reply_t_handler_json
4876 (vl_api_classify_table_info_reply_t * mp)
4878 vat_main_t *vam = &vat_main;
4879 vat_json_node_t node;
4881 i32 retval = ntohl (mp->retval);
4884 vat_json_init_object (&node);
4886 vat_json_object_add_int (&node, "sessions",
4887 ntohl (mp->active_sessions));
4888 vat_json_object_add_int (&node, "nexttbl",
4889 ntohl (mp->next_table_index));
4890 vat_json_object_add_int (&node, "nextnode",
4891 ntohl (mp->miss_next_index));
4892 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4893 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4894 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4895 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4896 ntohl (mp->mask_length), 0);
4897 vat_json_object_add_string_copy (&node, "mask", s);
4899 vat_json_print (vam->ofp, &node);
4900 vat_json_free (&node);
4902 vam->retval = ntohl (mp->retval);
4903 vam->result_ready = 1;
4907 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4910 vat_main_t *vam = &vat_main;
4912 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4913 ntohl (mp->hit_next_index), ntohl (mp->advance),
4914 ntohl (mp->opaque_index));
4915 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4916 ntohl (mp->match_length));
4920 vl_api_classify_session_details_t_handler_json
4921 (vl_api_classify_session_details_t * mp)
4923 vat_main_t *vam = &vat_main;
4924 vat_json_node_t *node = NULL;
4926 if (VAT_JSON_ARRAY != vam->json_tree.type)
4928 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4929 vat_json_init_array (&vam->json_tree);
4931 node = vat_json_array_add (&vam->json_tree);
4933 vat_json_init_object (node);
4934 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4935 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4936 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4938 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4940 vat_json_object_add_string_copy (node, "match", s);
4943 static void vl_api_pg_create_interface_reply_t_handler
4944 (vl_api_pg_create_interface_reply_t * mp)
4946 vat_main_t *vam = &vat_main;
4948 vam->retval = ntohl (mp->retval);
4949 vam->result_ready = 1;
4952 static void vl_api_pg_create_interface_reply_t_handler_json
4953 (vl_api_pg_create_interface_reply_t * mp)
4955 vat_main_t *vam = &vat_main;
4956 vat_json_node_t node;
4958 i32 retval = ntohl (mp->retval);
4961 vat_json_init_object (&node);
4963 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4965 vat_json_print (vam->ofp, &node);
4966 vat_json_free (&node);
4968 vam->retval = ntohl (mp->retval);
4969 vam->result_ready = 1;
4972 static void vl_api_policer_classify_details_t_handler
4973 (vl_api_policer_classify_details_t * mp)
4975 vat_main_t *vam = &vat_main;
4977 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4978 ntohl (mp->table_index));
4981 static void vl_api_policer_classify_details_t_handler_json
4982 (vl_api_policer_classify_details_t * mp)
4984 vat_main_t *vam = &vat_main;
4985 vat_json_node_t *node;
4987 if (VAT_JSON_ARRAY != vam->json_tree.type)
4989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4990 vat_json_init_array (&vam->json_tree);
4992 node = vat_json_array_add (&vam->json_tree);
4994 vat_json_init_object (node);
4995 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4996 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4999 static void vl_api_flow_classify_details_t_handler
5000 (vl_api_flow_classify_details_t * mp)
5002 vat_main_t *vam = &vat_main;
5004 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5005 ntohl (mp->table_index));
5008 static void vl_api_flow_classify_details_t_handler_json
5009 (vl_api_flow_classify_details_t * mp)
5011 vat_main_t *vam = &vat_main;
5012 vat_json_node_t *node;
5014 if (VAT_JSON_ARRAY != vam->json_tree.type)
5016 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5017 vat_json_init_array (&vam->json_tree);
5019 node = vat_json_array_add (&vam->json_tree);
5021 vat_json_init_object (node);
5022 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5023 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5026 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5027 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5028 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5029 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5030 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5031 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5032 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5033 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5034 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5035 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5038 * Generate boilerplate reply handlers, which
5039 * dig the return value out of the xxx_reply_t API message,
5040 * stick it into vam->retval, and set vam->result_ready
5042 * Could also do this by pointing N message decode slots at
5043 * a single function, but that could break in subtle ways.
5046 #define foreach_standard_reply_retval_handler \
5047 _(sw_interface_set_flags_reply) \
5048 _(sw_interface_add_del_address_reply) \
5049 _(sw_interface_set_rx_mode_reply) \
5050 _(sw_interface_set_rx_placement_reply) \
5051 _(sw_interface_set_table_reply) \
5052 _(sw_interface_set_mpls_enable_reply) \
5053 _(sw_interface_set_vpath_reply) \
5054 _(sw_interface_set_vxlan_bypass_reply) \
5055 _(sw_interface_set_geneve_bypass_reply) \
5056 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5057 _(sw_interface_set_l2_bridge_reply) \
5058 _(sw_interface_set_bond_weight_reply) \
5059 _(bridge_domain_add_del_reply) \
5060 _(sw_interface_set_l2_xconnect_reply) \
5061 _(l2fib_add_del_reply) \
5062 _(l2fib_flush_int_reply) \
5063 _(l2fib_flush_bd_reply) \
5064 _(ip_route_add_del_reply) \
5065 _(ip_table_add_del_reply) \
5066 _(ip_table_replace_begin_reply) \
5067 _(ip_table_flush_reply) \
5068 _(ip_table_replace_end_reply) \
5069 _(ip_mroute_add_del_reply) \
5070 _(mpls_route_add_del_reply) \
5071 _(mpls_table_add_del_reply) \
5072 _(mpls_ip_bind_unbind_reply) \
5073 _(bier_route_add_del_reply) \
5074 _(bier_table_add_del_reply) \
5075 _(sw_interface_set_unnumbered_reply) \
5076 _(set_ip_flow_hash_reply) \
5077 _(sw_interface_ip6_enable_disable_reply) \
5078 _(l2_patch_add_del_reply) \
5079 _(sr_mpls_policy_add_reply) \
5080 _(sr_mpls_policy_mod_reply) \
5081 _(sr_mpls_policy_del_reply) \
5082 _(sr_policy_add_reply) \
5083 _(sr_policy_mod_reply) \
5084 _(sr_policy_del_reply) \
5085 _(sr_localsid_add_del_reply) \
5086 _(sr_steering_add_del_reply) \
5087 _(classify_add_del_session_reply) \
5088 _(classify_set_interface_ip_table_reply) \
5089 _(classify_set_interface_l2_tables_reply) \
5090 _(l2tpv3_set_tunnel_cookies_reply) \
5091 _(l2tpv3_interface_enable_disable_reply) \
5092 _(l2tpv3_set_lookup_key_reply) \
5093 _(l2_fib_clear_table_reply) \
5094 _(l2_interface_efp_filter_reply) \
5095 _(l2_interface_vlan_tag_rewrite_reply) \
5096 _(modify_vhost_user_if_reply) \
5097 _(delete_vhost_user_if_reply) \
5098 _(want_l2_macs_events_reply) \
5099 _(input_acl_set_interface_reply) \
5100 _(ipsec_spd_add_del_reply) \
5101 _(ipsec_interface_add_del_spd_reply) \
5102 _(ipsec_spd_entry_add_del_reply) \
5103 _(ipsec_sad_entry_add_del_reply) \
5104 _(ipsec_tunnel_if_add_del_reply) \
5105 _(ipsec_tunnel_if_set_sa_reply) \
5106 _(delete_loopback_reply) \
5107 _(bd_ip_mac_add_del_reply) \
5108 _(bd_ip_mac_flush_reply) \
5109 _(want_interface_events_reply) \
5110 _(cop_interface_enable_disable_reply) \
5111 _(cop_whitelist_enable_disable_reply) \
5112 _(sw_interface_clear_stats_reply) \
5113 _(ioam_enable_reply) \
5114 _(ioam_disable_reply) \
5115 _(one_add_del_locator_reply) \
5116 _(one_add_del_local_eid_reply) \
5117 _(one_add_del_remote_mapping_reply) \
5118 _(one_add_del_adjacency_reply) \
5119 _(one_add_del_map_resolver_reply) \
5120 _(one_add_del_map_server_reply) \
5121 _(one_enable_disable_reply) \
5122 _(one_rloc_probe_enable_disable_reply) \
5123 _(one_map_register_enable_disable_reply) \
5124 _(one_map_register_set_ttl_reply) \
5125 _(one_set_transport_protocol_reply) \
5126 _(one_map_register_fallback_threshold_reply) \
5127 _(one_pitr_set_locator_set_reply) \
5128 _(one_map_request_mode_reply) \
5129 _(one_add_del_map_request_itr_rlocs_reply) \
5130 _(one_eid_table_add_del_map_reply) \
5131 _(one_use_petr_reply) \
5132 _(one_stats_enable_disable_reply) \
5133 _(one_add_del_l2_arp_entry_reply) \
5134 _(one_add_del_ndp_entry_reply) \
5135 _(one_stats_flush_reply) \
5136 _(one_enable_disable_xtr_mode_reply) \
5137 _(one_enable_disable_pitr_mode_reply) \
5138 _(one_enable_disable_petr_mode_reply) \
5139 _(gpe_enable_disable_reply) \
5140 _(gpe_set_encap_mode_reply) \
5141 _(gpe_add_del_iface_reply) \
5142 _(gpe_add_del_native_fwd_rpath_reply) \
5143 _(af_packet_delete_reply) \
5144 _(policer_classify_set_interface_reply) \
5145 _(set_ipfix_exporter_reply) \
5146 _(set_ipfix_classify_stream_reply) \
5147 _(ipfix_classify_table_add_del_reply) \
5148 _(flow_classify_set_interface_reply) \
5149 _(sw_interface_span_enable_disable_reply) \
5150 _(pg_capture_reply) \
5151 _(pg_enable_disable_reply) \
5152 _(pg_interface_enable_disable_coalesce_reply) \
5153 _(ip_source_and_port_range_check_add_del_reply) \
5154 _(ip_source_and_port_range_check_interface_add_del_reply)\
5155 _(delete_subif_reply) \
5156 _(l2_interface_pbb_tag_rewrite_reply) \
5158 _(feature_enable_disable_reply) \
5159 _(feature_gso_enable_disable_reply) \
5160 _(sw_interface_tag_add_del_reply) \
5161 _(sw_interface_add_del_mac_address_reply) \
5162 _(hw_interface_set_mtu_reply) \
5163 _(p2p_ethernet_add_reply) \
5164 _(p2p_ethernet_del_reply) \
5165 _(lldp_config_reply) \
5166 _(sw_interface_set_lldp_reply) \
5167 _(tcp_configure_src_addresses_reply) \
5168 _(session_rule_add_del_reply) \
5169 _(ip_container_proxy_add_del_reply) \
5170 _(output_acl_set_interface_reply) \
5171 _(qos_record_enable_disable_reply) \
5175 static void vl_api_##n##_t_handler \
5176 (vl_api_##n##_t * mp) \
5178 vat_main_t * vam = &vat_main; \
5179 i32 retval = ntohl(mp->retval); \
5180 if (vam->async_mode) { \
5181 vam->async_errors += (retval < 0); \
5183 vam->retval = retval; \
5184 vam->result_ready = 1; \
5187 foreach_standard_reply_retval_handler;
5191 static void vl_api_##n##_t_handler_json \
5192 (vl_api_##n##_t * mp) \
5194 vat_main_t * vam = &vat_main; \
5195 vat_json_node_t node; \
5196 vat_json_init_object(&node); \
5197 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5198 vat_json_print(vam->ofp, &node); \
5199 vam->retval = ntohl(mp->retval); \
5200 vam->result_ready = 1; \
5202 foreach_standard_reply_retval_handler;
5206 * Table of message reply handlers, must include boilerplate handlers
5210 #define foreach_vpe_api_reply_msg \
5211 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5212 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5213 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5214 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5215 _(CONTROL_PING_REPLY, control_ping_reply) \
5216 _(CLI_REPLY, cli_reply) \
5217 _(CLI_INBAND_REPLY, cli_inband_reply) \
5218 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5219 sw_interface_add_del_address_reply) \
5220 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5221 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5222 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5223 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5224 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5225 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5226 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5227 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5228 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5229 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5230 sw_interface_set_l2_xconnect_reply) \
5231 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5232 sw_interface_set_l2_bridge_reply) \
5233 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5234 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5235 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5236 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5237 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5238 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5239 _(L2_FLAGS_REPLY, l2_flags_reply) \
5240 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5241 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5242 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5243 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5244 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5245 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5246 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5247 _(BOND_CREATE_REPLY, bond_create_reply) \
5248 _(BOND_DELETE_REPLY, bond_delete_reply) \
5249 _(BOND_ADD_MEMBER_REPLY, bond_add_member_reply) \
5250 _(BOND_DETACH_MEMBER_REPLY, bond_detach_member_reply) \
5251 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5252 _(SW_BOND_INTERFACE_DETAILS, sw_bond_interface_details) \
5253 _(SW_MEMBER_INTERFACE_DETAILS, sw_member_interface_details) \
5254 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5255 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5256 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5257 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5258 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5259 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5260 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5261 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5262 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5263 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5264 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5265 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5266 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5267 sw_interface_set_unnumbered_reply) \
5268 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5269 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5270 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5271 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5272 sw_interface_ip6_enable_disable_reply) \
5273 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5274 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5275 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5276 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5277 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5278 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5279 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5280 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5281 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5282 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5283 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5284 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5285 classify_set_interface_ip_table_reply) \
5286 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5287 classify_set_interface_l2_tables_reply) \
5288 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5289 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5290 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5291 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5292 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5293 l2tpv3_interface_enable_disable_reply) \
5294 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5295 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5296 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5297 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5298 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5299 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5300 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5301 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5302 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5303 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5304 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5305 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5306 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5307 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5308 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5309 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5310 _(SHOW_VERSION_REPLY, show_version_reply) \
5311 _(SHOW_THREADS_REPLY, show_threads_reply) \
5312 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5313 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5314 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5315 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5316 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5317 _(L2_MACS_EVENT, l2_macs_event) \
5318 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5319 _(IP_ADDRESS_DETAILS, ip_address_details) \
5320 _(IP_DETAILS, ip_details) \
5321 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5322 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5323 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5324 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5325 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5326 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5327 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5328 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5329 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5330 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5331 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5332 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5333 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5334 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5335 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5336 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5337 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5338 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5339 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5340 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5341 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5342 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5343 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5344 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5345 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5346 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5347 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5348 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5349 one_map_register_enable_disable_reply) \
5350 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5351 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5352 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5353 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5354 one_map_register_fallback_threshold_reply) \
5355 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5356 one_rloc_probe_enable_disable_reply) \
5357 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5358 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5359 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5360 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5361 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5362 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5363 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5364 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5365 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5366 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5367 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5368 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5369 _(ONE_STATS_DETAILS, one_stats_details) \
5370 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5371 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5372 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5373 show_one_stats_enable_disable_reply) \
5374 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5375 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5376 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5377 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5378 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5379 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5380 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5381 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5382 one_enable_disable_pitr_mode_reply) \
5383 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5384 one_enable_disable_petr_mode_reply) \
5385 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5386 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5387 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5388 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5389 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5390 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5391 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5392 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5393 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5394 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5395 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5396 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5397 gpe_add_del_native_fwd_rpath_reply) \
5398 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5399 gpe_fwd_entry_path_details) \
5400 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5401 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5402 one_add_del_map_request_itr_rlocs_reply) \
5403 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5404 one_get_map_request_itr_rlocs_reply) \
5405 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5406 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5407 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5408 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5409 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5410 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5411 show_one_map_register_state_reply) \
5412 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5413 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5414 show_one_map_register_fallback_threshold_reply) \
5415 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5416 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5417 _(AF_PACKET_DETAILS, af_packet_details) \
5418 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5419 _(POLICER_DETAILS, policer_details) \
5420 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5421 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5422 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5423 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5424 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5425 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5426 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5427 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5428 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5429 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5430 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5431 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5432 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5433 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5434 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5435 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5436 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5437 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5438 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5439 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5440 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5441 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5442 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5443 _(PG_INTERFACE_ENABLE_DISABLE_COALESCE_REPLY, pg_interface_enable_disable_coalesce_reply) \
5444 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5445 ip_source_and_port_range_check_add_del_reply) \
5446 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5447 ip_source_and_port_range_check_interface_add_del_reply) \
5448 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5449 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5450 _(SET_PUNT_REPLY, set_punt_reply) \
5451 _(IP_TABLE_DETAILS, ip_table_details) \
5452 _(IP_ROUTE_DETAILS, ip_route_details) \
5453 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5454 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5455 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5456 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5457 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5458 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5459 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5460 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5461 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5462 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5463 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5464 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5465 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5466 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5467 _(SESSION_RULES_DETAILS, session_rules_details) \
5468 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5469 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5470 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply) \
5471 _(FLOW_ADD_REPLY, flow_add_reply) \
5473 #define foreach_standalone_reply_msg \
5474 _(SW_INTERFACE_EVENT, sw_interface_event)
5482 #define STR_VTR_OP_CASE(op) \
5483 case L2_VTR_ ## op: \
5487 str_vtr_op (u32 vtr_op)
5491 STR_VTR_OP_CASE (DISABLED);
5492 STR_VTR_OP_CASE (PUSH_1);
5493 STR_VTR_OP_CASE (PUSH_2);
5494 STR_VTR_OP_CASE (POP_1);
5495 STR_VTR_OP_CASE (POP_2);
5496 STR_VTR_OP_CASE (TRANSLATE_1_1);
5497 STR_VTR_OP_CASE (TRANSLATE_1_2);
5498 STR_VTR_OP_CASE (TRANSLATE_2_1);
5499 STR_VTR_OP_CASE (TRANSLATE_2_2);
5506 dump_sub_interface_table (vat_main_t * vam)
5508 const sw_interface_subif_t *sub = NULL;
5510 if (vam->json_output)
5513 ("JSON output supported only for VPE API calls and dump_stats_table");
5518 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5519 "Interface", "sw_if_index",
5520 "sub id", "dot1ad", "tags", "outer id",
5521 "inner id", "exact", "default", "outer any", "inner any");
5523 vec_foreach (sub, vam->sw_if_subif_table)
5526 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5527 sub->interface_name,
5529 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5530 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5531 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5532 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5533 if (sub->vtr_op != L2_VTR_DISABLED)
5536 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5537 "tag1: %d tag2: %d ]",
5538 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5539 sub->vtr_tag1, sub->vtr_tag2);
5547 name_sort_cmp (void *a1, void *a2)
5549 name_sort_t *n1 = a1;
5550 name_sort_t *n2 = a2;
5552 return strcmp ((char *) n1->name, (char *) n2->name);
5556 dump_interface_table (vat_main_t * vam)
5559 name_sort_t *nses = 0, *ns;
5561 if (vam->json_output)
5564 ("JSON output supported only for VPE API calls and dump_stats_table");
5569 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5571 vec_add2 (nses, ns, 1);
5572 ns->name = (u8 *)(p->key);
5573 ns->value = (u32) p->value[0];
5577 vec_sort_with_function (nses, name_sort_cmp);
5579 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5580 vec_foreach (ns, nses)
5582 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5589 dump_ip_table (vat_main_t * vam, int is_ipv6)
5591 const ip_details_t *det = NULL;
5592 const ip_address_details_t *address = NULL;
5595 print (vam->ofp, "%-12s", "sw_if_index");
5597 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5604 print (vam->ofp, "%-12d", i);
5605 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5610 vec_foreach (address, det->addr)
5614 is_ipv6 ? format_ip6_address : format_ip4_address,
5615 address->ip, address->prefix_length);
5623 dump_ipv4_table (vat_main_t * vam)
5625 if (vam->json_output)
5628 ("JSON output supported only for VPE API calls and dump_stats_table");
5632 return dump_ip_table (vam, 0);
5636 dump_ipv6_table (vat_main_t * vam)
5638 if (vam->json_output)
5641 ("JSON output supported only for VPE API calls and dump_stats_table");
5645 return dump_ip_table (vam, 1);
5649 * Pass CLI buffers directly in the CLI_INBAND API message,
5650 * instead of an additional shared memory area.
5653 exec_inband (vat_main_t * vam)
5655 vl_api_cli_inband_t *mp;
5656 unformat_input_t *i = vam->input;
5659 if (vec_len (i->buffer) == 0)
5662 if (vam->exec_mode == 0 && unformat (i, "mode"))
5667 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5674 * In order for the CLI command to work, it
5675 * must be a vector ending in \n, not a C-string ending
5678 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
5679 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
5683 /* json responses may or may not include a useful reply... */
5684 if (vec_len (vam->cmd_reply))
5685 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5690 exec (vat_main_t * vam)
5692 return exec_inband (vam);
5696 api_create_loopback (vat_main_t * vam)
5698 unformat_input_t *i = vam->input;
5699 vl_api_create_loopback_t *mp;
5700 vl_api_create_loopback_instance_t *mp_lbi;
5703 u8 is_specified = 0;
5704 u32 user_instance = 0;
5707 clib_memset (mac_address, 0, sizeof (mac_address));
5709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5711 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5713 if (unformat (i, "instance %d", &user_instance))
5721 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5722 mp_lbi->is_specified = is_specified;
5724 mp_lbi->user_instance = htonl (user_instance);
5726 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5731 /* Construct the API message */
5732 M (CREATE_LOOPBACK, mp);
5734 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5743 api_delete_loopback (vat_main_t * vam)
5745 unformat_input_t *i = vam->input;
5746 vl_api_delete_loopback_t *mp;
5747 u32 sw_if_index = ~0;
5750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5752 if (unformat (i, "sw_if_index %d", &sw_if_index))
5758 if (sw_if_index == ~0)
5760 errmsg ("missing sw_if_index");
5764 /* Construct the API message */
5765 M (DELETE_LOOPBACK, mp);
5766 mp->sw_if_index = ntohl (sw_if_index);
5774 api_want_interface_events (vat_main_t * vam)
5776 unformat_input_t *i = vam->input;
5777 vl_api_want_interface_events_t *mp;
5781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5783 if (unformat (i, "enable"))
5785 else if (unformat (i, "disable"))
5793 errmsg ("missing enable|disable");
5797 M (WANT_INTERFACE_EVENTS, mp);
5798 mp->enable_disable = enable;
5800 vam->interface_event_display = enable;
5808 /* Note: non-static, called once to set up the initial intfc table */
5810 api_sw_interface_dump (vat_main_t * vam)
5812 vl_api_sw_interface_dump_t *mp;
5813 vl_api_control_ping_t *mp_ping;
5815 name_sort_t *nses = 0, *ns;
5816 sw_interface_subif_t *sub = NULL;
5819 /* Toss the old name table */
5821 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5823 vec_add2 (nses, ns, 1);
5824 ns->name = (u8 *)(p->key);
5825 ns->value = (u32) p->value[0];
5829 hash_free (vam->sw_if_index_by_interface_name);
5831 vec_foreach (ns, nses) vec_free (ns->name);
5835 vec_foreach (sub, vam->sw_if_subif_table)
5837 vec_free (sub->interface_name);
5839 vec_free (vam->sw_if_subif_table);
5841 /* recreate the interface name hash table */
5842 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5845 * Ask for all interface names. Otherwise, the epic catalog of
5846 * name filters becomes ridiculously long, and vat ends up needing
5847 * to be taught about new interface types.
5849 M (SW_INTERFACE_DUMP, mp);
5852 /* Use a control ping for synchronization */
5853 MPING (CONTROL_PING, mp_ping);
5861 api_sw_interface_set_flags (vat_main_t * vam)
5863 unformat_input_t *i = vam->input;
5864 vl_api_sw_interface_set_flags_t *mp;
5866 u8 sw_if_index_set = 0;
5870 /* Parse args required to build the message */
5871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5873 if (unformat (i, "admin-up"))
5875 else if (unformat (i, "admin-down"))
5878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5879 sw_if_index_set = 1;
5880 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5881 sw_if_index_set = 1;
5886 if (sw_if_index_set == 0)
5888 errmsg ("missing interface name or sw_if_index");
5892 /* Construct the API message */
5893 M (SW_INTERFACE_SET_FLAGS, mp);
5894 mp->sw_if_index = ntohl (sw_if_index);
5895 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5900 /* Wait for a reply, return the good/bad news... */
5906 api_sw_interface_set_rx_mode (vat_main_t * vam)
5908 unformat_input_t *i = vam->input;
5909 vl_api_sw_interface_set_rx_mode_t *mp;
5911 u8 sw_if_index_set = 0;
5913 u8 queue_id_valid = 0;
5915 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5917 /* Parse args required to build the message */
5918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5920 if (unformat (i, "queue %d", &queue_id))
5922 else if (unformat (i, "polling"))
5923 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5924 else if (unformat (i, "interrupt"))
5925 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5926 else if (unformat (i, "adaptive"))
5927 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5929 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5930 sw_if_index_set = 1;
5931 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5932 sw_if_index_set = 1;
5937 if (sw_if_index_set == 0)
5939 errmsg ("missing interface name or sw_if_index");
5942 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5944 errmsg ("missing rx-mode");
5948 /* Construct the API message */
5949 M (SW_INTERFACE_SET_RX_MODE, mp);
5950 mp->sw_if_index = ntohl (sw_if_index);
5951 mp->mode = (vl_api_rx_mode_t) mode;
5952 mp->queue_id_valid = queue_id_valid;
5953 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5958 /* Wait for a reply, return the good/bad news... */
5964 api_sw_interface_set_rx_placement (vat_main_t * vam)
5966 unformat_input_t *i = vam->input;
5967 vl_api_sw_interface_set_rx_placement_t *mp;
5969 u8 sw_if_index_set = 0;
5972 u32 queue_id, thread_index;
5974 /* Parse args required to build the message */
5975 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5977 if (unformat (i, "queue %d", &queue_id))
5979 else if (unformat (i, "main"))
5981 else if (unformat (i, "worker %d", &thread_index))
5984 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5985 sw_if_index_set = 1;
5986 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5987 sw_if_index_set = 1;
5992 if (sw_if_index_set == 0)
5994 errmsg ("missing interface name or sw_if_index");
6000 /* Construct the API message */
6001 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6002 mp->sw_if_index = ntohl (sw_if_index);
6003 mp->worker_id = ntohl (thread_index);
6004 mp->queue_id = ntohl (queue_id);
6005 mp->is_main = is_main;
6009 /* Wait for a reply, return the good/bad news... */
6014 static void vl_api_sw_interface_rx_placement_details_t_handler
6015 (vl_api_sw_interface_rx_placement_details_t * mp)
6017 vat_main_t *vam = &vat_main;
6018 u32 worker_id = ntohl (mp->worker_id);
6021 "\n%-11d %-11s %-6d %-5d %-9s",
6022 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6023 worker_id, ntohl (mp->queue_id),
6025 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6028 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6029 (vl_api_sw_interface_rx_placement_details_t * mp)
6031 vat_main_t *vam = &vat_main;
6032 vat_json_node_t *node = NULL;
6034 if (VAT_JSON_ARRAY != vam->json_tree.type)
6036 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6037 vat_json_init_array (&vam->json_tree);
6039 node = vat_json_array_add (&vam->json_tree);
6041 vat_json_init_object (node);
6042 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6043 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6044 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6045 vat_json_object_add_uint (node, "mode", mp->mode);
6049 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6051 unformat_input_t *i = vam->input;
6052 vl_api_sw_interface_rx_placement_dump_t *mp;
6053 vl_api_control_ping_t *mp_ping;
6056 u8 sw_if_index_set = 0;
6058 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6060 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6062 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6069 "\n%-11s %-11s %-6s %-5s %-4s",
6070 "sw_if_index", "main/worker", "thread", "queue", "mode");
6072 /* Dump Interface rx placement */
6073 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6075 if (sw_if_index_set)
6076 mp->sw_if_index = htonl (sw_if_index);
6078 mp->sw_if_index = ~0;
6082 /* Use a control ping for synchronization */
6083 MPING (CONTROL_PING, mp_ping);
6091 api_sw_interface_clear_stats (vat_main_t * vam)
6093 unformat_input_t *i = vam->input;
6094 vl_api_sw_interface_clear_stats_t *mp;
6096 u8 sw_if_index_set = 0;
6099 /* Parse args required to build the message */
6100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6102 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6103 sw_if_index_set = 1;
6104 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6105 sw_if_index_set = 1;
6110 /* Construct the API message */
6111 M (SW_INTERFACE_CLEAR_STATS, mp);
6113 if (sw_if_index_set == 1)
6114 mp->sw_if_index = ntohl (sw_if_index);
6116 mp->sw_if_index = ~0;
6121 /* Wait for a reply, return the good/bad news... */
6127 api_sw_interface_add_del_address (vat_main_t * vam)
6129 unformat_input_t *i = vam->input;
6130 vl_api_sw_interface_add_del_address_t *mp;
6132 u8 sw_if_index_set = 0;
6133 u8 is_add = 1, del_all = 0;
6134 u32 address_length = 0;
6135 u8 v4_address_set = 0;
6136 u8 v6_address_set = 0;
6137 ip4_address_t v4address;
6138 ip6_address_t v6address;
6141 /* Parse args required to build the message */
6142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6144 if (unformat (i, "del-all"))
6146 else if (unformat (i, "del"))
6149 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6150 sw_if_index_set = 1;
6151 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6152 sw_if_index_set = 1;
6153 else if (unformat (i, "%U/%d",
6154 unformat_ip4_address, &v4address, &address_length))
6156 else if (unformat (i, "%U/%d",
6157 unformat_ip6_address, &v6address, &address_length))
6163 if (sw_if_index_set == 0)
6165 errmsg ("missing interface name or sw_if_index");
6168 if (v4_address_set && v6_address_set)
6170 errmsg ("both v4 and v6 addresses set");
6173 if (!v4_address_set && !v6_address_set && !del_all)
6175 errmsg ("no addresses set");
6179 /* Construct the API message */
6180 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6182 mp->sw_if_index = ntohl (sw_if_index);
6183 mp->is_add = is_add;
6184 mp->del_all = del_all;
6187 mp->prefix.address.af = ADDRESS_IP6;
6188 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6192 mp->prefix.address.af = ADDRESS_IP4;
6193 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6195 mp->prefix.len = address_length;
6200 /* Wait for a reply, return good/bad news */
6206 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6208 unformat_input_t *i = vam->input;
6209 vl_api_sw_interface_set_mpls_enable_t *mp;
6211 u8 sw_if_index_set = 0;
6215 /* Parse args required to build the message */
6216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6218 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6219 sw_if_index_set = 1;
6220 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6221 sw_if_index_set = 1;
6222 else if (unformat (i, "disable"))
6224 else if (unformat (i, "dis"))
6230 if (sw_if_index_set == 0)
6232 errmsg ("missing interface name or sw_if_index");
6236 /* Construct the API message */
6237 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6239 mp->sw_if_index = ntohl (sw_if_index);
6240 mp->enable = enable;
6245 /* Wait for a reply... */
6251 api_sw_interface_set_table (vat_main_t * vam)
6253 unformat_input_t *i = vam->input;
6254 vl_api_sw_interface_set_table_t *mp;
6255 u32 sw_if_index, vrf_id = 0;
6256 u8 sw_if_index_set = 0;
6260 /* Parse args required to build the message */
6261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6263 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6264 sw_if_index_set = 1;
6265 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6266 sw_if_index_set = 1;
6267 else if (unformat (i, "vrf %d", &vrf_id))
6269 else if (unformat (i, "ipv6"))
6275 if (sw_if_index_set == 0)
6277 errmsg ("missing interface name or sw_if_index");
6281 /* Construct the API message */
6282 M (SW_INTERFACE_SET_TABLE, mp);
6284 mp->sw_if_index = ntohl (sw_if_index);
6285 mp->is_ipv6 = is_ipv6;
6286 mp->vrf_id = ntohl (vrf_id);
6291 /* Wait for a reply... */
6296 static void vl_api_sw_interface_get_table_reply_t_handler
6297 (vl_api_sw_interface_get_table_reply_t * mp)
6299 vat_main_t *vam = &vat_main;
6301 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6303 vam->retval = ntohl (mp->retval);
6304 vam->result_ready = 1;
6308 static void vl_api_sw_interface_get_table_reply_t_handler_json
6309 (vl_api_sw_interface_get_table_reply_t * mp)
6311 vat_main_t *vam = &vat_main;
6312 vat_json_node_t node;
6314 vat_json_init_object (&node);
6315 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6316 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6318 vat_json_print (vam->ofp, &node);
6319 vat_json_free (&node);
6321 vam->retval = ntohl (mp->retval);
6322 vam->result_ready = 1;
6326 api_sw_interface_get_table (vat_main_t * vam)
6328 unformat_input_t *i = vam->input;
6329 vl_api_sw_interface_get_table_t *mp;
6331 u8 sw_if_index_set = 0;
6335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6337 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6338 sw_if_index_set = 1;
6339 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6340 sw_if_index_set = 1;
6341 else if (unformat (i, "ipv6"))
6347 if (sw_if_index_set == 0)
6349 errmsg ("missing interface name or sw_if_index");
6353 M (SW_INTERFACE_GET_TABLE, mp);
6354 mp->sw_if_index = htonl (sw_if_index);
6355 mp->is_ipv6 = is_ipv6;
6363 api_sw_interface_set_vpath (vat_main_t * vam)
6365 unformat_input_t *i = vam->input;
6366 vl_api_sw_interface_set_vpath_t *mp;
6367 u32 sw_if_index = 0;
6368 u8 sw_if_index_set = 0;
6372 /* Parse args required to build the message */
6373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6375 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6376 sw_if_index_set = 1;
6377 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6378 sw_if_index_set = 1;
6379 else if (unformat (i, "enable"))
6381 else if (unformat (i, "disable"))
6387 if (sw_if_index_set == 0)
6389 errmsg ("missing interface name or sw_if_index");
6393 /* Construct the API message */
6394 M (SW_INTERFACE_SET_VPATH, mp);
6396 mp->sw_if_index = ntohl (sw_if_index);
6397 mp->enable = is_enable;
6402 /* Wait for a reply... */
6408 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6410 unformat_input_t *i = vam->input;
6411 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6412 u32 sw_if_index = 0;
6413 u8 sw_if_index_set = 0;
6418 /* Parse args required to build the message */
6419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6422 sw_if_index_set = 1;
6423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6424 sw_if_index_set = 1;
6425 else if (unformat (i, "enable"))
6427 else if (unformat (i, "disable"))
6429 else if (unformat (i, "ip4"))
6431 else if (unformat (i, "ip6"))
6437 if (sw_if_index_set == 0)
6439 errmsg ("missing interface name or sw_if_index");
6443 /* Construct the API message */
6444 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6446 mp->sw_if_index = ntohl (sw_if_index);
6447 mp->enable = is_enable;
6448 mp->is_ipv6 = is_ipv6;
6453 /* Wait for a reply... */
6459 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6461 unformat_input_t *i = vam->input;
6462 vl_api_sw_interface_set_geneve_bypass_t *mp;
6463 u32 sw_if_index = 0;
6464 u8 sw_if_index_set = 0;
6469 /* Parse args required to build the message */
6470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6472 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6473 sw_if_index_set = 1;
6474 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6475 sw_if_index_set = 1;
6476 else if (unformat (i, "enable"))
6478 else if (unformat (i, "disable"))
6480 else if (unformat (i, "ip4"))
6482 else if (unformat (i, "ip6"))
6488 if (sw_if_index_set == 0)
6490 errmsg ("missing interface name or sw_if_index");
6494 /* Construct the API message */
6495 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6497 mp->sw_if_index = ntohl (sw_if_index);
6498 mp->enable = is_enable;
6499 mp->is_ipv6 = is_ipv6;
6504 /* Wait for a reply... */
6510 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6512 unformat_input_t *i = vam->input;
6513 vl_api_sw_interface_set_l2_xconnect_t *mp;
6515 u8 rx_sw_if_index_set = 0;
6517 u8 tx_sw_if_index_set = 0;
6521 /* Parse args required to build the message */
6522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6524 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6525 rx_sw_if_index_set = 1;
6526 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6527 tx_sw_if_index_set = 1;
6528 else if (unformat (i, "rx"))
6530 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6532 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6534 rx_sw_if_index_set = 1;
6539 else if (unformat (i, "tx"))
6541 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6543 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6545 tx_sw_if_index_set = 1;
6550 else if (unformat (i, "enable"))
6552 else if (unformat (i, "disable"))
6558 if (rx_sw_if_index_set == 0)
6560 errmsg ("missing rx interface name or rx_sw_if_index");
6564 if (enable && (tx_sw_if_index_set == 0))
6566 errmsg ("missing tx interface name or tx_sw_if_index");
6570 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6572 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6573 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6574 mp->enable = enable;
6582 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6584 unformat_input_t *i = vam->input;
6585 vl_api_sw_interface_set_l2_bridge_t *mp;
6586 vl_api_l2_port_type_t port_type;
6588 u8 rx_sw_if_index_set = 0;
6595 port_type = L2_API_PORT_TYPE_NORMAL;
6597 /* Parse args required to build the message */
6598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6600 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6601 rx_sw_if_index_set = 1;
6602 else if (unformat (i, "bd_id %d", &bd_id))
6606 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6607 rx_sw_if_index_set = 1;
6608 else if (unformat (i, "shg %d", &shg))
6610 else if (unformat (i, "bvi"))
6611 port_type = L2_API_PORT_TYPE_BVI;
6612 else if (unformat (i, "uu-fwd"))
6613 port_type = L2_API_PORT_TYPE_UU_FWD;
6614 else if (unformat (i, "enable"))
6616 else if (unformat (i, "disable"))
6622 if (rx_sw_if_index_set == 0)
6624 errmsg ("missing rx interface name or sw_if_index");
6628 if (enable && (bd_id_set == 0))
6630 errmsg ("missing bridge domain");
6634 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6636 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6637 mp->bd_id = ntohl (bd_id);
6639 mp->port_type = ntohl (port_type);
6640 mp->enable = enable;
6648 api_bridge_domain_dump (vat_main_t * vam)
6650 unformat_input_t *i = vam->input;
6651 vl_api_bridge_domain_dump_t *mp;
6652 vl_api_control_ping_t *mp_ping;
6656 /* Parse args required to build the message */
6657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6659 if (unformat (i, "bd_id %d", &bd_id))
6665 M (BRIDGE_DOMAIN_DUMP, mp);
6666 mp->bd_id = ntohl (bd_id);
6669 /* Use a control ping for synchronization */
6670 MPING (CONTROL_PING, mp_ping);
6678 api_bridge_domain_add_del (vat_main_t * vam)
6680 unformat_input_t *i = vam->input;
6681 vl_api_bridge_domain_add_del_t *mp;
6684 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6689 /* Parse args required to build the message */
6690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6692 if (unformat (i, "bd_id %d", &bd_id))
6694 else if (unformat (i, "flood %d", &flood))
6696 else if (unformat (i, "uu-flood %d", &uu_flood))
6698 else if (unformat (i, "forward %d", &forward))
6700 else if (unformat (i, "learn %d", &learn))
6702 else if (unformat (i, "arp-term %d", &arp_term))
6704 else if (unformat (i, "mac-age %d", &mac_age))
6706 else if (unformat (i, "bd-tag %s", &bd_tag))
6708 else if (unformat (i, "del"))
6711 flood = uu_flood = forward = learn = 0;
6719 errmsg ("missing bridge domain");
6726 errmsg ("mac age must be less than 256 ");
6731 if ((bd_tag) && (vec_len (bd_tag) > 63))
6733 errmsg ("bd-tag cannot be longer than 63");
6738 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6740 mp->bd_id = ntohl (bd_id);
6742 mp->uu_flood = uu_flood;
6743 mp->forward = forward;
6745 mp->arp_term = arp_term;
6746 mp->is_add = is_add;
6747 mp->mac_age = (u8) mac_age;
6750 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6751 mp->bd_tag[vec_len (bd_tag)] = 0;
6762 api_l2fib_flush_bd (vat_main_t * vam)
6764 unformat_input_t *i = vam->input;
6765 vl_api_l2fib_flush_bd_t *mp;
6769 /* Parse args required to build the message */
6770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6772 if (unformat (i, "bd_id %d", &bd_id));
6779 errmsg ("missing bridge domain");
6783 M (L2FIB_FLUSH_BD, mp);
6785 mp->bd_id = htonl (bd_id);
6793 api_l2fib_flush_int (vat_main_t * vam)
6795 unformat_input_t *i = vam->input;
6796 vl_api_l2fib_flush_int_t *mp;
6797 u32 sw_if_index = ~0;
6800 /* Parse args required to build the message */
6801 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6803 if (unformat (i, "sw_if_index %d", &sw_if_index));
6805 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6810 if (sw_if_index == ~0)
6812 errmsg ("missing interface name or sw_if_index");
6816 M (L2FIB_FLUSH_INT, mp);
6818 mp->sw_if_index = ntohl (sw_if_index);
6826 api_l2fib_add_del (vat_main_t * vam)
6828 unformat_input_t *i = vam->input;
6829 vl_api_l2fib_add_del_t *mp;
6835 u32 sw_if_index = 0;
6836 u8 sw_if_index_set = 0;
6845 /* Parse args required to build the message */
6846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6848 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6850 else if (unformat (i, "bd_id %d", &bd_id))
6852 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6853 sw_if_index_set = 1;
6854 else if (unformat (i, "sw_if"))
6856 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6859 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6860 sw_if_index_set = 1;
6865 else if (unformat (i, "static"))
6867 else if (unformat (i, "filter"))
6872 else if (unformat (i, "bvi"))
6877 else if (unformat (i, "del"))
6879 else if (unformat (i, "count %d", &count))
6887 errmsg ("missing mac address");
6893 errmsg ("missing bridge domain");
6897 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6899 errmsg ("missing interface name or sw_if_index");
6905 /* Turn on async mode */
6906 vam->async_mode = 1;
6907 vam->async_errors = 0;
6908 before = vat_time_now (vam);
6911 for (j = 0; j < count; j++)
6913 M (L2FIB_ADD_DEL, mp);
6915 clib_memcpy (mp->mac, mac, 6);
6916 mp->bd_id = ntohl (bd_id);
6917 mp->is_add = is_add;
6918 mp->sw_if_index = ntohl (sw_if_index);
6922 mp->static_mac = static_mac;
6923 mp->filter_mac = filter_mac;
6924 mp->bvi_mac = bvi_mac;
6926 increment_mac_address (mac);
6933 vl_api_control_ping_t *mp_ping;
6936 /* Shut off async mode */
6937 vam->async_mode = 0;
6939 MPING (CONTROL_PING, mp_ping);
6942 timeout = vat_time_now (vam) + 1.0;
6943 while (vat_time_now (vam) < timeout)
6944 if (vam->result_ready == 1)
6949 if (vam->retval == -99)
6952 if (vam->async_errors > 0)
6954 errmsg ("%d asynchronous errors", vam->async_errors);
6957 vam->async_errors = 0;
6958 after = vat_time_now (vam);
6960 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6961 count, after - before, count / (after - before));
6967 /* Wait for a reply... */
6971 /* Return the good/bad news */
6972 return (vam->retval);
6976 api_bridge_domain_set_mac_age (vat_main_t * vam)
6978 unformat_input_t *i = vam->input;
6979 vl_api_bridge_domain_set_mac_age_t *mp;
6984 /* Parse args required to build the message */
6985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6987 if (unformat (i, "bd_id %d", &bd_id));
6988 else if (unformat (i, "mac-age %d", &mac_age));
6995 errmsg ("missing bridge domain");
7001 errmsg ("mac age must be less than 256 ");
7005 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7007 mp->bd_id = htonl (bd_id);
7008 mp->mac_age = (u8) mac_age;
7016 api_l2_flags (vat_main_t * vam)
7018 unformat_input_t *i = vam->input;
7019 vl_api_l2_flags_t *mp;
7022 u8 sw_if_index_set = 0;
7026 /* Parse args required to build the message */
7027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7029 if (unformat (i, "sw_if_index %d", &sw_if_index))
7030 sw_if_index_set = 1;
7031 else if (unformat (i, "sw_if"))
7033 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7036 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7037 sw_if_index_set = 1;
7042 else if (unformat (i, "learn"))
7044 else if (unformat (i, "forward"))
7046 else if (unformat (i, "flood"))
7048 else if (unformat (i, "uu-flood"))
7049 flags |= L2_UU_FLOOD;
7050 else if (unformat (i, "arp-term"))
7051 flags |= L2_ARP_TERM;
7052 else if (unformat (i, "off"))
7054 else if (unformat (i, "disable"))
7060 if (sw_if_index_set == 0)
7062 errmsg ("missing interface name or sw_if_index");
7068 mp->sw_if_index = ntohl (sw_if_index);
7069 mp->feature_bitmap = ntohl (flags);
7070 mp->is_set = is_set;
7078 api_bridge_flags (vat_main_t * vam)
7080 unformat_input_t *i = vam->input;
7081 vl_api_bridge_flags_t *mp;
7085 bd_flags_t flags = 0;
7088 /* Parse args required to build the message */
7089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7091 if (unformat (i, "bd_id %d", &bd_id))
7093 else if (unformat (i, "learn"))
7094 flags |= BRIDGE_API_FLAG_LEARN;
7095 else if (unformat (i, "forward"))
7096 flags |= BRIDGE_API_FLAG_FWD;
7097 else if (unformat (i, "flood"))
7098 flags |= BRIDGE_API_FLAG_FLOOD;
7099 else if (unformat (i, "uu-flood"))
7100 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7101 else if (unformat (i, "arp-term"))
7102 flags |= BRIDGE_API_FLAG_ARP_TERM;
7103 else if (unformat (i, "off"))
7105 else if (unformat (i, "disable"))
7113 errmsg ("missing bridge domain");
7117 M (BRIDGE_FLAGS, mp);
7119 mp->bd_id = ntohl (bd_id);
7120 mp->flags = ntohl (flags);
7121 mp->is_set = is_set;
7129 api_bd_ip_mac_add_del (vat_main_t * vam)
7131 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7132 vl_api_mac_address_t mac = { 0 };
7133 unformat_input_t *i = vam->input;
7134 vl_api_bd_ip_mac_add_del_t *mp;
7143 /* Parse args required to build the message */
7144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7146 if (unformat (i, "bd_id %d", &bd_id))
7150 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7154 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7158 else if (unformat (i, "del"))
7166 errmsg ("missing bridge domain");
7169 else if (ip_set == 0)
7171 errmsg ("missing IP address");
7174 else if (mac_set == 0)
7176 errmsg ("missing MAC address");
7180 M (BD_IP_MAC_ADD_DEL, mp);
7182 mp->entry.bd_id = ntohl (bd_id);
7183 mp->is_add = is_add;
7185 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7186 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7194 api_bd_ip_mac_flush (vat_main_t * vam)
7196 unformat_input_t *i = vam->input;
7197 vl_api_bd_ip_mac_flush_t *mp;
7202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7204 if (unformat (i, "bd_id %d", &bd_id))
7214 errmsg ("missing bridge domain");
7218 M (BD_IP_MAC_FLUSH, mp);
7220 mp->bd_id = ntohl (bd_id);
7227 static void vl_api_bd_ip_mac_details_t_handler
7228 (vl_api_bd_ip_mac_details_t * mp)
7230 vat_main_t *vam = &vat_main;
7234 ntohl (mp->entry.bd_id),
7235 format_vl_api_mac_address, mp->entry.mac,
7236 format_vl_api_address, &mp->entry.ip);
7239 static void vl_api_bd_ip_mac_details_t_handler_json
7240 (vl_api_bd_ip_mac_details_t * mp)
7242 vat_main_t *vam = &vat_main;
7243 vat_json_node_t *node = NULL;
7245 if (VAT_JSON_ARRAY != vam->json_tree.type)
7247 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7248 vat_json_init_array (&vam->json_tree);
7250 node = vat_json_array_add (&vam->json_tree);
7252 vat_json_init_object (node);
7253 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7254 vat_json_object_add_string_copy (node, "mac_address",
7255 format (0, "%U", format_vl_api_mac_address,
7259 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7260 vat_json_object_add_string_copy (node, "ip_address", ip);
7265 api_bd_ip_mac_dump (vat_main_t * vam)
7267 unformat_input_t *i = vam->input;
7268 vl_api_bd_ip_mac_dump_t *mp;
7269 vl_api_control_ping_t *mp_ping;
7274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7276 if (unformat (i, "bd_id %d", &bd_id))
7285 "\n%-5s %-7s %-20s %-30s",
7286 "bd_id", "is_ipv6", "mac_address", "ip_address");
7288 /* Dump Bridge Domain Ip to Mac entries */
7289 M (BD_IP_MAC_DUMP, mp);
7292 mp->bd_id = htonl (bd_id);
7298 /* Use a control ping for synchronization */
7299 MPING (CONTROL_PING, mp_ping);
7307 api_tap_create_v2 (vat_main_t * vam)
7309 unformat_input_t *i = vam->input;
7310 vl_api_tap_create_v2_t *mp;
7314 u32 num_rx_queues = 0;
7315 u8 *host_if_name = 0;
7316 u8 host_if_name_set = 0;
7319 u8 host_mac_addr[6];
7320 u8 host_mac_addr_set = 0;
7321 u8 *host_bridge = 0;
7322 u8 host_bridge_set = 0;
7323 u8 host_ip4_prefix_set = 0;
7324 u8 host_ip6_prefix_set = 0;
7325 ip4_address_t host_ip4_addr;
7326 ip4_address_t host_ip4_gw;
7327 u8 host_ip4_gw_set = 0;
7328 u32 host_ip4_prefix_len = 0;
7329 ip6_address_t host_ip6_addr;
7330 ip6_address_t host_ip6_gw;
7331 u8 host_ip6_gw_set = 0;
7332 u32 host_ip6_prefix_len = 0;
7333 u32 host_mtu_size = 0;
7334 u8 host_mtu_set = 0;
7337 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7339 clib_memset (mac_address, 0, sizeof (mac_address));
7341 /* Parse args required to build the message */
7342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7344 if (unformat (i, "id %u", &id))
7348 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7350 else if (unformat (i, "host-if-name %s", &host_if_name))
7351 host_if_name_set = 1;
7352 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
7354 else if (unformat (i, "host-ns %s", &host_ns))
7356 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7358 host_mac_addr_set = 1;
7359 else if (unformat (i, "host-bridge %s", &host_bridge))
7360 host_bridge_set = 1;
7361 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
7362 &host_ip4_addr, &host_ip4_prefix_len))
7363 host_ip4_prefix_set = 1;
7364 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
7365 &host_ip6_addr, &host_ip6_prefix_len))
7366 host_ip6_prefix_set = 1;
7367 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7369 host_ip4_gw_set = 1;
7370 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7372 host_ip6_gw_set = 1;
7373 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7375 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7377 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
7379 else if (unformat (i, "no-gso"))
7380 tap_flags &= ~TAP_API_FLAG_GSO;
7381 else if (unformat (i, "gso"))
7382 tap_flags |= TAP_API_FLAG_GSO;
7383 else if (unformat (i, "csum-offload"))
7384 tap_flags |= TAP_API_FLAG_CSUM_OFFLOAD;
7385 else if (unformat (i, "persist"))
7386 tap_flags |= TAP_API_FLAG_PERSIST;
7387 else if (unformat (i, "attach"))
7388 tap_flags |= TAP_API_FLAG_ATTACH;
7389 else if (unformat (i, "tun"))
7390 tap_flags |= TAP_API_FLAG_TUN;
7391 else if (unformat (i, "gro-coalesce"))
7392 tap_flags |= TAP_API_FLAG_GRO_COALESCE;
7393 else if (unformat (i, "packed"))
7394 tap_flags |= TAP_API_FLAG_PACKED;
7395 else if (unformat (i, "in-order"))
7396 tap_flags |= TAP_API_FLAG_IN_ORDER;
7401 if (vec_len (host_if_name) > 63)
7403 errmsg ("tap name too long. ");
7406 if (vec_len (host_ns) > 63)
7408 errmsg ("host name space too long. ");
7411 if (vec_len (host_bridge) > 63)
7413 errmsg ("host bridge name too long. ");
7416 if (host_ip4_prefix_len > 32)
7418 errmsg ("host ip4 prefix length not valid. ");
7421 if (host_ip6_prefix_len > 128)
7423 errmsg ("host ip6 prefix length not valid. ");
7426 if (!is_pow2 (rx_ring_sz))
7428 errmsg ("rx ring size must be power of 2. ");
7431 if (rx_ring_sz > 32768)
7433 errmsg ("rx ring size must be 32768 or lower. ");
7436 if (!is_pow2 (tx_ring_sz))
7438 errmsg ("tx ring size must be power of 2. ");
7441 if (tx_ring_sz > 32768)
7443 errmsg ("tx ring size must be 32768 or lower. ");
7446 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7448 errmsg ("host MTU size must be in between 64 and 65355. ");
7452 /* Construct the API message */
7453 M (TAP_CREATE_V2, mp);
7455 mp->id = ntohl (id);
7456 mp->use_random_mac = random_mac;
7457 mp->num_rx_queues = (u8) num_rx_queues;
7458 mp->tx_ring_sz = ntohs (tx_ring_sz);
7459 mp->rx_ring_sz = ntohs (rx_ring_sz);
7460 mp->host_mtu_set = host_mtu_set;
7461 mp->host_mtu_size = ntohl (host_mtu_size);
7462 mp->host_mac_addr_set = host_mac_addr_set;
7463 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7464 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7465 mp->host_ip4_gw_set = host_ip4_gw_set;
7466 mp->host_ip6_gw_set = host_ip6_gw_set;
7467 mp->tap_flags = ntohl (tap_flags);
7468 mp->host_namespace_set = host_ns_set;
7469 mp->host_if_name_set = host_if_name_set;
7470 mp->host_bridge_set = host_bridge_set;
7472 if (random_mac == 0)
7473 clib_memcpy (mp->mac_address, mac_address, 6);
7474 if (host_mac_addr_set)
7475 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7476 if (host_if_name_set)
7477 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7479 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7480 if (host_bridge_set)
7481 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7482 if (host_ip4_prefix_set)
7484 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7485 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7487 if (host_ip6_prefix_set)
7489 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7490 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7492 if (host_ip4_gw_set)
7493 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7494 if (host_ip6_gw_set)
7495 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7498 vec_free (host_if_name);
7499 vec_free (host_bridge);
7504 /* Wait for a reply... */
7510 api_tap_delete_v2 (vat_main_t * vam)
7512 unformat_input_t *i = vam->input;
7513 vl_api_tap_delete_v2_t *mp;
7514 u32 sw_if_index = ~0;
7515 u8 sw_if_index_set = 0;
7518 /* Parse args required to build the message */
7519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7521 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7522 sw_if_index_set = 1;
7523 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7524 sw_if_index_set = 1;
7529 if (sw_if_index_set == 0)
7531 errmsg ("missing vpp interface name. ");
7535 /* Construct the API message */
7536 M (TAP_DELETE_V2, mp);
7538 mp->sw_if_index = ntohl (sw_if_index);
7543 /* Wait for a reply... */
7549 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7551 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7554 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7557 addr->domain = x[0];
7560 addr->function = x[3];
7566 api_virtio_pci_create (vat_main_t * vam)
7568 unformat_input_t *i = vam->input;
7569 vl_api_virtio_pci_create_t *mp;
7573 u8 checksum_offload_enabled = 0;
7575 u64 features = (u64) ~ (0ULL);
7578 clib_memset (mac_address, 0, sizeof (mac_address));
7580 /* Parse args required to build the message */
7581 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7583 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7587 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7589 else if (unformat (i, "features 0x%llx", &features))
7591 else if (unformat (i, "gso-enabled"))
7593 else if (unformat (i, "csum-offload-enabled"))
7594 checksum_offload_enabled = 1;
7601 errmsg ("pci address must be non zero. ");
7605 /* Construct the API message */
7606 M (VIRTIO_PCI_CREATE, mp);
7608 mp->use_random_mac = random_mac;
7610 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7611 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7612 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7613 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7615 mp->features = clib_host_to_net_u64 (features);
7616 mp->gso_enabled = gso_enabled;
7617 mp->checksum_offload_enabled = checksum_offload_enabled;
7619 if (random_mac == 0)
7620 clib_memcpy (mp->mac_address, mac_address, 6);
7625 /* Wait for a reply... */
7631 api_virtio_pci_delete (vat_main_t * vam)
7633 unformat_input_t *i = vam->input;
7634 vl_api_virtio_pci_delete_t *mp;
7635 u32 sw_if_index = ~0;
7636 u8 sw_if_index_set = 0;
7639 /* Parse args required to build the message */
7640 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7642 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7643 sw_if_index_set = 1;
7644 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7645 sw_if_index_set = 1;
7650 if (sw_if_index_set == 0)
7652 errmsg ("missing vpp interface name. ");
7656 /* Construct the API message */
7657 M (VIRTIO_PCI_DELETE, mp);
7659 mp->sw_if_index = htonl (sw_if_index);
7664 /* Wait for a reply... */
7670 api_bond_create (vat_main_t * vam)
7672 unformat_input_t *i = vam->input;
7673 vl_api_bond_create_t *mp;
7683 clib_memset (mac_address, 0, sizeof (mac_address));
7686 /* Parse args required to build the message */
7687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7689 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7691 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7692 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7694 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7697 else if (unformat (i, "numa-only"))
7699 else if (unformat (i, "id %u", &id))
7705 if (mode_is_set == 0)
7707 errmsg ("Missing bond mode. ");
7711 /* Construct the API message */
7712 M (BOND_CREATE, mp);
7714 mp->use_custom_mac = custom_mac;
7716 mp->mode = htonl (mode);
7717 mp->lb = htonl (lb);
7718 mp->id = htonl (id);
7719 mp->numa_only = numa_only;
7722 clib_memcpy (mp->mac_address, mac_address, 6);
7727 /* Wait for a reply... */
7733 api_bond_delete (vat_main_t * vam)
7735 unformat_input_t *i = vam->input;
7736 vl_api_bond_delete_t *mp;
7737 u32 sw_if_index = ~0;
7738 u8 sw_if_index_set = 0;
7741 /* Parse args required to build the message */
7742 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7744 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7745 sw_if_index_set = 1;
7746 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7747 sw_if_index_set = 1;
7752 if (sw_if_index_set == 0)
7754 errmsg ("missing vpp interface name. ");
7758 /* Construct the API message */
7759 M (BOND_DELETE, mp);
7761 mp->sw_if_index = ntohl (sw_if_index);
7766 /* Wait for a reply... */
7772 api_bond_add_member (vat_main_t * vam)
7774 unformat_input_t *i = vam->input;
7775 vl_api_bond_add_member_t *mp;
7776 u32 bond_sw_if_index;
7780 u32 bond_sw_if_index_is_set = 0;
7782 u8 sw_if_index_is_set = 0;
7784 /* Parse args required to build the message */
7785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7787 if (unformat (i, "sw_if_index %d", &sw_if_index))
7788 sw_if_index_is_set = 1;
7789 else if (unformat (i, "bond %u", &bond_sw_if_index))
7790 bond_sw_if_index_is_set = 1;
7791 else if (unformat (i, "passive %d", &is_passive))
7793 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7799 if (bond_sw_if_index_is_set == 0)
7801 errmsg ("Missing bond sw_if_index. ");
7804 if (sw_if_index_is_set == 0)
7806 errmsg ("Missing member sw_if_index. ");
7810 /* Construct the API message */
7811 M (BOND_ADD_MEMBER, mp);
7813 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7814 mp->sw_if_index = ntohl (sw_if_index);
7815 mp->is_long_timeout = is_long_timeout;
7816 mp->is_passive = is_passive;
7821 /* Wait for a reply... */
7827 api_bond_detach_member (vat_main_t * vam)
7829 unformat_input_t *i = vam->input;
7830 vl_api_bond_detach_member_t *mp;
7831 u32 sw_if_index = ~0;
7832 u8 sw_if_index_set = 0;
7835 /* Parse args required to build the message */
7836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7838 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7839 sw_if_index_set = 1;
7840 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7841 sw_if_index_set = 1;
7846 if (sw_if_index_set == 0)
7848 errmsg ("missing vpp interface name. ");
7852 /* Construct the API message */
7853 M (BOND_DETACH_MEMBER, mp);
7855 mp->sw_if_index = ntohl (sw_if_index);
7860 /* Wait for a reply... */
7866 api_ip_table_add_del (vat_main_t * vam)
7868 unformat_input_t *i = vam->input;
7869 vl_api_ip_table_add_del_t *mp;
7875 /* Parse args required to build the message */
7876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7878 if (unformat (i, "ipv6"))
7880 else if (unformat (i, "del"))
7882 else if (unformat (i, "add"))
7884 else if (unformat (i, "table %d", &table_id))
7888 clib_warning ("parse error '%U'", format_unformat_error, i);
7895 errmsg ("missing table-ID");
7899 /* Construct the API message */
7900 M (IP_TABLE_ADD_DEL, mp);
7902 mp->table.table_id = ntohl (table_id);
7903 mp->table.is_ip6 = is_ipv6;
7904 mp->is_add = is_add;
7909 /* Wait for a reply... */
7916 unformat_fib_path (unformat_input_t * input, va_list * args)
7918 vat_main_t *vam = va_arg (*args, vat_main_t *);
7919 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7920 u32 weight, preference;
7921 mpls_label_t out_label;
7923 clib_memset (path, 0, sizeof (*path));
7925 path->sw_if_index = ~0;
7929 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7931 if (unformat (input, "%U %U",
7932 unformat_vl_api_ip4_address,
7933 &path->nh.address.ip4,
7934 api_unformat_sw_if_index, vam, &path->sw_if_index))
7936 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7938 else if (unformat (input, "%U %U",
7939 unformat_vl_api_ip6_address,
7940 &path->nh.address.ip6,
7941 api_unformat_sw_if_index, vam, &path->sw_if_index))
7943 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7945 else if (unformat (input, "weight %u", &weight))
7947 path->weight = weight;
7949 else if (unformat (input, "preference %u", &preference))
7951 path->preference = preference;
7953 else if (unformat (input, "%U next-hop-table %d",
7954 unformat_vl_api_ip4_address,
7955 &path->nh.address.ip4, &path->table_id))
7957 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7959 else if (unformat (input, "%U next-hop-table %d",
7960 unformat_vl_api_ip6_address,
7961 &path->nh.address.ip6, &path->table_id))
7963 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7965 else if (unformat (input, "%U",
7966 unformat_vl_api_ip4_address, &path->nh.address.ip4))
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_IP4;
7975 else if (unformat (input, "%U",
7976 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7979 * the recursive next-hops are by default in the default table
7982 path->sw_if_index = ~0;
7983 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7985 else if (unformat (input, "resolve-via-host"))
7987 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7989 else if (unformat (input, "resolve-via-attached"))
7991 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7993 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7995 path->type = FIB_API_PATH_TYPE_LOCAL;
7996 path->sw_if_index = ~0;
7997 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7999 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
8001 path->type = FIB_API_PATH_TYPE_LOCAL;
8002 path->sw_if_index = ~0;
8003 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8005 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
8007 else if (unformat (input, "via-label %d", &path->nh.via_label))
8009 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8010 path->sw_if_index = ~0;
8012 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8014 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8015 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8017 else if (unformat (input, "local"))
8019 path->type = FIB_API_PATH_TYPE_LOCAL;
8021 else if (unformat (input, "out-labels"))
8023 while (unformat (input, "%d", &out_label))
8025 path->label_stack[path->n_labels].label = out_label;
8026 path->label_stack[path->n_labels].is_uniform = 0;
8027 path->label_stack[path->n_labels].ttl = 64;
8031 else if (unformat (input, "via"))
8033 /* new path, back up and return */
8034 unformat_put_input (input);
8035 unformat_put_input (input);
8036 unformat_put_input (input);
8037 unformat_put_input (input);
8046 path->proto = ntohl (path->proto);
8047 path->type = ntohl (path->type);
8048 path->flags = ntohl (path->flags);
8049 path->table_id = ntohl (path->table_id);
8050 path->sw_if_index = ntohl (path->sw_if_index);
8056 api_ip_route_add_del (vat_main_t * vam)
8058 unformat_input_t *i = vam->input;
8059 vl_api_ip_route_add_del_t *mp;
8062 u8 is_multipath = 0;
8065 vl_api_prefix_t pfx = { };
8066 vl_api_fib_path_t paths[8];
8070 u32 random_add_del = 0;
8071 u32 *random_vector = 0;
8072 u32 random_seed = 0xdeaddabe;
8074 /* Parse args required to build the message */
8075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8077 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8079 else if (unformat (i, "del"))
8081 else if (unformat (i, "add"))
8083 else if (unformat (i, "vrf %d", &vrf_id))
8085 else if (unformat (i, "count %d", &count))
8087 else if (unformat (i, "random"))
8089 else if (unformat (i, "multipath"))
8091 else if (unformat (i, "seed %d", &random_seed))
8095 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8098 if (8 == path_count)
8100 errmsg ("max 8 paths");
8106 clib_warning ("parse error '%U'", format_unformat_error, i);
8113 errmsg ("specify a path; via ...");
8116 if (prefix_set == 0)
8118 errmsg ("missing prefix");
8122 /* Generate a pile of unique, random routes */
8125 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8126 u32 this_random_address;
8129 random_hash = hash_create (count, sizeof (uword));
8131 hash_set (random_hash, i->as_u32, 1);
8132 for (j = 0; j <= count; j++)
8136 this_random_address = random_u32 (&random_seed);
8137 this_random_address =
8138 clib_host_to_net_u32 (this_random_address);
8140 while (hash_get (random_hash, this_random_address));
8141 vec_add1 (random_vector, this_random_address);
8142 hash_set (random_hash, this_random_address, 1);
8144 hash_free (random_hash);
8145 set_ip4_address (&pfx.address, random_vector[0]);
8150 /* Turn on async mode */
8151 vam->async_mode = 1;
8152 vam->async_errors = 0;
8153 before = vat_time_now (vam);
8156 for (j = 0; j < count; j++)
8158 /* Construct the API message */
8159 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8161 mp->is_add = is_add;
8162 mp->is_multipath = is_multipath;
8164 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8165 mp->route.table_id = ntohl (vrf_id);
8166 mp->route.n_paths = path_count;
8168 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8171 set_ip4_address (&pfx.address, random_vector[j + 1]);
8173 increment_address (&pfx.address);
8176 /* If we receive SIGTERM, stop now... */
8181 /* When testing multiple add/del ops, use a control-ping to sync */
8184 vl_api_control_ping_t *mp_ping;
8188 /* Shut off async mode */
8189 vam->async_mode = 0;
8191 MPING (CONTROL_PING, mp_ping);
8194 timeout = vat_time_now (vam) + 1.0;
8195 while (vat_time_now (vam) < timeout)
8196 if (vam->result_ready == 1)
8201 if (vam->retval == -99)
8204 if (vam->async_errors > 0)
8206 errmsg ("%d asynchronous errors", vam->async_errors);
8209 vam->async_errors = 0;
8210 after = vat_time_now (vam);
8212 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8216 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8217 count, after - before, count / (after - before));
8223 /* Wait for a reply... */
8228 /* Return the good/bad news */
8229 return (vam->retval);
8233 api_ip_mroute_add_del (vat_main_t * vam)
8235 unformat_input_t *i = vam->input;
8236 u8 path_set = 0, prefix_set = 0, is_add = 1;
8237 vl_api_ip_mroute_add_del_t *mp;
8238 mfib_entry_flags_t eflags = 0;
8239 vl_api_mfib_path_t path;
8240 vl_api_mprefix_t pfx = { };
8244 /* Parse args required to build the message */
8245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8247 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8250 pfx.grp_address_length = htons (pfx.grp_address_length);
8252 else if (unformat (i, "del"))
8254 else if (unformat (i, "add"))
8256 else if (unformat (i, "vrf %d", &vrf_id))
8258 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8259 path.itf_flags = htonl (path.itf_flags);
8260 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8262 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8266 clib_warning ("parse error '%U'", format_unformat_error, i);
8271 if (prefix_set == 0)
8273 errmsg ("missing addresses\n");
8278 errmsg ("missing path\n");
8282 /* Construct the API message */
8283 M (IP_MROUTE_ADD_DEL, mp);
8285 mp->is_add = is_add;
8286 mp->is_multipath = 1;
8288 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8289 mp->route.table_id = htonl (vrf_id);
8290 mp->route.n_paths = 1;
8291 mp->route.entry_flags = htonl (eflags);
8293 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8297 /* Wait for a reply... */
8303 api_mpls_table_add_del (vat_main_t * vam)
8305 unformat_input_t *i = vam->input;
8306 vl_api_mpls_table_add_del_t *mp;
8311 /* Parse args required to build the message */
8312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8314 if (unformat (i, "table %d", &table_id))
8316 else if (unformat (i, "del"))
8318 else if (unformat (i, "add"))
8322 clib_warning ("parse error '%U'", format_unformat_error, i);
8329 errmsg ("missing table-ID");
8333 /* Construct the API message */
8334 M (MPLS_TABLE_ADD_DEL, mp);
8336 mp->mt_table.mt_table_id = ntohl (table_id);
8337 mp->mt_is_add = is_add;
8342 /* Wait for a reply... */
8349 api_mpls_route_add_del (vat_main_t * vam)
8351 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8352 mpls_label_t local_label = MPLS_LABEL_INVALID;
8353 unformat_input_t *i = vam->input;
8354 vl_api_mpls_route_add_del_t *mp;
8355 vl_api_fib_path_t paths[8];
8359 /* Parse args required to build the message */
8360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8362 if (unformat (i, "%d", &local_label))
8364 else if (unformat (i, "eos"))
8366 else if (unformat (i, "non-eos"))
8368 else if (unformat (i, "del"))
8370 else if (unformat (i, "add"))
8372 else if (unformat (i, "multipath"))
8374 else if (unformat (i, "count %d", &count))
8378 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8381 if (8 == path_count)
8383 errmsg ("max 8 paths");
8389 clib_warning ("parse error '%U'", format_unformat_error, i);
8396 errmsg ("specify a path; via ...");
8400 if (MPLS_LABEL_INVALID == local_label)
8402 errmsg ("missing label");
8408 /* Turn on async mode */
8409 vam->async_mode = 1;
8410 vam->async_errors = 0;
8411 before = vat_time_now (vam);
8414 for (j = 0; j < count; j++)
8416 /* Construct the API message */
8417 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8419 mp->mr_is_add = is_add;
8420 mp->mr_is_multipath = is_multipath;
8422 mp->mr_route.mr_label = local_label;
8423 mp->mr_route.mr_eos = is_eos;
8424 mp->mr_route.mr_table_id = 0;
8425 mp->mr_route.mr_n_paths = path_count;
8427 clib_memcpy (&mp->mr_route.mr_paths, paths,
8428 sizeof (paths[0]) * path_count);
8434 /* If we receive SIGTERM, stop now... */
8439 /* When testing multiple add/del ops, use a control-ping to sync */
8442 vl_api_control_ping_t *mp_ping;
8446 /* Shut off async mode */
8447 vam->async_mode = 0;
8449 MPING (CONTROL_PING, mp_ping);
8452 timeout = vat_time_now (vam) + 1.0;
8453 while (vat_time_now (vam) < timeout)
8454 if (vam->result_ready == 1)
8459 if (vam->retval == -99)
8462 if (vam->async_errors > 0)
8464 errmsg ("%d asynchronous errors", vam->async_errors);
8467 vam->async_errors = 0;
8468 after = vat_time_now (vam);
8470 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8474 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8475 count, after - before, count / (after - before));
8481 /* Wait for a reply... */
8486 /* Return the good/bad news */
8487 return (vam->retval);
8492 api_mpls_ip_bind_unbind (vat_main_t * vam)
8494 unformat_input_t *i = vam->input;
8495 vl_api_mpls_ip_bind_unbind_t *mp;
8496 u32 ip_table_id = 0;
8498 vl_api_prefix_t pfx;
8500 mpls_label_t local_label = MPLS_LABEL_INVALID;
8503 /* Parse args required to build the message */
8504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8506 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8508 else if (unformat (i, "%d", &local_label))
8510 else if (unformat (i, "table-id %d", &ip_table_id))
8512 else if (unformat (i, "unbind"))
8514 else if (unformat (i, "bind"))
8518 clib_warning ("parse error '%U'", format_unformat_error, i);
8525 errmsg ("IP prefix not set");
8529 if (MPLS_LABEL_INVALID == local_label)
8531 errmsg ("missing label");
8535 /* Construct the API message */
8536 M (MPLS_IP_BIND_UNBIND, mp);
8538 mp->mb_is_bind = is_bind;
8539 mp->mb_ip_table_id = ntohl (ip_table_id);
8540 mp->mb_mpls_table_id = 0;
8541 mp->mb_label = ntohl (local_label);
8542 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8547 /* Wait for a reply... */
8554 api_sr_mpls_policy_add (vat_main_t * vam)
8556 unformat_input_t *i = vam->input;
8557 vl_api_sr_mpls_policy_add_t *mp;
8563 u32 *segments = NULL;
8566 /* Parse args required to build the message */
8567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8569 if (unformat (i, "bsid %d", &bsid))
8571 else if (unformat (i, "weight %d", &weight))
8573 else if (unformat (i, "spray"))
8575 else if (unformat (i, "next %d", &sid))
8578 vec_add1 (segments, htonl (sid));
8582 clib_warning ("parse error '%U'", format_unformat_error, i);
8589 errmsg ("bsid not set");
8593 if (n_segments == 0)
8595 errmsg ("no sid in segment stack");
8599 /* Construct the API message */
8600 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8602 mp->bsid = htonl (bsid);
8603 mp->weight = htonl (weight);
8604 mp->is_spray = type;
8605 mp->n_segments = n_segments;
8606 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8607 vec_free (segments);
8612 /* Wait for a reply... */
8618 api_sr_mpls_policy_del (vat_main_t * vam)
8620 unformat_input_t *i = vam->input;
8621 vl_api_sr_mpls_policy_del_t *mp;
8625 /* Parse args required to build the message */
8626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8628 if (unformat (i, "bsid %d", &bsid))
8632 clib_warning ("parse error '%U'", format_unformat_error, i);
8639 errmsg ("bsid not set");
8643 /* Construct the API message */
8644 M (SR_MPLS_POLICY_DEL, mp);
8646 mp->bsid = htonl (bsid);
8651 /* Wait for a reply... */
8657 api_bier_table_add_del (vat_main_t * vam)
8659 unformat_input_t *i = vam->input;
8660 vl_api_bier_table_add_del_t *mp;
8662 u32 set = 0, sub_domain = 0, hdr_len = 3;
8663 mpls_label_t local_label = MPLS_LABEL_INVALID;
8666 /* Parse args required to build the message */
8667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8669 if (unformat (i, "sub-domain %d", &sub_domain))
8671 else if (unformat (i, "set %d", &set))
8673 else if (unformat (i, "label %d", &local_label))
8675 else if (unformat (i, "hdr-len %d", &hdr_len))
8677 else if (unformat (i, "add"))
8679 else if (unformat (i, "del"))
8683 clib_warning ("parse error '%U'", format_unformat_error, i);
8688 if (MPLS_LABEL_INVALID == local_label)
8690 errmsg ("missing label\n");
8694 /* Construct the API message */
8695 M (BIER_TABLE_ADD_DEL, mp);
8697 mp->bt_is_add = is_add;
8698 mp->bt_label = ntohl (local_label);
8699 mp->bt_tbl_id.bt_set = set;
8700 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8701 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8706 /* Wait for a reply... */
8713 api_bier_route_add_del (vat_main_t * vam)
8715 unformat_input_t *i = vam->input;
8716 vl_api_bier_route_add_del_t *mp;
8718 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8719 ip4_address_t v4_next_hop_address;
8720 ip6_address_t v6_next_hop_address;
8721 u8 next_hop_set = 0;
8722 u8 next_hop_proto_is_ip4 = 1;
8723 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8726 /* Parse args required to build the message */
8727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8729 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8731 next_hop_proto_is_ip4 = 1;
8734 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8736 next_hop_proto_is_ip4 = 0;
8739 if (unformat (i, "sub-domain %d", &sub_domain))
8741 else if (unformat (i, "set %d", &set))
8743 else if (unformat (i, "hdr-len %d", &hdr_len))
8745 else if (unformat (i, "bp %d", &bp))
8747 else if (unformat (i, "add"))
8749 else if (unformat (i, "del"))
8751 else if (unformat (i, "out-label %d", &next_hop_out_label))
8755 clib_warning ("parse error '%U'", format_unformat_error, i);
8760 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8762 errmsg ("next hop / label set\n");
8767 errmsg ("bit=position not set\n");
8771 /* Construct the API message */
8772 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8774 mp->br_is_add = is_add;
8775 mp->br_route.br_tbl_id.bt_set = set;
8776 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8777 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8778 mp->br_route.br_bp = ntohs (bp);
8779 mp->br_route.br_n_paths = 1;
8780 mp->br_route.br_paths[0].n_labels = 1;
8781 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8782 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8783 FIB_API_PATH_NH_PROTO_IP4 :
8784 FIB_API_PATH_NH_PROTO_IP6);
8786 if (next_hop_proto_is_ip4)
8788 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8789 &v4_next_hop_address, sizeof (v4_next_hop_address));
8793 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8794 &v6_next_hop_address, sizeof (v6_next_hop_address));
8800 /* Wait for a reply... */
8807 api_mpls_tunnel_add_del (vat_main_t * vam)
8809 unformat_input_t *i = vam->input;
8810 vl_api_mpls_tunnel_add_del_t *mp;
8812 vl_api_fib_path_t paths[8];
8813 u32 sw_if_index = ~0;
8819 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8821 if (unformat (i, "add"))
8825 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8827 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8829 else if (unformat (i, "l2-only"))
8833 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8836 if (8 == path_count)
8838 errmsg ("max 8 paths");
8844 clib_warning ("parse error '%U'", format_unformat_error, i);
8849 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8851 mp->mt_is_add = is_add;
8852 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8853 mp->mt_tunnel.mt_l2_only = l2_only;
8854 mp->mt_tunnel.mt_is_multicast = 0;
8855 mp->mt_tunnel.mt_n_paths = path_count;
8857 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8858 sizeof (paths[0]) * path_count);
8866 api_sw_interface_set_unnumbered (vat_main_t * vam)
8868 unformat_input_t *i = vam->input;
8869 vl_api_sw_interface_set_unnumbered_t *mp;
8871 u32 unnum_sw_index = ~0;
8873 u8 sw_if_index_set = 0;
8876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8879 sw_if_index_set = 1;
8880 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8881 sw_if_index_set = 1;
8882 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8884 else if (unformat (i, "del"))
8888 clib_warning ("parse error '%U'", format_unformat_error, i);
8893 if (sw_if_index_set == 0)
8895 errmsg ("missing interface name or sw_if_index");
8899 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8901 mp->sw_if_index = ntohl (sw_if_index);
8902 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8903 mp->is_add = is_add;
8912 api_create_vlan_subif (vat_main_t * vam)
8914 unformat_input_t *i = vam->input;
8915 vl_api_create_vlan_subif_t *mp;
8917 u8 sw_if_index_set = 0;
8922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8924 if (unformat (i, "sw_if_index %d", &sw_if_index))
8925 sw_if_index_set = 1;
8927 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8928 sw_if_index_set = 1;
8929 else if (unformat (i, "vlan %d", &vlan_id))
8933 clib_warning ("parse error '%U'", format_unformat_error, i);
8938 if (sw_if_index_set == 0)
8940 errmsg ("missing interface name or sw_if_index");
8944 if (vlan_id_set == 0)
8946 errmsg ("missing vlan_id");
8949 M (CREATE_VLAN_SUBIF, mp);
8951 mp->sw_if_index = ntohl (sw_if_index);
8952 mp->vlan_id = ntohl (vlan_id);
8959 #define foreach_create_subif_bit \
8966 _(outer_vlan_id_any) \
8967 _(inner_vlan_id_any)
8969 #define foreach_create_subif_flag \
8974 _(4, "exact_match") \
8975 _(5, "default_sub") \
8976 _(6, "outer_vlan_id_any") \
8977 _(7, "inner_vlan_id_any")
8980 api_create_subif (vat_main_t * vam)
8982 unformat_input_t *i = vam->input;
8983 vl_api_create_subif_t *mp;
8985 u8 sw_if_index_set = 0;
8988 u32 __attribute__ ((unused)) no_tags = 0;
8989 u32 __attribute__ ((unused)) one_tag = 0;
8990 u32 __attribute__ ((unused)) two_tags = 0;
8991 u32 __attribute__ ((unused)) dot1ad = 0;
8992 u32 __attribute__ ((unused)) exact_match = 0;
8993 u32 __attribute__ ((unused)) default_sub = 0;
8994 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8995 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8997 u16 outer_vlan_id = 0;
8998 u16 inner_vlan_id = 0;
9001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9003 if (unformat (i, "sw_if_index %d", &sw_if_index))
9004 sw_if_index_set = 1;
9006 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9007 sw_if_index_set = 1;
9008 else if (unformat (i, "sub_id %d", &sub_id))
9010 else if (unformat (i, "outer_vlan_id %d", &tmp))
9011 outer_vlan_id = tmp;
9012 else if (unformat (i, "inner_vlan_id %d", &tmp))
9013 inner_vlan_id = tmp;
9015 #define _(a) else if (unformat (i, #a)) a = 1 ;
9016 foreach_create_subif_bit
9020 clib_warning ("parse error '%U'", format_unformat_error, i);
9025 if (sw_if_index_set == 0)
9027 errmsg ("missing interface name or sw_if_index");
9031 if (sub_id_set == 0)
9033 errmsg ("missing sub_id");
9036 M (CREATE_SUBIF, mp);
9038 mp->sw_if_index = ntohl (sw_if_index);
9039 mp->sub_id = ntohl (sub_id);
9041 #define _(a,b) mp->sub_if_flags |= (1 << a);
9042 foreach_create_subif_flag;
9045 mp->outer_vlan_id = ntohs (outer_vlan_id);
9046 mp->inner_vlan_id = ntohs (inner_vlan_id);
9054 api_ip_table_replace_begin (vat_main_t * vam)
9056 unformat_input_t *i = vam->input;
9057 vl_api_ip_table_replace_begin_t *mp;
9062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9064 if (unformat (i, "table %d", &table_id))
9066 else if (unformat (i, "ipv6"))
9070 clib_warning ("parse error '%U'", format_unformat_error, i);
9075 M (IP_TABLE_REPLACE_BEGIN, mp);
9077 mp->table.table_id = ntohl (table_id);
9078 mp->table.is_ip6 = is_ipv6;
9086 api_ip_table_flush (vat_main_t * vam)
9088 unformat_input_t *i = vam->input;
9089 vl_api_ip_table_flush_t *mp;
9094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9096 if (unformat (i, "table %d", &table_id))
9098 else if (unformat (i, "ipv6"))
9102 clib_warning ("parse error '%U'", format_unformat_error, i);
9107 M (IP_TABLE_FLUSH, mp);
9109 mp->table.table_id = ntohl (table_id);
9110 mp->table.is_ip6 = is_ipv6;
9118 api_ip_table_replace_end (vat_main_t * vam)
9120 unformat_input_t *i = vam->input;
9121 vl_api_ip_table_replace_end_t *mp;
9126 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9128 if (unformat (i, "table %d", &table_id))
9130 else if (unformat (i, "ipv6"))
9134 clib_warning ("parse error '%U'", format_unformat_error, i);
9139 M (IP_TABLE_REPLACE_END, mp);
9141 mp->table.table_id = ntohl (table_id);
9142 mp->table.is_ip6 = is_ipv6;
9150 api_set_ip_flow_hash (vat_main_t * vam)
9152 unformat_input_t *i = vam->input;
9153 vl_api_set_ip_flow_hash_t *mp;
9165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9167 if (unformat (i, "vrf %d", &vrf_id))
9169 else if (unformat (i, "ipv6"))
9171 else if (unformat (i, "src"))
9173 else if (unformat (i, "dst"))
9175 else if (unformat (i, "sport"))
9177 else if (unformat (i, "dport"))
9179 else if (unformat (i, "proto"))
9181 else if (unformat (i, "reverse"))
9186 clib_warning ("parse error '%U'", format_unformat_error, i);
9191 if (vrf_id_set == 0)
9193 errmsg ("missing vrf id");
9197 M (SET_IP_FLOW_HASH, mp);
9203 mp->reverse = reverse;
9204 mp->vrf_id = ntohl (vrf_id);
9205 mp->is_ipv6 = is_ipv6;
9213 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9215 unformat_input_t *i = vam->input;
9216 vl_api_sw_interface_ip6_enable_disable_t *mp;
9218 u8 sw_if_index_set = 0;
9222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9224 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9225 sw_if_index_set = 1;
9226 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9227 sw_if_index_set = 1;
9228 else if (unformat (i, "enable"))
9230 else if (unformat (i, "disable"))
9234 clib_warning ("parse error '%U'", format_unformat_error, i);
9239 if (sw_if_index_set == 0)
9241 errmsg ("missing interface name or sw_if_index");
9245 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9247 mp->sw_if_index = ntohl (sw_if_index);
9248 mp->enable = enable;
9257 api_l2_patch_add_del (vat_main_t * vam)
9259 unformat_input_t *i = vam->input;
9260 vl_api_l2_patch_add_del_t *mp;
9262 u8 rx_sw_if_index_set = 0;
9264 u8 tx_sw_if_index_set = 0;
9268 /* Parse args required to build the message */
9269 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9271 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9272 rx_sw_if_index_set = 1;
9273 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9274 tx_sw_if_index_set = 1;
9275 else if (unformat (i, "rx"))
9277 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9279 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9281 rx_sw_if_index_set = 1;
9286 else if (unformat (i, "tx"))
9288 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9290 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9292 tx_sw_if_index_set = 1;
9297 else if (unformat (i, "del"))
9303 if (rx_sw_if_index_set == 0)
9305 errmsg ("missing rx interface name or rx_sw_if_index");
9309 if (tx_sw_if_index_set == 0)
9311 errmsg ("missing tx interface name or tx_sw_if_index");
9315 M (L2_PATCH_ADD_DEL, mp);
9317 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9318 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9319 mp->is_add = is_add;
9327 u8 localsid_addr[16];
9336 api_sr_localsid_add_del (vat_main_t * vam)
9338 unformat_input_t *i = vam->input;
9339 vl_api_sr_localsid_add_del_t *mp;
9342 ip6_address_t localsid;
9346 u32 fib_table = ~(u32) 0;
9347 ip46_address_t nh_addr;
9348 clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
9350 bool nexthop_set = 0;
9354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9356 if (unformat (i, "del"))
9358 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9359 else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
9361 else if (unformat (i, "behavior %u", &behavior));
9362 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9363 else if (unformat (i, "fib-table %u", &fib_table));
9364 else if (unformat (i, "end.psp %u", &behavior));
9369 M (SR_LOCALSID_ADD_DEL, mp);
9371 clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
9375 clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
9377 mp->behavior = behavior;
9378 mp->sw_if_index = ntohl (sw_if_index);
9379 mp->fib_table = ntohl (fib_table);
9380 mp->end_psp = end_psp;
9381 mp->is_del = is_del;
9389 api_ioam_enable (vat_main_t * vam)
9391 unformat_input_t *input = vam->input;
9392 vl_api_ioam_enable_t *mp;
9394 int has_trace_option = 0;
9395 int has_pot_option = 0;
9396 int has_seqno_option = 0;
9397 int has_analyse_option = 0;
9400 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9402 if (unformat (input, "trace"))
9403 has_trace_option = 1;
9404 else if (unformat (input, "pot"))
9406 else if (unformat (input, "seqno"))
9407 has_seqno_option = 1;
9408 else if (unformat (input, "analyse"))
9409 has_analyse_option = 1;
9413 M (IOAM_ENABLE, mp);
9414 mp->id = htons (id);
9415 mp->seqno = has_seqno_option;
9416 mp->analyse = has_analyse_option;
9417 mp->pot_enable = has_pot_option;
9418 mp->trace_enable = has_trace_option;
9427 api_ioam_disable (vat_main_t * vam)
9429 vl_api_ioam_disable_t *mp;
9432 M (IOAM_DISABLE, mp);
9438 #define foreach_tcp_proto_field \
9442 #define foreach_udp_proto_field \
9446 #define foreach_ip4_proto_field \
9458 u16 src_port, dst_port;
9461 #if VPP_API_TEST_BUILTIN == 0
9463 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9465 u8 **maskp = va_arg (*args, u8 **);
9467 u8 found_something = 0;
9470 #define _(a) u8 a=0;
9471 foreach_tcp_proto_field;
9474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9477 #define _(a) else if (unformat (input, #a)) a=1;
9478 foreach_tcp_proto_field
9484 #define _(a) found_something += a;
9485 foreach_tcp_proto_field;
9488 if (found_something == 0)
9491 vec_validate (mask, sizeof (*tcp) - 1);
9493 tcp = (tcp_header_t *) mask;
9495 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9496 foreach_tcp_proto_field;
9504 unformat_udp_mask (unformat_input_t * input, va_list * args)
9506 u8 **maskp = va_arg (*args, u8 **);
9508 u8 found_something = 0;
9511 #define _(a) u8 a=0;
9512 foreach_udp_proto_field;
9515 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9518 #define _(a) else if (unformat (input, #a)) a=1;
9519 foreach_udp_proto_field
9525 #define _(a) found_something += a;
9526 foreach_udp_proto_field;
9529 if (found_something == 0)
9532 vec_validate (mask, sizeof (*udp) - 1);
9534 udp = (udp_header_t *) mask;
9536 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9537 foreach_udp_proto_field;
9545 unformat_l4_mask (unformat_input_t * input, va_list * args)
9547 u8 **maskp = va_arg (*args, u8 **);
9548 u16 src_port = 0, dst_port = 0;
9549 tcpudp_header_t *tcpudp;
9551 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9553 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9555 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9557 else if (unformat (input, "src_port"))
9559 else if (unformat (input, "dst_port"))
9565 if (!src_port && !dst_port)
9569 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9571 tcpudp = (tcpudp_header_t *) mask;
9572 tcpudp->src_port = src_port;
9573 tcpudp->dst_port = dst_port;
9581 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9583 u8 **maskp = va_arg (*args, u8 **);
9585 u8 found_something = 0;
9588 #define _(a) u8 a=0;
9589 foreach_ip4_proto_field;
9595 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9597 if (unformat (input, "version"))
9599 else if (unformat (input, "hdr_length"))
9601 else if (unformat (input, "src"))
9603 else if (unformat (input, "dst"))
9605 else if (unformat (input, "proto"))
9608 #define _(a) else if (unformat (input, #a)) a=1;
9609 foreach_ip4_proto_field
9615 #define _(a) found_something += a;
9616 foreach_ip4_proto_field;
9619 if (found_something == 0)
9622 vec_validate (mask, sizeof (*ip) - 1);
9624 ip = (ip4_header_t *) mask;
9626 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9627 foreach_ip4_proto_field;
9630 ip->ip_version_and_header_length = 0;
9633 ip->ip_version_and_header_length |= 0xF0;
9636 ip->ip_version_and_header_length |= 0x0F;
9642 #define foreach_ip6_proto_field \
9650 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9652 u8 **maskp = va_arg (*args, u8 **);
9654 u8 found_something = 0;
9656 u32 ip_version_traffic_class_and_flow_label;
9658 #define _(a) u8 a=0;
9659 foreach_ip6_proto_field;
9662 u8 traffic_class = 0;
9665 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9667 if (unformat (input, "version"))
9669 else if (unformat (input, "traffic-class"))
9671 else if (unformat (input, "flow-label"))
9673 else if (unformat (input, "src"))
9675 else if (unformat (input, "dst"))
9677 else if (unformat (input, "proto"))
9680 #define _(a) else if (unformat (input, #a)) a=1;
9681 foreach_ip6_proto_field
9687 #define _(a) found_something += a;
9688 foreach_ip6_proto_field;
9691 if (found_something == 0)
9694 vec_validate (mask, sizeof (*ip) - 1);
9696 ip = (ip6_header_t *) mask;
9698 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9699 foreach_ip6_proto_field;
9702 ip_version_traffic_class_and_flow_label = 0;
9705 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9708 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9711 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9713 ip->ip_version_traffic_class_and_flow_label =
9714 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9721 unformat_l3_mask (unformat_input_t * input, va_list * args)
9723 u8 **maskp = va_arg (*args, u8 **);
9725 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9727 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9729 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9738 unformat_l2_mask (unformat_input_t * input, va_list * args)
9740 u8 **maskp = va_arg (*args, u8 **);
9755 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9757 if (unformat (input, "src"))
9759 else if (unformat (input, "dst"))
9761 else if (unformat (input, "proto"))
9763 else if (unformat (input, "tag1"))
9765 else if (unformat (input, "tag2"))
9767 else if (unformat (input, "ignore-tag1"))
9769 else if (unformat (input, "ignore-tag2"))
9771 else if (unformat (input, "cos1"))
9773 else if (unformat (input, "cos2"))
9775 else if (unformat (input, "dot1q"))
9777 else if (unformat (input, "dot1ad"))
9782 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9783 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9786 if (tag1 || ignore_tag1 || cos1 || dot1q)
9788 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9791 vec_validate (mask, len - 1);
9794 clib_memset (mask, 0xff, 6);
9797 clib_memset (mask + 6, 0xff, 6);
9801 /* inner vlan tag */
9810 mask[21] = mask[20] = 0xff;
9831 mask[16] = mask[17] = 0xff;
9841 mask[12] = mask[13] = 0xff;
9848 unformat_classify_mask (unformat_input_t * input, va_list * args)
9850 u8 **maskp = va_arg (*args, u8 **);
9851 u32 *skipp = va_arg (*args, u32 *);
9852 u32 *matchp = va_arg (*args, u32 *);
9860 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9862 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9864 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9866 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9868 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9882 if (mask || l2 || l3 || l4)
9886 /* "With a free Ethernet header in every package" */
9888 vec_validate (l2, 13);
9892 vec_append (mask, l3);
9897 vec_append (mask, l4);
9902 /* Scan forward looking for the first significant mask octet */
9903 for (i = 0; i < vec_len (mask); i++)
9907 /* compute (skip, match) params */
9908 *skipp = i / sizeof (u32x4);
9909 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9911 /* Pad mask to an even multiple of the vector size */
9912 while (vec_len (mask) % sizeof (u32x4))
9915 match = vec_len (mask) / sizeof (u32x4);
9917 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9919 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9920 if (*tmp || *(tmp + 1))
9925 clib_warning ("BUG: match 0");
9927 _vec_len (mask) = match * sizeof (u32x4);
9937 #endif /* VPP_API_TEST_BUILTIN */
9939 #define foreach_l2_next \
9941 _(ethernet, ETHERNET_INPUT) \
9946 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9948 u32 *miss_next_indexp = va_arg (*args, u32 *);
9953 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9957 if (unformat (input, "%d", &tmp))
9966 *miss_next_indexp = next_index;
9970 #define foreach_ip_next \
9976 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9978 u32 *miss_next_indexp = va_arg (*args, u32 *);
9983 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9987 if (unformat (input, "%d", &tmp))
9996 *miss_next_indexp = next_index;
10000 #define foreach_acl_next \
10004 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10006 u32 *miss_next_indexp = va_arg (*args, u32 *);
10007 u32 next_index = 0;
10011 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10015 if (unformat (input, "permit"))
10020 else if (unformat (input, "%d", &tmp))
10029 *miss_next_indexp = next_index;
10034 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10036 u32 *r = va_arg (*args, u32 *);
10038 if (unformat (input, "conform-color"))
10039 *r = POLICE_CONFORM;
10040 else if (unformat (input, "exceed-color"))
10041 *r = POLICE_EXCEED;
10049 api_classify_add_del_table (vat_main_t * vam)
10051 unformat_input_t *i = vam->input;
10052 vl_api_classify_add_del_table_t *mp;
10059 u32 table_index = ~0;
10060 u32 next_table_index = ~0;
10061 u32 miss_next_index = ~0;
10062 u32 memory_size = 32 << 20;
10064 u32 current_data_flag = 0;
10065 int current_data_offset = 0;
10068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10070 if (unformat (i, "del"))
10072 else if (unformat (i, "del-chain"))
10077 else if (unformat (i, "buckets %d", &nbuckets))
10079 else if (unformat (i, "memory_size %d", &memory_size))
10081 else if (unformat (i, "skip %d", &skip))
10083 else if (unformat (i, "match %d", &match))
10085 else if (unformat (i, "table %d", &table_index))
10087 else if (unformat (i, "mask %U", unformat_classify_mask,
10088 &mask, &skip, &match))
10090 else if (unformat (i, "next-table %d", &next_table_index))
10092 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10095 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10098 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10101 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10103 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10109 if (is_add && mask == 0)
10111 errmsg ("Mask required");
10115 if (is_add && skip == ~0)
10117 errmsg ("skip count required");
10121 if (is_add && match == ~0)
10123 errmsg ("match count required");
10127 if (!is_add && table_index == ~0)
10129 errmsg ("table index required for delete");
10133 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10135 mp->is_add = is_add;
10136 mp->del_chain = del_chain;
10137 mp->table_index = ntohl (table_index);
10138 mp->nbuckets = ntohl (nbuckets);
10139 mp->memory_size = ntohl (memory_size);
10140 mp->skip_n_vectors = ntohl (skip);
10141 mp->match_n_vectors = ntohl (match);
10142 mp->next_table_index = ntohl (next_table_index);
10143 mp->miss_next_index = ntohl (miss_next_index);
10144 mp->current_data_flag = ntohl (current_data_flag);
10145 mp->current_data_offset = ntohl (current_data_offset);
10146 mp->mask_len = ntohl (vec_len (mask));
10147 clib_memcpy (mp->mask, mask, vec_len (mask));
10156 #if VPP_API_TEST_BUILTIN == 0
10158 unformat_l4_match (unformat_input_t * input, va_list * args)
10160 u8 **matchp = va_arg (*args, u8 **);
10162 u8 *proto_header = 0;
10168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10170 if (unformat (input, "src_port %d", &src_port))
10172 else if (unformat (input, "dst_port %d", &dst_port))
10178 h.src_port = clib_host_to_net_u16 (src_port);
10179 h.dst_port = clib_host_to_net_u16 (dst_port);
10180 vec_validate (proto_header, sizeof (h) - 1);
10181 memcpy (proto_header, &h, sizeof (h));
10183 *matchp = proto_header;
10189 unformat_ip4_match (unformat_input_t * input, va_list * args)
10191 u8 **matchp = va_arg (*args, u8 **);
10196 int hdr_length = 0;
10197 u32 hdr_length_val;
10198 int src = 0, dst = 0;
10199 ip4_address_t src_val, dst_val;
10206 int fragment_id = 0;
10207 u32 fragment_id_val;
10213 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10215 if (unformat (input, "version %d", &version_val))
10217 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10219 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10221 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10223 else if (unformat (input, "proto %d", &proto_val))
10225 else if (unformat (input, "tos %d", &tos_val))
10227 else if (unformat (input, "length %d", &length_val))
10229 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10231 else if (unformat (input, "ttl %d", &ttl_val))
10233 else if (unformat (input, "checksum %d", &checksum_val))
10239 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10240 + ttl + checksum == 0)
10244 * Aligned because we use the real comparison functions
10246 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10248 ip = (ip4_header_t *) match;
10250 /* These are realistically matched in practice */
10252 ip->src_address.as_u32 = src_val.as_u32;
10255 ip->dst_address.as_u32 = dst_val.as_u32;
10258 ip->protocol = proto_val;
10261 /* These are not, but they're included for completeness */
10263 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10266 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10272 ip->length = clib_host_to_net_u16 (length_val);
10278 ip->checksum = clib_host_to_net_u16 (checksum_val);
10285 unformat_ip6_match (unformat_input_t * input, va_list * args)
10287 u8 **matchp = va_arg (*args, u8 **);
10292 u8 traffic_class = 0;
10293 u32 traffic_class_val = 0;
10296 int src = 0, dst = 0;
10297 ip6_address_t src_val, dst_val;
10300 int payload_length = 0;
10301 u32 payload_length_val;
10304 u32 ip_version_traffic_class_and_flow_label;
10306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10308 if (unformat (input, "version %d", &version_val))
10310 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10312 else if (unformat (input, "flow_label %d", &flow_label_val))
10314 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10316 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10318 else if (unformat (input, "proto %d", &proto_val))
10320 else if (unformat (input, "payload_length %d", &payload_length_val))
10321 payload_length = 1;
10322 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10328 if (version + traffic_class + flow_label + src + dst + proto +
10329 payload_length + hop_limit == 0)
10333 * Aligned because we use the real comparison functions
10335 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10337 ip = (ip6_header_t *) match;
10340 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10343 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10346 ip->protocol = proto_val;
10348 ip_version_traffic_class_and_flow_label = 0;
10351 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10354 ip_version_traffic_class_and_flow_label |=
10355 (traffic_class_val & 0xFF) << 20;
10358 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10360 ip->ip_version_traffic_class_and_flow_label =
10361 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10363 if (payload_length)
10364 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10367 ip->hop_limit = hop_limit_val;
10374 unformat_l3_match (unformat_input_t * input, va_list * args)
10376 u8 **matchp = va_arg (*args, u8 **);
10378 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10380 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10382 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10391 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10393 u8 *tagp = va_arg (*args, u8 *);
10396 if (unformat (input, "%d", &tag))
10398 tagp[0] = (tag >> 8) & 0x0F;
10399 tagp[1] = tag & 0xFF;
10407 unformat_l2_match (unformat_input_t * input, va_list * args)
10409 u8 **matchp = va_arg (*args, u8 **);
10422 u8 ignore_tag1 = 0;
10423 u8 ignore_tag2 = 0;
10429 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10431 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10434 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10436 else if (unformat (input, "proto %U",
10437 unformat_ethernet_type_host_byte_order, &proto_val))
10439 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10441 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10443 else if (unformat (input, "ignore-tag1"))
10445 else if (unformat (input, "ignore-tag2"))
10447 else if (unformat (input, "cos1 %d", &cos1_val))
10449 else if (unformat (input, "cos2 %d", &cos2_val))
10454 if ((src + dst + proto + tag1 + tag2 +
10455 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10458 if (tag1 || ignore_tag1 || cos1)
10460 if (tag2 || ignore_tag2 || cos2)
10463 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10466 clib_memcpy (match, dst_val, 6);
10469 clib_memcpy (match + 6, src_val, 6);
10473 /* inner vlan tag */
10474 match[19] = tag2_val[1];
10475 match[18] = tag2_val[0];
10477 match[18] |= (cos2_val & 0x7) << 5;
10480 match[21] = proto_val & 0xff;
10481 match[20] = proto_val >> 8;
10485 match[15] = tag1_val[1];
10486 match[14] = tag1_val[0];
10489 match[14] |= (cos1_val & 0x7) << 5;
10495 match[15] = tag1_val[1];
10496 match[14] = tag1_val[0];
10499 match[17] = proto_val & 0xff;
10500 match[16] = proto_val >> 8;
10503 match[14] |= (cos1_val & 0x7) << 5;
10509 match[18] |= (cos2_val & 0x7) << 5;
10511 match[14] |= (cos1_val & 0x7) << 5;
10514 match[13] = proto_val & 0xff;
10515 match[12] = proto_val >> 8;
10523 unformat_qos_source (unformat_input_t * input, va_list * args)
10525 int *qs = va_arg (*args, int *);
10527 if (unformat (input, "ip"))
10528 *qs = QOS_SOURCE_IP;
10529 else if (unformat (input, "mpls"))
10530 *qs = QOS_SOURCE_MPLS;
10531 else if (unformat (input, "ext"))
10532 *qs = QOS_SOURCE_EXT;
10533 else if (unformat (input, "vlan"))
10534 *qs = QOS_SOURCE_VLAN;
10543 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10545 u8 **matchp = va_arg (*args, u8 **);
10546 u32 skip_n_vectors = va_arg (*args, u32);
10547 u32 match_n_vectors = va_arg (*args, u32);
10554 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10556 if (unformat (input, "hex %U", unformat_hex_string, &match))
10558 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10560 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10562 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10576 if (match || l2 || l3 || l4)
10578 if (l2 || l3 || l4)
10580 /* "Win a free Ethernet header in every packet" */
10582 vec_validate_aligned (l2, 13, sizeof (u32x4));
10586 vec_append_aligned (match, l3, sizeof (u32x4));
10591 vec_append_aligned (match, l4, sizeof (u32x4));
10596 /* Make sure the vector is big enough even if key is all 0's */
10597 vec_validate_aligned
10598 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10601 /* Set size, include skipped vectors */
10602 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10613 api_classify_add_del_session (vat_main_t * vam)
10615 unformat_input_t *i = vam->input;
10616 vl_api_classify_add_del_session_t *mp;
10618 u32 table_index = ~0;
10619 u32 hit_next_index = ~0;
10620 u32 opaque_index = ~0;
10623 u32 skip_n_vectors = 0;
10624 u32 match_n_vectors = 0;
10630 * Warning: you have to supply skip_n and match_n
10631 * because the API client cant simply look at the classify
10635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10637 if (unformat (i, "del"))
10639 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10642 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10645 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10648 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10650 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10652 else if (unformat (i, "opaque-index %d", &opaque_index))
10654 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10656 else if (unformat (i, "match_n %d", &match_n_vectors))
10658 else if (unformat (i, "match %U", api_unformat_classify_match,
10659 &match, skip_n_vectors, match_n_vectors))
10661 else if (unformat (i, "advance %d", &advance))
10663 else if (unformat (i, "table-index %d", &table_index))
10665 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10667 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10669 else if (unformat (i, "action %d", &action))
10671 else if (unformat (i, "metadata %d", &metadata))
10677 if (table_index == ~0)
10679 errmsg ("Table index required");
10683 if (is_add && match == 0)
10685 errmsg ("Match value required");
10689 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10691 mp->is_add = is_add;
10692 mp->table_index = ntohl (table_index);
10693 mp->hit_next_index = ntohl (hit_next_index);
10694 mp->opaque_index = ntohl (opaque_index);
10695 mp->advance = ntohl (advance);
10696 mp->action = action;
10697 mp->metadata = ntohl (metadata);
10698 mp->match_len = ntohl (vec_len (match));
10699 clib_memcpy (mp->match, match, vec_len (match));
10708 api_classify_set_interface_ip_table (vat_main_t * vam)
10710 unformat_input_t *i = vam->input;
10711 vl_api_classify_set_interface_ip_table_t *mp;
10713 int sw_if_index_set;
10714 u32 table_index = ~0;
10718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10720 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10721 sw_if_index_set = 1;
10722 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10723 sw_if_index_set = 1;
10724 else if (unformat (i, "table %d", &table_index))
10728 clib_warning ("parse error '%U'", format_unformat_error, i);
10733 if (sw_if_index_set == 0)
10735 errmsg ("missing interface name or sw_if_index");
10740 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10742 mp->sw_if_index = ntohl (sw_if_index);
10743 mp->table_index = ntohl (table_index);
10744 mp->is_ipv6 = is_ipv6;
10752 api_classify_set_interface_l2_tables (vat_main_t * vam)
10754 unformat_input_t *i = vam->input;
10755 vl_api_classify_set_interface_l2_tables_t *mp;
10757 int sw_if_index_set;
10758 u32 ip4_table_index = ~0;
10759 u32 ip6_table_index = ~0;
10760 u32 other_table_index = ~0;
10764 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10766 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10767 sw_if_index_set = 1;
10768 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10769 sw_if_index_set = 1;
10770 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10772 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10774 else if (unformat (i, "other-table %d", &other_table_index))
10776 else if (unformat (i, "is-input %d", &is_input))
10780 clib_warning ("parse error '%U'", format_unformat_error, i);
10785 if (sw_if_index_set == 0)
10787 errmsg ("missing interface name or sw_if_index");
10792 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10794 mp->sw_if_index = ntohl (sw_if_index);
10795 mp->ip4_table_index = ntohl (ip4_table_index);
10796 mp->ip6_table_index = ntohl (ip6_table_index);
10797 mp->other_table_index = ntohl (other_table_index);
10798 mp->is_input = (u8) is_input;
10806 api_set_ipfix_exporter (vat_main_t * vam)
10808 unformat_input_t *i = vam->input;
10809 vl_api_set_ipfix_exporter_t *mp;
10810 ip4_address_t collector_address;
10811 u8 collector_address_set = 0;
10812 u32 collector_port = ~0;
10813 ip4_address_t src_address;
10814 u8 src_address_set = 0;
10817 u32 template_interval = ~0;
10818 u8 udp_checksum = 0;
10821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10823 if (unformat (i, "collector_address %U", unformat_ip4_address,
10824 &collector_address))
10825 collector_address_set = 1;
10826 else if (unformat (i, "collector_port %d", &collector_port))
10828 else if (unformat (i, "src_address %U", unformat_ip4_address,
10830 src_address_set = 1;
10831 else if (unformat (i, "vrf_id %d", &vrf_id))
10833 else if (unformat (i, "path_mtu %d", &path_mtu))
10835 else if (unformat (i, "template_interval %d", &template_interval))
10837 else if (unformat (i, "udp_checksum"))
10843 if (collector_address_set == 0)
10845 errmsg ("collector_address required");
10849 if (src_address_set == 0)
10851 errmsg ("src_address required");
10855 M (SET_IPFIX_EXPORTER, mp);
10857 memcpy (mp->collector_address.un.ip4, collector_address.data,
10858 sizeof (collector_address.data));
10859 mp->collector_port = htons ((u16) collector_port);
10860 memcpy (mp->src_address.un.ip4, src_address.data,
10861 sizeof (src_address.data));
10862 mp->vrf_id = htonl (vrf_id);
10863 mp->path_mtu = htonl (path_mtu);
10864 mp->template_interval = htonl (template_interval);
10865 mp->udp_checksum = udp_checksum;
10873 api_set_ipfix_classify_stream (vat_main_t * vam)
10875 unformat_input_t *i = vam->input;
10876 vl_api_set_ipfix_classify_stream_t *mp;
10878 u32 src_port = UDP_DST_PORT_ipfix;
10881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10883 if (unformat (i, "domain %d", &domain_id))
10885 else if (unformat (i, "src_port %d", &src_port))
10889 errmsg ("unknown input `%U'", format_unformat_error, i);
10894 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10896 mp->domain_id = htonl (domain_id);
10897 mp->src_port = htons ((u16) src_port);
10905 api_ipfix_classify_table_add_del (vat_main_t * vam)
10907 unformat_input_t *i = vam->input;
10908 vl_api_ipfix_classify_table_add_del_t *mp;
10910 u32 classify_table_index = ~0;
10912 u8 transport_protocol = 255;
10915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10917 if (unformat (i, "add"))
10919 else if (unformat (i, "del"))
10921 else if (unformat (i, "table %d", &classify_table_index))
10923 else if (unformat (i, "ip4"))
10925 else if (unformat (i, "ip6"))
10927 else if (unformat (i, "tcp"))
10928 transport_protocol = 6;
10929 else if (unformat (i, "udp"))
10930 transport_protocol = 17;
10933 errmsg ("unknown input `%U'", format_unformat_error, i);
10940 errmsg ("expecting: add|del");
10943 if (classify_table_index == ~0)
10945 errmsg ("classifier table not specified");
10948 if (ip_version == 0)
10950 errmsg ("IP version not specified");
10954 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10956 mp->is_add = is_add;
10957 mp->table_id = htonl (classify_table_index);
10958 mp->ip_version = ip_version;
10959 mp->transport_protocol = transport_protocol;
10967 api_get_node_index (vat_main_t * vam)
10969 unformat_input_t *i = vam->input;
10970 vl_api_get_node_index_t *mp;
10974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10976 if (unformat (i, "node %s", &name))
10983 errmsg ("node name required");
10986 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10988 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10992 M (GET_NODE_INDEX, mp);
10993 clib_memcpy (mp->node_name, name, vec_len (name));
11002 api_get_next_index (vat_main_t * vam)
11004 unformat_input_t *i = vam->input;
11005 vl_api_get_next_index_t *mp;
11006 u8 *node_name = 0, *next_node_name = 0;
11009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11011 if (unformat (i, "node-name %s", &node_name))
11013 else if (unformat (i, "next-node-name %s", &next_node_name))
11017 if (node_name == 0)
11019 errmsg ("node name required");
11022 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11024 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11028 if (next_node_name == 0)
11030 errmsg ("next node name required");
11033 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11035 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11039 M (GET_NEXT_INDEX, mp);
11040 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11041 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11042 vec_free (node_name);
11043 vec_free (next_node_name);
11051 api_add_node_next (vat_main_t * vam)
11053 unformat_input_t *i = vam->input;
11054 vl_api_add_node_next_t *mp;
11059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11061 if (unformat (i, "node %s", &name))
11063 else if (unformat (i, "next %s", &next))
11070 errmsg ("node name required");
11073 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11075 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11080 errmsg ("next node required");
11083 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11085 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11089 M (ADD_NODE_NEXT, mp);
11090 clib_memcpy (mp->node_name, name, vec_len (name));
11091 clib_memcpy (mp->next_name, next, vec_len (next));
11101 api_l2tpv3_create_tunnel (vat_main_t * vam)
11103 unformat_input_t *i = vam->input;
11104 ip6_address_t client_address, our_address;
11105 int client_address_set = 0;
11106 int our_address_set = 0;
11107 u32 local_session_id = 0;
11108 u32 remote_session_id = 0;
11109 u64 local_cookie = 0;
11110 u64 remote_cookie = 0;
11111 u8 l2_sublayer_present = 0;
11112 vl_api_l2tpv3_create_tunnel_t *mp;
11115 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11117 if (unformat (i, "client_address %U", unformat_ip6_address,
11119 client_address_set = 1;
11120 else if (unformat (i, "our_address %U", unformat_ip6_address,
11122 our_address_set = 1;
11123 else if (unformat (i, "local_session_id %d", &local_session_id))
11125 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11127 else if (unformat (i, "local_cookie %lld", &local_cookie))
11129 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11131 else if (unformat (i, "l2-sublayer-present"))
11132 l2_sublayer_present = 1;
11137 if (client_address_set == 0)
11139 errmsg ("client_address required");
11143 if (our_address_set == 0)
11145 errmsg ("our_address required");
11149 M (L2TPV3_CREATE_TUNNEL, mp);
11151 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11152 sizeof (ip6_address_t));
11154 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11155 sizeof (ip6_address_t));
11157 mp->local_session_id = ntohl (local_session_id);
11158 mp->remote_session_id = ntohl (remote_session_id);
11159 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11160 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11161 mp->l2_sublayer_present = l2_sublayer_present;
11169 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11171 unformat_input_t *i = vam->input;
11173 u8 sw_if_index_set = 0;
11174 u64 new_local_cookie = 0;
11175 u64 new_remote_cookie = 0;
11176 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11181 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11182 sw_if_index_set = 1;
11183 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11184 sw_if_index_set = 1;
11185 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11187 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11193 if (sw_if_index_set == 0)
11195 errmsg ("missing interface name or sw_if_index");
11199 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11201 mp->sw_if_index = ntohl (sw_if_index);
11202 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11203 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11211 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11213 unformat_input_t *i = vam->input;
11214 vl_api_l2tpv3_interface_enable_disable_t *mp;
11216 u8 sw_if_index_set = 0;
11217 u8 enable_disable = 1;
11220 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11222 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11223 sw_if_index_set = 1;
11224 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11225 sw_if_index_set = 1;
11226 else if (unformat (i, "enable"))
11227 enable_disable = 1;
11228 else if (unformat (i, "disable"))
11229 enable_disable = 0;
11234 if (sw_if_index_set == 0)
11236 errmsg ("missing interface name or sw_if_index");
11240 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11242 mp->sw_if_index = ntohl (sw_if_index);
11243 mp->enable_disable = enable_disable;
11251 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11253 unformat_input_t *i = vam->input;
11254 vl_api_l2tpv3_set_lookup_key_t *mp;
11258 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11260 if (unformat (i, "lookup_v6_src"))
11261 key = L2T_LOOKUP_SRC_ADDRESS;
11262 else if (unformat (i, "lookup_v6_dst"))
11263 key = L2T_LOOKUP_DST_ADDRESS;
11264 else if (unformat (i, "lookup_session_id"))
11265 key = L2T_LOOKUP_SESSION_ID;
11270 if (key == (u8) ~ 0)
11272 errmsg ("l2tp session lookup key unset");
11276 M (L2TPV3_SET_LOOKUP_KEY, mp);
11285 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11286 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11288 vat_main_t *vam = &vat_main;
11290 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11291 format_ip6_address, mp->our_address,
11292 format_ip6_address, mp->client_address,
11293 clib_net_to_host_u32 (mp->sw_if_index));
11296 " local cookies %016llx %016llx remote cookie %016llx",
11297 clib_net_to_host_u64 (mp->local_cookie[0]),
11298 clib_net_to_host_u64 (mp->local_cookie[1]),
11299 clib_net_to_host_u64 (mp->remote_cookie));
11301 print (vam->ofp, " local session-id %d remote session-id %d",
11302 clib_net_to_host_u32 (mp->local_session_id),
11303 clib_net_to_host_u32 (mp->remote_session_id));
11305 print (vam->ofp, " l2 specific sublayer %s\n",
11306 mp->l2_sublayer_present ? "preset" : "absent");
11310 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11311 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11313 vat_main_t *vam = &vat_main;
11314 vat_json_node_t *node = NULL;
11315 struct in6_addr addr;
11317 if (VAT_JSON_ARRAY != vam->json_tree.type)
11319 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11320 vat_json_init_array (&vam->json_tree);
11322 node = vat_json_array_add (&vam->json_tree);
11324 vat_json_init_object (node);
11326 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11327 vat_json_object_add_ip6 (node, "our_address", addr);
11328 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11329 vat_json_object_add_ip6 (node, "client_address", addr);
11331 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11332 vat_json_init_array (lc);
11333 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11334 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11335 vat_json_object_add_uint (node, "remote_cookie",
11336 clib_net_to_host_u64 (mp->remote_cookie));
11338 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11339 vat_json_object_add_uint (node, "local_session_id",
11340 clib_net_to_host_u32 (mp->local_session_id));
11341 vat_json_object_add_uint (node, "remote_session_id",
11342 clib_net_to_host_u32 (mp->remote_session_id));
11343 vat_json_object_add_string_copy (node, "l2_sublayer",
11344 mp->l2_sublayer_present ? (u8 *) "present"
11345 : (u8 *) "absent");
11349 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11351 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11352 vl_api_control_ping_t *mp_ping;
11355 /* Get list of l2tpv3-tunnel interfaces */
11356 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11359 /* Use a control ping for synchronization */
11360 MPING (CONTROL_PING, mp_ping);
11368 static void vl_api_sw_interface_tap_v2_details_t_handler
11369 (vl_api_sw_interface_tap_v2_details_t * mp)
11371 vat_main_t *vam = &vat_main;
11374 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11375 mp->host_ip4_prefix.len);
11377 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11378 mp->host_ip6_prefix.len);
11381 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11382 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11383 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11384 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11385 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11391 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11392 (vl_api_sw_interface_tap_v2_details_t * mp)
11394 vat_main_t *vam = &vat_main;
11395 vat_json_node_t *node = NULL;
11397 if (VAT_JSON_ARRAY != vam->json_tree.type)
11399 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11400 vat_json_init_array (&vam->json_tree);
11402 node = vat_json_array_add (&vam->json_tree);
11404 vat_json_init_object (node);
11405 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11406 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11407 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11408 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11409 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11410 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11411 vat_json_object_add_string_copy (node, "host_mac_addr",
11412 format (0, "%U", format_ethernet_address,
11413 &mp->host_mac_addr));
11414 vat_json_object_add_string_copy (node, "host_namespace",
11415 mp->host_namespace);
11416 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11417 vat_json_object_add_string_copy (node, "host_ip4_addr",
11418 format (0, "%U/%d", format_ip4_address,
11419 mp->host_ip4_prefix.address,
11420 mp->host_ip4_prefix.len));
11421 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11422 format (0, "%U/%d", format_ip6_address,
11423 mp->host_ip6_prefix.address,
11424 mp->host_ip6_prefix.len));
11429 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11431 vl_api_sw_interface_tap_v2_dump_t *mp;
11432 vl_api_control_ping_t *mp_ping;
11436 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11437 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11438 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11441 /* Get list of tap interfaces */
11442 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11445 /* Use a control ping for synchronization */
11446 MPING (CONTROL_PING, mp_ping);
11453 static void vl_api_sw_interface_virtio_pci_details_t_handler
11454 (vl_api_sw_interface_virtio_pci_details_t * mp)
11456 vat_main_t *vam = &vat_main;
11471 addr.domain = ntohs (mp->pci_addr.domain);
11472 addr.bus = mp->pci_addr.bus;
11473 addr.slot = mp->pci_addr.slot;
11474 addr.function = mp->pci_addr.function;
11476 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11477 addr.slot, addr.function);
11480 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11481 pci_addr, ntohl (mp->sw_if_index),
11482 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11483 format_ethernet_address, mp->mac_addr,
11484 clib_net_to_host_u64 (mp->features));
11485 vec_free (pci_addr);
11488 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11489 (vl_api_sw_interface_virtio_pci_details_t * mp)
11491 vat_main_t *vam = &vat_main;
11492 vat_json_node_t *node = NULL;
11493 vlib_pci_addr_t pci_addr;
11495 if (VAT_JSON_ARRAY != vam->json_tree.type)
11497 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11498 vat_json_init_array (&vam->json_tree);
11500 node = vat_json_array_add (&vam->json_tree);
11502 pci_addr.domain = ntohs (mp->pci_addr.domain);
11503 pci_addr.bus = mp->pci_addr.bus;
11504 pci_addr.slot = mp->pci_addr.slot;
11505 pci_addr.function = mp->pci_addr.function;
11507 vat_json_init_object (node);
11508 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11509 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11510 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11511 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11512 vat_json_object_add_uint (node, "features",
11513 clib_net_to_host_u64 (mp->features));
11514 vat_json_object_add_string_copy (node, "mac_addr",
11515 format (0, "%U", format_ethernet_address,
11520 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11522 vl_api_sw_interface_virtio_pci_dump_t *mp;
11523 vl_api_control_ping_t *mp_ping;
11527 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11528 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11529 "mac_addr", "features");
11531 /* Get list of tap interfaces */
11532 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11535 /* Use a control ping for synchronization */
11536 MPING (CONTROL_PING, mp_ping);
11544 api_vxlan_offload_rx (vat_main_t * vam)
11546 unformat_input_t *line_input = vam->input;
11547 vl_api_vxlan_offload_rx_t *mp;
11548 u32 hw_if_index = ~0, rx_if_index = ~0;
11552 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11554 if (unformat (line_input, "del"))
11556 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11559 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11561 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11564 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11568 errmsg ("parse error '%U'", format_unformat_error, line_input);
11573 if (hw_if_index == ~0)
11575 errmsg ("no hw interface");
11579 if (rx_if_index == ~0)
11581 errmsg ("no rx tunnel");
11585 M (VXLAN_OFFLOAD_RX, mp);
11587 mp->hw_if_index = ntohl (hw_if_index);
11588 mp->sw_if_index = ntohl (rx_if_index);
11589 mp->enable = is_add;
11596 static uword unformat_vxlan_decap_next
11597 (unformat_input_t * input, va_list * args)
11599 u32 *result = va_arg (*args, u32 *);
11602 if (unformat (input, "l2"))
11603 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11604 else if (unformat (input, "%d", &tmp))
11612 api_vxlan_add_del_tunnel (vat_main_t * vam)
11614 unformat_input_t *line_input = vam->input;
11615 vl_api_vxlan_add_del_tunnel_t *mp;
11616 ip46_address_t src, dst;
11618 u8 ipv4_set = 0, ipv6_set = 0;
11623 u32 mcast_sw_if_index = ~0;
11624 u32 encap_vrf_id = 0;
11625 u32 decap_next_index = ~0;
11629 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11630 clib_memset (&src, 0, sizeof src);
11631 clib_memset (&dst, 0, sizeof dst);
11633 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11635 if (unformat (line_input, "del"))
11637 else if (unformat (line_input, "instance %d", &instance))
11640 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11646 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11652 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11658 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11663 else if (unformat (line_input, "group %U %U",
11664 unformat_ip4_address, &dst.ip4,
11665 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11667 grp_set = dst_set = 1;
11670 else if (unformat (line_input, "group %U",
11671 unformat_ip4_address, &dst.ip4))
11673 grp_set = dst_set = 1;
11676 else if (unformat (line_input, "group %U %U",
11677 unformat_ip6_address, &dst.ip6,
11678 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11680 grp_set = dst_set = 1;
11683 else if (unformat (line_input, "group %U",
11684 unformat_ip6_address, &dst.ip6))
11686 grp_set = dst_set = 1;
11690 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11692 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11694 else if (unformat (line_input, "decap-next %U",
11695 unformat_vxlan_decap_next, &decap_next_index))
11697 else if (unformat (line_input, "vni %d", &vni))
11701 errmsg ("parse error '%U'", format_unformat_error, line_input);
11708 errmsg ("tunnel src address not specified");
11713 errmsg ("tunnel dst address not specified");
11717 if (grp_set && !ip46_address_is_multicast (&dst))
11719 errmsg ("tunnel group address not multicast");
11722 if (grp_set && mcast_sw_if_index == ~0)
11724 errmsg ("tunnel nonexistent multicast device");
11727 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11729 errmsg ("tunnel dst address must be unicast");
11734 if (ipv4_set && ipv6_set)
11736 errmsg ("both IPv4 and IPv6 addresses specified");
11740 if ((vni == 0) || (vni >> 24))
11742 errmsg ("vni not specified or out of range");
11746 M (VXLAN_ADD_DEL_TUNNEL, mp);
11750 clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
11751 clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11755 clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
11756 clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11758 mp->src_address.af = ipv6_set;
11759 mp->dst_address.af = ipv6_set;
11761 mp->instance = htonl (instance);
11762 mp->encap_vrf_id = ntohl (encap_vrf_id);
11763 mp->decap_next_index = ntohl (decap_next_index);
11764 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11765 mp->vni = ntohl (vni);
11766 mp->is_add = is_add;
11773 static void vl_api_vxlan_tunnel_details_t_handler
11774 (vl_api_vxlan_tunnel_details_t * mp)
11776 vat_main_t *vam = &vat_main;
11777 ip46_address_t src =
11778 to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
11779 ip46_address_t dst =
11780 to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
11782 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11783 ntohl (mp->sw_if_index),
11784 ntohl (mp->instance),
11785 format_ip46_address, &src, IP46_TYPE_ANY,
11786 format_ip46_address, &dst, IP46_TYPE_ANY,
11787 ntohl (mp->encap_vrf_id),
11788 ntohl (mp->decap_next_index), ntohl (mp->vni),
11789 ntohl (mp->mcast_sw_if_index));
11792 static void vl_api_vxlan_tunnel_details_t_handler_json
11793 (vl_api_vxlan_tunnel_details_t * mp)
11795 vat_main_t *vam = &vat_main;
11796 vat_json_node_t *node = NULL;
11798 if (VAT_JSON_ARRAY != vam->json_tree.type)
11800 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11801 vat_json_init_array (&vam->json_tree);
11803 node = vat_json_array_add (&vam->json_tree);
11805 vat_json_init_object (node);
11806 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11808 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11810 if (mp->src_address.af)
11812 struct in6_addr ip6;
11814 clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
11815 vat_json_object_add_ip6 (node, "src_address", ip6);
11816 clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
11817 vat_json_object_add_ip6 (node, "dst_address", ip6);
11821 struct in_addr ip4;
11823 clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
11824 vat_json_object_add_ip4 (node, "src_address", ip4);
11825 clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
11826 vat_json_object_add_ip4 (node, "dst_address", ip4);
11828 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11829 vat_json_object_add_uint (node, "decap_next_index",
11830 ntohl (mp->decap_next_index));
11831 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11832 vat_json_object_add_uint (node, "mcast_sw_if_index",
11833 ntohl (mp->mcast_sw_if_index));
11837 api_vxlan_tunnel_dump (vat_main_t * vam)
11839 unformat_input_t *i = vam->input;
11840 vl_api_vxlan_tunnel_dump_t *mp;
11841 vl_api_control_ping_t *mp_ping;
11843 u8 sw_if_index_set = 0;
11846 /* Parse args required to build the message */
11847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11849 if (unformat (i, "sw_if_index %d", &sw_if_index))
11850 sw_if_index_set = 1;
11855 if (sw_if_index_set == 0)
11860 if (!vam->json_output)
11862 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11863 "sw_if_index", "instance", "src_address", "dst_address",
11864 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11867 /* Get list of vxlan-tunnel interfaces */
11868 M (VXLAN_TUNNEL_DUMP, mp);
11870 mp->sw_if_index = htonl (sw_if_index);
11874 /* Use a control ping for synchronization */
11875 MPING (CONTROL_PING, mp_ping);
11882 static uword unformat_geneve_decap_next
11883 (unformat_input_t * input, va_list * args)
11885 u32 *result = va_arg (*args, u32 *);
11888 if (unformat (input, "l2"))
11889 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11890 else if (unformat (input, "%d", &tmp))
11898 api_geneve_add_del_tunnel (vat_main_t * vam)
11900 unformat_input_t *line_input = vam->input;
11901 vl_api_geneve_add_del_tunnel_t *mp;
11902 ip46_address_t src, dst;
11904 u8 ipv4_set = 0, ipv6_set = 0;
11908 u32 mcast_sw_if_index = ~0;
11909 u32 encap_vrf_id = 0;
11910 u32 decap_next_index = ~0;
11914 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11915 clib_memset (&src, 0, sizeof src);
11916 clib_memset (&dst, 0, sizeof dst);
11918 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11920 if (unformat (line_input, "del"))
11923 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11929 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11935 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11941 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11946 else if (unformat (line_input, "group %U %U",
11947 unformat_ip4_address, &dst.ip4,
11948 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11950 grp_set = dst_set = 1;
11953 else if (unformat (line_input, "group %U",
11954 unformat_ip4_address, &dst.ip4))
11956 grp_set = dst_set = 1;
11959 else if (unformat (line_input, "group %U %U",
11960 unformat_ip6_address, &dst.ip6,
11961 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11963 grp_set = dst_set = 1;
11966 else if (unformat (line_input, "group %U",
11967 unformat_ip6_address, &dst.ip6))
11969 grp_set = dst_set = 1;
11973 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11975 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11977 else if (unformat (line_input, "decap-next %U",
11978 unformat_geneve_decap_next, &decap_next_index))
11980 else if (unformat (line_input, "vni %d", &vni))
11984 errmsg ("parse error '%U'", format_unformat_error, line_input);
11991 errmsg ("tunnel src address not specified");
11996 errmsg ("tunnel dst address not specified");
12000 if (grp_set && !ip46_address_is_multicast (&dst))
12002 errmsg ("tunnel group address not multicast");
12005 if (grp_set && mcast_sw_if_index == ~0)
12007 errmsg ("tunnel nonexistent multicast device");
12010 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12012 errmsg ("tunnel dst address must be unicast");
12017 if (ipv4_set && ipv6_set)
12019 errmsg ("both IPv4 and IPv6 addresses specified");
12023 if ((vni == 0) || (vni >> 24))
12025 errmsg ("vni not specified or out of range");
12029 M (GENEVE_ADD_DEL_TUNNEL, mp);
12033 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12034 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12038 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12039 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12041 mp->encap_vrf_id = ntohl (encap_vrf_id);
12042 mp->decap_next_index = ntohl (decap_next_index);
12043 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12044 mp->vni = ntohl (vni);
12045 mp->is_add = is_add;
12052 static void vl_api_geneve_tunnel_details_t_handler
12053 (vl_api_geneve_tunnel_details_t * mp)
12055 vat_main_t *vam = &vat_main;
12056 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12057 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12059 if (mp->src_address.af == ADDRESS_IP6)
12061 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12062 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12066 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12067 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12070 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12071 ntohl (mp->sw_if_index),
12072 format_ip46_address, &src, IP46_TYPE_ANY,
12073 format_ip46_address, &dst, IP46_TYPE_ANY,
12074 ntohl (mp->encap_vrf_id),
12075 ntohl (mp->decap_next_index), ntohl (mp->vni),
12076 ntohl (mp->mcast_sw_if_index));
12079 static void vl_api_geneve_tunnel_details_t_handler_json
12080 (vl_api_geneve_tunnel_details_t * mp)
12082 vat_main_t *vam = &vat_main;
12083 vat_json_node_t *node = NULL;
12086 if (VAT_JSON_ARRAY != vam->json_tree.type)
12088 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12089 vat_json_init_array (&vam->json_tree);
12091 node = vat_json_array_add (&vam->json_tree);
12093 vat_json_init_object (node);
12094 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12095 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12098 struct in6_addr ip6;
12100 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12101 vat_json_object_add_ip6 (node, "src_address", ip6);
12102 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12103 vat_json_object_add_ip6 (node, "dst_address", ip6);
12107 struct in_addr ip4;
12109 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12110 vat_json_object_add_ip4 (node, "src_address", ip4);
12111 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12112 vat_json_object_add_ip4 (node, "dst_address", ip4);
12114 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12115 vat_json_object_add_uint (node, "decap_next_index",
12116 ntohl (mp->decap_next_index));
12117 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12118 vat_json_object_add_uint (node, "mcast_sw_if_index",
12119 ntohl (mp->mcast_sw_if_index));
12123 api_geneve_tunnel_dump (vat_main_t * vam)
12125 unformat_input_t *i = vam->input;
12126 vl_api_geneve_tunnel_dump_t *mp;
12127 vl_api_control_ping_t *mp_ping;
12129 u8 sw_if_index_set = 0;
12132 /* Parse args required to build the message */
12133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12135 if (unformat (i, "sw_if_index %d", &sw_if_index))
12136 sw_if_index_set = 1;
12141 if (sw_if_index_set == 0)
12146 if (!vam->json_output)
12148 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12149 "sw_if_index", "local_address", "remote_address",
12150 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12153 /* Get list of geneve-tunnel interfaces */
12154 M (GENEVE_TUNNEL_DUMP, mp);
12156 mp->sw_if_index = htonl (sw_if_index);
12160 /* Use a control ping for synchronization */
12161 M (CONTROL_PING, mp_ping);
12169 api_gre_tunnel_add_del (vat_main_t * vam)
12171 unformat_input_t *line_input = vam->input;
12172 vl_api_address_t src = { }, dst =
12175 vl_api_gre_tunnel_add_del_t *mp;
12176 vl_api_gre_tunnel_type_t t_type;
12180 u32 outer_table_id = 0;
12181 u32 session_id = 0;
12185 t_type = GRE_API_TUNNEL_TYPE_L3;
12187 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12189 if (unformat (line_input, "del"))
12191 else if (unformat (line_input, "instance %d", &instance))
12193 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12197 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12201 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12203 else if (unformat (line_input, "teb"))
12204 t_type = GRE_API_TUNNEL_TYPE_TEB;
12205 else if (unformat (line_input, "erspan %d", &session_id))
12206 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12209 errmsg ("parse error '%U'", format_unformat_error, line_input);
12216 errmsg ("tunnel src address not specified");
12221 errmsg ("tunnel dst address not specified");
12225 M (GRE_TUNNEL_ADD_DEL, mp);
12227 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12228 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12230 mp->tunnel.instance = htonl (instance);
12231 mp->tunnel.outer_table_id = htonl (outer_table_id);
12232 mp->is_add = is_add;
12233 mp->tunnel.session_id = htons ((u16) session_id);
12234 mp->tunnel.type = htonl (t_type);
12241 static void vl_api_gre_tunnel_details_t_handler
12242 (vl_api_gre_tunnel_details_t * mp)
12244 vat_main_t *vam = &vat_main;
12246 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12247 ntohl (mp->tunnel.sw_if_index),
12248 ntohl (mp->tunnel.instance),
12249 format_vl_api_address, &mp->tunnel.src,
12250 format_vl_api_address, &mp->tunnel.dst,
12251 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12252 ntohl (mp->tunnel.session_id));
12255 static void vl_api_gre_tunnel_details_t_handler_json
12256 (vl_api_gre_tunnel_details_t * mp)
12258 vat_main_t *vam = &vat_main;
12259 vat_json_node_t *node = NULL;
12261 if (VAT_JSON_ARRAY != vam->json_tree.type)
12263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12264 vat_json_init_array (&vam->json_tree);
12266 node = vat_json_array_add (&vam->json_tree);
12268 vat_json_init_object (node);
12269 vat_json_object_add_uint (node, "sw_if_index",
12270 ntohl (mp->tunnel.sw_if_index));
12271 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12273 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12274 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12275 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12276 vat_json_object_add_uint (node, "outer_table_id",
12277 ntohl (mp->tunnel.outer_table_id));
12278 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12282 api_gre_tunnel_dump (vat_main_t * vam)
12284 unformat_input_t *i = vam->input;
12285 vl_api_gre_tunnel_dump_t *mp;
12286 vl_api_control_ping_t *mp_ping;
12288 u8 sw_if_index_set = 0;
12291 /* Parse args required to build the message */
12292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12294 if (unformat (i, "sw_if_index %d", &sw_if_index))
12295 sw_if_index_set = 1;
12300 if (sw_if_index_set == 0)
12305 if (!vam->json_output)
12307 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12308 "sw_if_index", "instance", "src_address", "dst_address",
12309 "tunnel_type", "outer_fib_id", "session_id");
12312 /* Get list of gre-tunnel interfaces */
12313 M (GRE_TUNNEL_DUMP, mp);
12315 mp->sw_if_index = htonl (sw_if_index);
12319 /* Use a control ping for synchronization */
12320 MPING (CONTROL_PING, mp_ping);
12328 api_l2_fib_clear_table (vat_main_t * vam)
12330 // unformat_input_t * i = vam->input;
12331 vl_api_l2_fib_clear_table_t *mp;
12334 M (L2_FIB_CLEAR_TABLE, mp);
12342 api_l2_interface_efp_filter (vat_main_t * vam)
12344 unformat_input_t *i = vam->input;
12345 vl_api_l2_interface_efp_filter_t *mp;
12348 u8 sw_if_index_set = 0;
12351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12353 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12354 sw_if_index_set = 1;
12355 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12356 sw_if_index_set = 1;
12357 else if (unformat (i, "enable"))
12359 else if (unformat (i, "disable"))
12363 clib_warning ("parse error '%U'", format_unformat_error, i);
12368 if (sw_if_index_set == 0)
12370 errmsg ("missing sw_if_index");
12374 M (L2_INTERFACE_EFP_FILTER, mp);
12376 mp->sw_if_index = ntohl (sw_if_index);
12377 mp->enable_disable = enable;
12384 #define foreach_vtr_op \
12385 _("disable", L2_VTR_DISABLED) \
12386 _("push-1", L2_VTR_PUSH_1) \
12387 _("push-2", L2_VTR_PUSH_2) \
12388 _("pop-1", L2_VTR_POP_1) \
12389 _("pop-2", L2_VTR_POP_2) \
12390 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12391 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12392 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12393 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12396 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12398 unformat_input_t *i = vam->input;
12399 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12401 u8 sw_if_index_set = 0;
12404 u32 push_dot1q = 1;
12409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12411 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12412 sw_if_index_set = 1;
12413 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12414 sw_if_index_set = 1;
12415 else if (unformat (i, "vtr_op %d", &vtr_op))
12417 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12420 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12422 else if (unformat (i, "tag1 %d", &tag1))
12424 else if (unformat (i, "tag2 %d", &tag2))
12428 clib_warning ("parse error '%U'", format_unformat_error, i);
12433 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12435 errmsg ("missing vtr operation or sw_if_index");
12439 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12440 mp->sw_if_index = ntohl (sw_if_index);
12441 mp->vtr_op = ntohl (vtr_op);
12442 mp->push_dot1q = ntohl (push_dot1q);
12443 mp->tag1 = ntohl (tag1);
12444 mp->tag2 = ntohl (tag2);
12452 api_create_vhost_user_if (vat_main_t * vam)
12454 unformat_input_t *i = vam->input;
12455 vl_api_create_vhost_user_if_t *mp;
12458 u8 file_name_set = 0;
12459 u32 custom_dev_instance = ~0;
12461 u8 use_custom_mac = 0;
12462 u8 disable_mrg_rxbuf = 0;
12463 u8 disable_indirect_desc = 0;
12466 u8 enable_packed = 0;
12469 /* Shut up coverity */
12470 clib_memset (hwaddr, 0, sizeof (hwaddr));
12472 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12474 if (unformat (i, "socket %s", &file_name))
12478 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12480 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12481 use_custom_mac = 1;
12482 else if (unformat (i, "server"))
12484 else if (unformat (i, "disable_mrg_rxbuf"))
12485 disable_mrg_rxbuf = 1;
12486 else if (unformat (i, "disable_indirect_desc"))
12487 disable_indirect_desc = 1;
12488 else if (unformat (i, "gso"))
12490 else if (unformat (i, "packed"))
12492 else if (unformat (i, "tag %s", &tag))
12498 if (file_name_set == 0)
12500 errmsg ("missing socket file name");
12504 if (vec_len (file_name) > 255)
12506 errmsg ("socket file name too long");
12509 vec_add1 (file_name, 0);
12511 M (CREATE_VHOST_USER_IF, mp);
12513 mp->is_server = is_server;
12514 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12515 mp->disable_indirect_desc = disable_indirect_desc;
12516 mp->enable_gso = enable_gso;
12517 mp->enable_packed = enable_packed;
12518 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12519 vec_free (file_name);
12520 if (custom_dev_instance != ~0)
12523 mp->custom_dev_instance = ntohl (custom_dev_instance);
12526 mp->use_custom_mac = use_custom_mac;
12527 clib_memcpy (mp->mac_address, hwaddr, 6);
12529 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12538 api_modify_vhost_user_if (vat_main_t * vam)
12540 unformat_input_t *i = vam->input;
12541 vl_api_modify_vhost_user_if_t *mp;
12544 u8 file_name_set = 0;
12545 u32 custom_dev_instance = ~0;
12546 u8 sw_if_index_set = 0;
12547 u32 sw_if_index = (u32) ~ 0;
12549 u8 enable_packed = 0;
12552 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12554 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12555 sw_if_index_set = 1;
12556 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12557 sw_if_index_set = 1;
12558 else if (unformat (i, "socket %s", &file_name))
12562 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12564 else if (unformat (i, "server"))
12566 else if (unformat (i, "gso"))
12568 else if (unformat (i, "packed"))
12574 if (sw_if_index_set == 0)
12576 errmsg ("missing sw_if_index or interface name");
12580 if (file_name_set == 0)
12582 errmsg ("missing socket file name");
12586 if (vec_len (file_name) > 255)
12588 errmsg ("socket file name too long");
12591 vec_add1 (file_name, 0);
12593 M (MODIFY_VHOST_USER_IF, mp);
12595 mp->sw_if_index = ntohl (sw_if_index);
12596 mp->is_server = is_server;
12597 mp->enable_gso = enable_gso;
12598 mp->enable_packed = enable_packed;
12599 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12600 vec_free (file_name);
12601 if (custom_dev_instance != ~0)
12604 mp->custom_dev_instance = ntohl (custom_dev_instance);
12613 api_delete_vhost_user_if (vat_main_t * vam)
12615 unformat_input_t *i = vam->input;
12616 vl_api_delete_vhost_user_if_t *mp;
12617 u32 sw_if_index = ~0;
12618 u8 sw_if_index_set = 0;
12621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12623 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12624 sw_if_index_set = 1;
12625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12626 sw_if_index_set = 1;
12631 if (sw_if_index_set == 0)
12633 errmsg ("missing sw_if_index or interface name");
12638 M (DELETE_VHOST_USER_IF, mp);
12640 mp->sw_if_index = ntohl (sw_if_index);
12647 static void vl_api_sw_interface_vhost_user_details_t_handler
12648 (vl_api_sw_interface_vhost_user_details_t * mp)
12650 vat_main_t *vam = &vat_main;
12654 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12655 clib_net_to_host_u32
12656 (mp->features_last_32) <<
12659 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12660 (char *) mp->interface_name,
12661 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12662 features, mp->is_server,
12663 ntohl (mp->num_regions), (char *) mp->sock_filename);
12664 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12667 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12668 (vl_api_sw_interface_vhost_user_details_t * mp)
12670 vat_main_t *vam = &vat_main;
12671 vat_json_node_t *node = NULL;
12673 if (VAT_JSON_ARRAY != vam->json_tree.type)
12675 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12676 vat_json_init_array (&vam->json_tree);
12678 node = vat_json_array_add (&vam->json_tree);
12680 vat_json_init_object (node);
12681 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12682 vat_json_object_add_string_copy (node, "interface_name",
12683 mp->interface_name);
12684 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12685 ntohl (mp->virtio_net_hdr_sz));
12686 vat_json_object_add_uint (node, "features_first_32",
12687 clib_net_to_host_u32 (mp->features_first_32));
12688 vat_json_object_add_uint (node, "features_last_32",
12689 clib_net_to_host_u32 (mp->features_last_32));
12690 vat_json_object_add_uint (node, "is_server", mp->is_server);
12691 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12692 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12693 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12697 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12699 unformat_input_t *i = vam->input;
12700 vl_api_sw_interface_vhost_user_dump_t *mp;
12701 vl_api_control_ping_t *mp_ping;
12703 u32 sw_if_index = ~0;
12705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12707 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12709 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12716 "Interface name idx hdr_sz features server regions filename");
12718 /* Get list of vhost-user interfaces */
12719 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12720 mp->sw_if_index = ntohl (sw_if_index);
12723 /* Use a control ping for synchronization */
12724 MPING (CONTROL_PING, mp_ping);
12732 api_show_version (vat_main_t * vam)
12734 vl_api_show_version_t *mp;
12737 M (SHOW_VERSION, mp);
12746 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12748 unformat_input_t *line_input = vam->input;
12749 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12750 ip46_address_t local, remote;
12755 u32 mcast_sw_if_index = ~0;
12756 u32 encap_vrf_id = 0;
12757 u32 decap_vrf_id = 0;
12763 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12765 if (unformat (line_input, "del"))
12767 else if (unformat (line_input, "local %U",
12768 unformat_ip46_address, &local))
12772 else if (unformat (line_input, "remote %U",
12773 unformat_ip46_address, &remote))
12777 else if (unformat (line_input, "group %U %U",
12778 unformat_ip46_address, &remote,
12779 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12781 grp_set = remote_set = 1;
12783 else if (unformat (line_input, "group %U",
12784 unformat_ip46_address, &remote))
12786 grp_set = remote_set = 1;
12789 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12791 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12793 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12795 else if (unformat (line_input, "vni %d", &vni))
12797 else if (unformat (line_input, "next-ip4"))
12799 else if (unformat (line_input, "next-ip6"))
12801 else if (unformat (line_input, "next-ethernet"))
12803 else if (unformat (line_input, "next-nsh"))
12807 errmsg ("parse error '%U'", format_unformat_error, line_input);
12812 if (local_set == 0)
12814 errmsg ("tunnel local address not specified");
12817 if (remote_set == 0)
12819 errmsg ("tunnel remote address not specified");
12822 if (grp_set && mcast_sw_if_index == ~0)
12824 errmsg ("tunnel nonexistent multicast device");
12827 if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
12829 errmsg ("both IPv4 and IPv6 addresses specified");
12835 errmsg ("vni not specified");
12839 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12841 ip_address_encode (&local,
12842 ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
12843 IP46_TYPE_IP6, &mp->local);
12844 ip_address_encode (&remote,
12845 ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
12846 IP46_TYPE_IP6, &mp->remote);
12848 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12849 mp->encap_vrf_id = ntohl (encap_vrf_id);
12850 mp->decap_vrf_id = ntohl (decap_vrf_id);
12851 mp->protocol = protocol;
12852 mp->vni = ntohl (vni);
12853 mp->is_add = is_add;
12860 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12861 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12863 vat_main_t *vam = &vat_main;
12864 ip46_address_t local, remote;
12866 ip_address_decode (&mp->local, &local);
12867 ip_address_decode (&mp->remote, &remote);
12869 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12870 ntohl (mp->sw_if_index),
12871 format_ip46_address, &local, IP46_TYPE_ANY,
12872 format_ip46_address, &remote, IP46_TYPE_ANY,
12873 ntohl (mp->vni), mp->protocol,
12874 ntohl (mp->mcast_sw_if_index),
12875 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12879 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12880 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12882 vat_main_t *vam = &vat_main;
12883 vat_json_node_t *node = NULL;
12884 struct in_addr ip4;
12885 struct in6_addr ip6;
12886 ip46_address_t local, remote;
12888 ip_address_decode (&mp->local, &local);
12889 ip_address_decode (&mp->remote, &remote);
12891 if (VAT_JSON_ARRAY != vam->json_tree.type)
12893 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12894 vat_json_init_array (&vam->json_tree);
12896 node = vat_json_array_add (&vam->json_tree);
12898 vat_json_init_object (node);
12899 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12900 if (ip46_address_is_ip4 (&local))
12902 clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
12903 vat_json_object_add_ip4 (node, "local", ip4);
12904 clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
12905 vat_json_object_add_ip4 (node, "remote", ip4);
12909 clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
12910 vat_json_object_add_ip6 (node, "local", ip6);
12911 clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
12912 vat_json_object_add_ip6 (node, "remote", ip6);
12914 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12915 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12916 vat_json_object_add_uint (node, "mcast_sw_if_index",
12917 ntohl (mp->mcast_sw_if_index));
12918 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12919 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12920 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12924 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12926 unformat_input_t *i = vam->input;
12927 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12928 vl_api_control_ping_t *mp_ping;
12930 u8 sw_if_index_set = 0;
12933 /* Parse args required to build the message */
12934 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12936 if (unformat (i, "sw_if_index %d", &sw_if_index))
12937 sw_if_index_set = 1;
12942 if (sw_if_index_set == 0)
12947 if (!vam->json_output)
12949 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12950 "sw_if_index", "local", "remote", "vni",
12951 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12954 /* Get list of vxlan-tunnel interfaces */
12955 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12957 mp->sw_if_index = htonl (sw_if_index);
12961 /* Use a control ping for synchronization */
12962 MPING (CONTROL_PING, mp_ping);
12969 static void vl_api_l2_fib_table_details_t_handler
12970 (vl_api_l2_fib_table_details_t * mp)
12972 vat_main_t *vam = &vat_main;
12974 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12976 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12977 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12981 static void vl_api_l2_fib_table_details_t_handler_json
12982 (vl_api_l2_fib_table_details_t * mp)
12984 vat_main_t *vam = &vat_main;
12985 vat_json_node_t *node = NULL;
12987 if (VAT_JSON_ARRAY != vam->json_tree.type)
12989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12990 vat_json_init_array (&vam->json_tree);
12992 node = vat_json_array_add (&vam->json_tree);
12994 vat_json_init_object (node);
12995 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12996 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12997 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12998 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12999 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13000 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13004 api_l2_fib_table_dump (vat_main_t * vam)
13006 unformat_input_t *i = vam->input;
13007 vl_api_l2_fib_table_dump_t *mp;
13008 vl_api_control_ping_t *mp_ping;
13013 /* Parse args required to build the message */
13014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13016 if (unformat (i, "bd_id %d", &bd_id))
13022 if (bd_id_set == 0)
13024 errmsg ("missing bridge domain");
13028 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13030 /* Get list of l2 fib entries */
13031 M (L2_FIB_TABLE_DUMP, mp);
13033 mp->bd_id = ntohl (bd_id);
13036 /* Use a control ping for synchronization */
13037 MPING (CONTROL_PING, mp_ping);
13046 api_interface_name_renumber (vat_main_t * vam)
13048 unformat_input_t *line_input = vam->input;
13049 vl_api_interface_name_renumber_t *mp;
13050 u32 sw_if_index = ~0;
13051 u32 new_show_dev_instance = ~0;
13054 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13056 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13059 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13061 else if (unformat (line_input, "new_show_dev_instance %d",
13062 &new_show_dev_instance))
13068 if (sw_if_index == ~0)
13070 errmsg ("missing interface name or sw_if_index");
13074 if (new_show_dev_instance == ~0)
13076 errmsg ("missing new_show_dev_instance");
13080 M (INTERFACE_NAME_RENUMBER, mp);
13082 mp->sw_if_index = ntohl (sw_if_index);
13083 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13091 api_want_l2_macs_events (vat_main_t * vam)
13093 unformat_input_t *line_input = vam->input;
13094 vl_api_want_l2_macs_events_t *mp;
13095 u8 enable_disable = 1;
13096 u32 scan_delay = 0;
13097 u32 max_macs_in_event = 0;
13098 u32 learn_limit = 0;
13101 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13103 if (unformat (line_input, "learn-limit %d", &learn_limit))
13105 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13107 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13109 else if (unformat (line_input, "disable"))
13110 enable_disable = 0;
13115 M (WANT_L2_MACS_EVENTS, mp);
13116 mp->enable_disable = enable_disable;
13117 mp->pid = htonl (getpid ());
13118 mp->learn_limit = htonl (learn_limit);
13119 mp->scan_delay = (u8) scan_delay;
13120 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13127 api_input_acl_set_interface (vat_main_t * vam)
13129 unformat_input_t *i = vam->input;
13130 vl_api_input_acl_set_interface_t *mp;
13132 int sw_if_index_set;
13133 u32 ip4_table_index = ~0;
13134 u32 ip6_table_index = ~0;
13135 u32 l2_table_index = ~0;
13139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13141 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13142 sw_if_index_set = 1;
13143 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13144 sw_if_index_set = 1;
13145 else if (unformat (i, "del"))
13147 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13149 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13151 else if (unformat (i, "l2-table %d", &l2_table_index))
13155 clib_warning ("parse error '%U'", format_unformat_error, i);
13160 if (sw_if_index_set == 0)
13162 errmsg ("missing interface name or sw_if_index");
13166 M (INPUT_ACL_SET_INTERFACE, mp);
13168 mp->sw_if_index = ntohl (sw_if_index);
13169 mp->ip4_table_index = ntohl (ip4_table_index);
13170 mp->ip6_table_index = ntohl (ip6_table_index);
13171 mp->l2_table_index = ntohl (l2_table_index);
13172 mp->is_add = is_add;
13180 api_output_acl_set_interface (vat_main_t * vam)
13182 unformat_input_t *i = vam->input;
13183 vl_api_output_acl_set_interface_t *mp;
13185 int sw_if_index_set;
13186 u32 ip4_table_index = ~0;
13187 u32 ip6_table_index = ~0;
13188 u32 l2_table_index = ~0;
13192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13194 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13195 sw_if_index_set = 1;
13196 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13197 sw_if_index_set = 1;
13198 else if (unformat (i, "del"))
13200 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13202 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13204 else if (unformat (i, "l2-table %d", &l2_table_index))
13208 clib_warning ("parse error '%U'", format_unformat_error, i);
13213 if (sw_if_index_set == 0)
13215 errmsg ("missing interface name or sw_if_index");
13219 M (OUTPUT_ACL_SET_INTERFACE, mp);
13221 mp->sw_if_index = ntohl (sw_if_index);
13222 mp->ip4_table_index = ntohl (ip4_table_index);
13223 mp->ip6_table_index = ntohl (ip6_table_index);
13224 mp->l2_table_index = ntohl (l2_table_index);
13225 mp->is_add = is_add;
13233 api_ip_address_dump (vat_main_t * vam)
13235 unformat_input_t *i = vam->input;
13236 vl_api_ip_address_dump_t *mp;
13237 vl_api_control_ping_t *mp_ping;
13238 u32 sw_if_index = ~0;
13239 u8 sw_if_index_set = 0;
13244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13246 if (unformat (i, "sw_if_index %d", &sw_if_index))
13247 sw_if_index_set = 1;
13249 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13250 sw_if_index_set = 1;
13251 else if (unformat (i, "ipv4"))
13253 else if (unformat (i, "ipv6"))
13259 if (ipv4_set && ipv6_set)
13261 errmsg ("ipv4 and ipv6 flags cannot be both set");
13265 if ((!ipv4_set) && (!ipv6_set))
13267 errmsg ("no ipv4 nor ipv6 flag set");
13271 if (sw_if_index_set == 0)
13273 errmsg ("missing interface name or sw_if_index");
13277 vam->current_sw_if_index = sw_if_index;
13278 vam->is_ipv6 = ipv6_set;
13280 M (IP_ADDRESS_DUMP, mp);
13281 mp->sw_if_index = ntohl (sw_if_index);
13282 mp->is_ipv6 = ipv6_set;
13285 /* Use a control ping for synchronization */
13286 MPING (CONTROL_PING, mp_ping);
13294 api_ip_dump (vat_main_t * vam)
13296 vl_api_ip_dump_t *mp;
13297 vl_api_control_ping_t *mp_ping;
13298 unformat_input_t *in = vam->input;
13305 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13307 if (unformat (in, "ipv4"))
13309 else if (unformat (in, "ipv6"))
13315 if (ipv4_set && ipv6_set)
13317 errmsg ("ipv4 and ipv6 flags cannot be both set");
13321 if ((!ipv4_set) && (!ipv6_set))
13323 errmsg ("no ipv4 nor ipv6 flag set");
13327 is_ipv6 = ipv6_set;
13328 vam->is_ipv6 = is_ipv6;
13330 /* free old data */
13331 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13333 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13335 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13338 mp->is_ipv6 = ipv6_set;
13341 /* Use a control ping for synchronization */
13342 MPING (CONTROL_PING, mp_ping);
13350 api_ipsec_spd_add_del (vat_main_t * vam)
13352 unformat_input_t *i = vam->input;
13353 vl_api_ipsec_spd_add_del_t *mp;
13358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13360 if (unformat (i, "spd_id %d", &spd_id))
13362 else if (unformat (i, "del"))
13366 clib_warning ("parse error '%U'", format_unformat_error, i);
13372 errmsg ("spd_id must be set");
13376 M (IPSEC_SPD_ADD_DEL, mp);
13378 mp->spd_id = ntohl (spd_id);
13379 mp->is_add = is_add;
13387 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13389 unformat_input_t *i = vam->input;
13390 vl_api_ipsec_interface_add_del_spd_t *mp;
13392 u8 sw_if_index_set = 0;
13393 u32 spd_id = (u32) ~ 0;
13397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13399 if (unformat (i, "del"))
13401 else if (unformat (i, "spd_id %d", &spd_id))
13404 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13405 sw_if_index_set = 1;
13406 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13407 sw_if_index_set = 1;
13410 clib_warning ("parse error '%U'", format_unformat_error, i);
13416 if (spd_id == (u32) ~ 0)
13418 errmsg ("spd_id must be set");
13422 if (sw_if_index_set == 0)
13424 errmsg ("missing interface name or sw_if_index");
13428 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13430 mp->spd_id = ntohl (spd_id);
13431 mp->sw_if_index = ntohl (sw_if_index);
13432 mp->is_add = is_add;
13440 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13442 unformat_input_t *i = vam->input;
13443 vl_api_ipsec_spd_entry_add_del_t *mp;
13444 u8 is_add = 1, is_outbound = 0;
13445 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13447 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13448 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13449 vl_api_address_t laddr_start = { }, laddr_stop =
13458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13460 if (unformat (i, "del"))
13462 if (unformat (i, "outbound"))
13464 if (unformat (i, "inbound"))
13466 else if (unformat (i, "spd_id %d", &spd_id))
13468 else if (unformat (i, "sa_id %d", &sa_id))
13470 else if (unformat (i, "priority %d", &priority))
13472 else if (unformat (i, "protocol %d", &protocol))
13474 else if (unformat (i, "lport_start %d", &lport_start))
13476 else if (unformat (i, "lport_stop %d", &lport_stop))
13478 else if (unformat (i, "rport_start %d", &rport_start))
13480 else if (unformat (i, "rport_stop %d", &rport_stop))
13482 else if (unformat (i, "laddr_start %U",
13483 unformat_vl_api_address, &laddr_start))
13485 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13488 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13491 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13495 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13497 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13499 clib_warning ("unsupported action: 'resolve'");
13505 clib_warning ("parse error '%U'", format_unformat_error, i);
13511 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13513 mp->is_add = is_add;
13515 mp->entry.spd_id = ntohl (spd_id);
13516 mp->entry.priority = ntohl (priority);
13517 mp->entry.is_outbound = is_outbound;
13519 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13520 sizeof (vl_api_address_t));
13521 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13522 sizeof (vl_api_address_t));
13523 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13524 sizeof (vl_api_address_t));
13525 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13526 sizeof (vl_api_address_t));
13528 mp->entry.protocol = (u8) protocol;
13529 mp->entry.local_port_start = ntohs ((u16) lport_start);
13530 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13531 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13532 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13533 mp->entry.policy = (u8) policy;
13534 mp->entry.sa_id = ntohl (sa_id);
13542 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13544 unformat_input_t *i = vam->input;
13545 vl_api_ipsec_sad_entry_add_del_t *mp;
13546 u32 sad_id = 0, spi = 0;
13547 u8 *ck = 0, *ik = 0;
13550 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13551 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13552 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13553 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13554 vl_api_address_t tun_src, tun_dst;
13557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13559 if (unformat (i, "del"))
13561 else if (unformat (i, "sad_id %d", &sad_id))
13563 else if (unformat (i, "spi %d", &spi))
13565 else if (unformat (i, "esp"))
13566 protocol = IPSEC_API_PROTO_ESP;
13568 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13570 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13571 if (ADDRESS_IP6 == tun_src.af)
13572 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13575 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13577 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13578 if (ADDRESS_IP6 == tun_src.af)
13579 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13582 if (unformat (i, "crypto_alg %U",
13583 unformat_ipsec_api_crypto_alg, &crypto_alg))
13585 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13587 else if (unformat (i, "integ_alg %U",
13588 unformat_ipsec_api_integ_alg, &integ_alg))
13590 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13594 clib_warning ("parse error '%U'", format_unformat_error, i);
13600 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13602 mp->is_add = is_add;
13603 mp->entry.sad_id = ntohl (sad_id);
13604 mp->entry.protocol = protocol;
13605 mp->entry.spi = ntohl (spi);
13606 mp->entry.flags = flags;
13608 mp->entry.crypto_algorithm = crypto_alg;
13609 mp->entry.integrity_algorithm = integ_alg;
13610 mp->entry.crypto_key.length = vec_len (ck);
13611 mp->entry.integrity_key.length = vec_len (ik);
13613 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13614 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13616 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13617 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13620 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13622 clib_memcpy (mp->entry.integrity_key.data, ik,
13623 mp->entry.integrity_key.length);
13625 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13627 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13628 sizeof (mp->entry.tunnel_src));
13629 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13630 sizeof (mp->entry.tunnel_dst));
13639 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13641 unformat_input_t *i = vam->input;
13642 vl_api_ipsec_tunnel_if_add_del_t *mp;
13643 u32 local_spi = 0, remote_spi = 0;
13644 u32 crypto_alg = 0, integ_alg = 0;
13645 u8 *lck = NULL, *rck = NULL;
13646 u8 *lik = NULL, *rik = NULL;
13647 vl_api_address_t local_ip = { 0 };
13648 vl_api_address_t remote_ip = { 0 };
13652 u8 anti_replay = 0;
13658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13660 if (unformat (i, "del"))
13662 else if (unformat (i, "esn"))
13664 else if (unformat (i, "anti-replay"))
13666 else if (unformat (i, "count %d", &count))
13668 else if (unformat (i, "local_spi %d", &local_spi))
13670 else if (unformat (i, "remote_spi %d", &remote_spi))
13673 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13676 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13678 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13681 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13683 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13685 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13689 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13691 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13693 errmsg ("unsupported crypto-alg: '%U'\n",
13694 format_ipsec_crypto_alg, crypto_alg);
13700 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13702 if (integ_alg >= IPSEC_INTEG_N_ALG)
13704 errmsg ("unsupported integ-alg: '%U'\n",
13705 format_ipsec_integ_alg, integ_alg);
13709 else if (unformat (i, "instance %u", &instance))
13713 errmsg ("parse error '%U'\n", format_unformat_error, i);
13720 /* Turn on async mode */
13721 vam->async_mode = 1;
13722 vam->async_errors = 0;
13723 before = vat_time_now (vam);
13726 for (jj = 0; jj < count; jj++)
13728 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13730 mp->is_add = is_add;
13732 mp->anti_replay = anti_replay;
13735 increment_address (&remote_ip);
13737 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13738 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13740 mp->local_spi = htonl (local_spi + jj);
13741 mp->remote_spi = htonl (remote_spi + jj);
13742 mp->crypto_alg = (u8) crypto_alg;
13744 mp->local_crypto_key_len = 0;
13747 mp->local_crypto_key_len = vec_len (lck);
13748 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13749 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13750 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13753 mp->remote_crypto_key_len = 0;
13756 mp->remote_crypto_key_len = vec_len (rck);
13757 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13758 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13759 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13762 mp->integ_alg = (u8) integ_alg;
13764 mp->local_integ_key_len = 0;
13767 mp->local_integ_key_len = vec_len (lik);
13768 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13769 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13770 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13773 mp->remote_integ_key_len = 0;
13776 mp->remote_integ_key_len = vec_len (rik);
13777 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13778 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13779 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13784 mp->renumber = renumber;
13785 mp->show_instance = ntohl (instance);
13790 /* When testing multiple add/del ops, use a control-ping to sync */
13793 vl_api_control_ping_t *mp_ping;
13797 /* Shut off async mode */
13798 vam->async_mode = 0;
13800 MPING (CONTROL_PING, mp_ping);
13803 timeout = vat_time_now (vam) + 1.0;
13804 while (vat_time_now (vam) < timeout)
13805 if (vam->result_ready == 1)
13810 if (vam->retval == -99)
13811 errmsg ("timeout");
13813 if (vam->async_errors > 0)
13815 errmsg ("%d asynchronous errors", vam->async_errors);
13818 vam->async_errors = 0;
13819 after = vat_time_now (vam);
13821 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13825 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13826 count, after - before, count / (after - before));
13830 /* Wait for a reply... */
13839 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13841 vat_main_t *vam = &vat_main;
13843 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13844 "crypto_key %U integ_alg %u integ_key %U flags %x "
13845 "tunnel_src_addr %U tunnel_dst_addr %U "
13846 "salt %u seq_outbound %lu last_seq_inbound %lu "
13847 "replay_window %lu stat_index %u\n",
13848 ntohl (mp->entry.sad_id),
13849 ntohl (mp->sw_if_index),
13850 ntohl (mp->entry.spi),
13851 ntohl (mp->entry.protocol),
13852 ntohl (mp->entry.crypto_algorithm),
13853 format_hex_bytes, mp->entry.crypto_key.data,
13854 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13855 format_hex_bytes, mp->entry.integrity_key.data,
13856 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13857 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13858 &mp->entry.tunnel_dst, ntohl (mp->salt),
13859 clib_net_to_host_u64 (mp->seq_outbound),
13860 clib_net_to_host_u64 (mp->last_seq_inbound),
13861 clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
13864 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13865 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13867 static void vl_api_ipsec_sa_details_t_handler_json
13868 (vl_api_ipsec_sa_details_t * mp)
13870 vat_main_t *vam = &vat_main;
13871 vat_json_node_t *node = NULL;
13872 vl_api_ipsec_sad_flags_t flags;
13874 if (VAT_JSON_ARRAY != vam->json_tree.type)
13876 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13877 vat_json_init_array (&vam->json_tree);
13879 node = vat_json_array_add (&vam->json_tree);
13881 vat_json_init_object (node);
13882 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13883 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13884 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13885 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13886 vat_json_object_add_uint (node, "crypto_alg",
13887 ntohl (mp->entry.crypto_algorithm));
13888 vat_json_object_add_uint (node, "integ_alg",
13889 ntohl (mp->entry.integrity_algorithm));
13890 flags = ntohl (mp->entry.flags);
13891 vat_json_object_add_uint (node, "use_esn",
13892 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13893 vat_json_object_add_uint (node, "use_anti_replay",
13894 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13895 vat_json_object_add_uint (node, "is_tunnel",
13896 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13897 vat_json_object_add_uint (node, "is_tunnel_ip6",
13898 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13899 vat_json_object_add_uint (node, "udp_encap",
13900 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13901 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13902 mp->entry.crypto_key.length);
13903 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13904 mp->entry.integrity_key.length);
13905 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13906 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13907 vat_json_object_add_uint (node, "replay_window",
13908 clib_net_to_host_u64 (mp->replay_window));
13909 vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
13913 api_ipsec_sa_dump (vat_main_t * vam)
13915 unformat_input_t *i = vam->input;
13916 vl_api_ipsec_sa_dump_t *mp;
13917 vl_api_control_ping_t *mp_ping;
13921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13923 if (unformat (i, "sa_id %d", &sa_id))
13927 clib_warning ("parse error '%U'", format_unformat_error, i);
13932 M (IPSEC_SA_DUMP, mp);
13934 mp->sa_id = ntohl (sa_id);
13938 /* Use a control ping for synchronization */
13939 M (CONTROL_PING, mp_ping);
13947 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13949 unformat_input_t *i = vam->input;
13950 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13951 u32 sw_if_index = ~0;
13953 u8 is_outbound = (u8) ~ 0;
13956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13958 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13960 else if (unformat (i, "sa_id %d", &sa_id))
13962 else if (unformat (i, "outbound"))
13964 else if (unformat (i, "inbound"))
13968 clib_warning ("parse error '%U'", format_unformat_error, i);
13973 if (sw_if_index == ~0)
13975 errmsg ("interface must be specified");
13981 errmsg ("SA ID must be specified");
13985 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13987 mp->sw_if_index = htonl (sw_if_index);
13988 mp->sa_id = htonl (sa_id);
13989 mp->is_outbound = is_outbound;
13998 api_get_first_msg_id (vat_main_t * vam)
14000 vl_api_get_first_msg_id_t *mp;
14001 unformat_input_t *i = vam->input;
14006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14008 if (unformat (i, "client %s", &name))
14016 errmsg ("missing client name");
14019 vec_add1 (name, 0);
14021 if (vec_len (name) > 63)
14023 errmsg ("client name too long");
14027 M (GET_FIRST_MSG_ID, mp);
14028 clib_memcpy (mp->name, name, vec_len (name));
14035 api_cop_interface_enable_disable (vat_main_t * vam)
14037 unformat_input_t *line_input = vam->input;
14038 vl_api_cop_interface_enable_disable_t *mp;
14039 u32 sw_if_index = ~0;
14040 u8 enable_disable = 1;
14043 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14045 if (unformat (line_input, "disable"))
14046 enable_disable = 0;
14047 if (unformat (line_input, "enable"))
14048 enable_disable = 1;
14049 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14050 vam, &sw_if_index))
14052 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14058 if (sw_if_index == ~0)
14060 errmsg ("missing interface name or sw_if_index");
14064 /* Construct the API message */
14065 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14066 mp->sw_if_index = ntohl (sw_if_index);
14067 mp->enable_disable = enable_disable;
14071 /* Wait for the reply */
14077 api_cop_whitelist_enable_disable (vat_main_t * vam)
14079 unformat_input_t *line_input = vam->input;
14080 vl_api_cop_whitelist_enable_disable_t *mp;
14081 u32 sw_if_index = ~0;
14082 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14086 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14088 if (unformat (line_input, "ip4"))
14090 else if (unformat (line_input, "ip6"))
14092 else if (unformat (line_input, "default"))
14094 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14095 vam, &sw_if_index))
14097 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14099 else if (unformat (line_input, "fib-id %d", &fib_id))
14105 if (sw_if_index == ~0)
14107 errmsg ("missing interface name or sw_if_index");
14111 /* Construct the API message */
14112 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14113 mp->sw_if_index = ntohl (sw_if_index);
14114 mp->fib_id = ntohl (fib_id);
14117 mp->default_cop = default_cop;
14121 /* Wait for the reply */
14127 api_get_node_graph (vat_main_t * vam)
14129 vl_api_get_node_graph_t *mp;
14132 M (GET_NODE_GRAPH, mp);
14136 /* Wait for the reply */
14142 /** Used for parsing LISP eids */
14143 typedef CLIB_PACKED(struct{
14147 lisp_nsh_api_t nsh;
14149 u32 len; /**< prefix length if IP */
14150 u8 type; /**< type of eid */
14155 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14157 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14159 clib_memset (a, 0, sizeof (a[0]));
14161 if (unformat (input, "%U/%d", unformat_ip46_address, a->addr.ip, &a->len))
14163 a->type = 0; /* ip prefix type */
14165 else if (unformat (input, "%U", unformat_ethernet_address, a->addr.mac))
14167 a->type = 1; /* mac type */
14169 else if (unformat (input, "%U", unformat_nsh_address, a->addr.nsh))
14171 a->type = 2; /* NSH type */
14172 a->addr.nsh.spi = clib_host_to_net_u32 (a->addr.nsh.spi);
14181 if (ip46_address_is_ip4 (&a->addr.ip))
14182 return a->len > 32 ? 1 : 0;
14184 return a->len > 128 ? 1 : 0;
14191 lisp_eid_put_vat (vl_api_eid_t * eid, const lisp_eid_vat_t * vat_eid)
14193 eid->type = vat_eid->type;
14196 case EID_TYPE_API_PREFIX:
14197 if (ip46_address_is_ip4 (&vat_eid->addr.ip))
14199 clib_memcpy (&eid->address.prefix.address.un.ip4,
14200 &vat_eid->addr.ip.ip4, 4);
14201 eid->address.prefix.address.af = ADDRESS_IP4;
14202 eid->address.prefix.len = vat_eid->len;
14206 clib_memcpy (&eid->address.prefix.address.un.ip6,
14207 &vat_eid->addr.ip.ip6, 16);
14208 eid->address.prefix.address.af = ADDRESS_IP6;
14209 eid->address.prefix.len = vat_eid->len;
14212 case EID_TYPE_API_MAC:
14213 clib_memcpy (&eid->address.mac, &vat_eid->addr.mac,
14214 sizeof (eid->address.mac));
14216 case EID_TYPE_API_NSH:
14217 clib_memcpy (&eid->address.nsh, &vat_eid->addr.nsh,
14218 sizeof (eid->address.nsh));
14227 api_one_add_del_locator_set (vat_main_t * vam)
14229 unformat_input_t *input = vam->input;
14230 vl_api_one_add_del_locator_set_t *mp;
14232 u8 *locator_set_name = NULL;
14233 u8 locator_set_name_set = 0;
14234 vl_api_local_locator_t locator, *locators = 0;
14235 u32 sw_if_index, priority, weight;
14239 /* Parse args required to build the message */
14240 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14242 if (unformat (input, "del"))
14246 else if (unformat (input, "locator-set %s", &locator_set_name))
14248 locator_set_name_set = 1;
14250 else if (unformat (input, "sw_if_index %u p %u w %u",
14251 &sw_if_index, &priority, &weight))
14253 locator.sw_if_index = htonl (sw_if_index);
14254 locator.priority = priority;
14255 locator.weight = weight;
14256 vec_add1 (locators, locator);
14260 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14261 &sw_if_index, &priority, &weight))
14263 locator.sw_if_index = htonl (sw_if_index);
14264 locator.priority = priority;
14265 locator.weight = weight;
14266 vec_add1 (locators, locator);
14272 if (locator_set_name_set == 0)
14274 errmsg ("missing locator-set name");
14275 vec_free (locators);
14279 if (vec_len (locator_set_name) > 64)
14281 errmsg ("locator-set name too long");
14282 vec_free (locator_set_name);
14283 vec_free (locators);
14286 vec_add1 (locator_set_name, 0);
14288 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14290 /* Construct the API message */
14291 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14293 mp->is_add = is_add;
14294 clib_memcpy (mp->locator_set_name, locator_set_name,
14295 vec_len (locator_set_name));
14296 vec_free (locator_set_name);
14298 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14300 clib_memcpy (mp->locators, locators, data_len);
14301 vec_free (locators);
14306 /* Wait for a reply... */
14311 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14314 api_one_add_del_locator (vat_main_t * vam)
14316 unformat_input_t *input = vam->input;
14317 vl_api_one_add_del_locator_t *mp;
14318 u32 tmp_if_index = ~0;
14319 u32 sw_if_index = ~0;
14320 u8 sw_if_index_set = 0;
14321 u8 sw_if_index_if_name_set = 0;
14323 u8 priority_set = 0;
14327 u8 *locator_set_name = NULL;
14328 u8 locator_set_name_set = 0;
14331 /* Parse args required to build the message */
14332 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14334 if (unformat (input, "del"))
14338 else if (unformat (input, "locator-set %s", &locator_set_name))
14340 locator_set_name_set = 1;
14342 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14345 sw_if_index_if_name_set = 1;
14346 sw_if_index = tmp_if_index;
14348 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14350 sw_if_index_set = 1;
14351 sw_if_index = tmp_if_index;
14353 else if (unformat (input, "p %d", &priority))
14357 else if (unformat (input, "w %d", &weight))
14365 if (locator_set_name_set == 0)
14367 errmsg ("missing locator-set name");
14371 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14373 errmsg ("missing sw_if_index");
14374 vec_free (locator_set_name);
14378 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14380 errmsg ("cannot use both params interface name and sw_if_index");
14381 vec_free (locator_set_name);
14385 if (priority_set == 0)
14387 errmsg ("missing locator-set priority");
14388 vec_free (locator_set_name);
14392 if (weight_set == 0)
14394 errmsg ("missing locator-set weight");
14395 vec_free (locator_set_name);
14399 if (vec_len (locator_set_name) > 64)
14401 errmsg ("locator-set name too long");
14402 vec_free (locator_set_name);
14405 vec_add1 (locator_set_name, 0);
14407 /* Construct the API message */
14408 M (ONE_ADD_DEL_LOCATOR, mp);
14410 mp->is_add = is_add;
14411 mp->sw_if_index = ntohl (sw_if_index);
14412 mp->priority = priority;
14413 mp->weight = weight;
14414 clib_memcpy (mp->locator_set_name, locator_set_name,
14415 vec_len (locator_set_name));
14416 vec_free (locator_set_name);
14421 /* Wait for a reply... */
14426 #define api_lisp_add_del_locator api_one_add_del_locator
14429 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14431 u32 *key_id = va_arg (*args, u32 *);
14434 if (unformat (input, "%s", &s))
14436 if (!strcmp ((char *) s, "sha1"))
14437 key_id[0] = HMAC_SHA_1_96;
14438 else if (!strcmp ((char *) s, "sha256"))
14439 key_id[0] = HMAC_SHA_256_128;
14442 clib_warning ("invalid key_id: '%s'", s);
14443 key_id[0] = HMAC_NO_KEY;
14454 api_one_add_del_local_eid (vat_main_t * vam)
14456 unformat_input_t *input = vam->input;
14457 vl_api_one_add_del_local_eid_t *mp;
14460 lisp_eid_vat_t _eid, *eid = &_eid;
14461 u8 *locator_set_name = 0;
14462 u8 locator_set_name_set = 0;
14468 /* Parse args required to build the message */
14469 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14471 if (unformat (input, "del"))
14475 else if (unformat (input, "vni %d", &vni))
14479 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14483 else if (unformat (input, "locator-set %s", &locator_set_name))
14485 locator_set_name_set = 1;
14487 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14489 else if (unformat (input, "secret-key %_%v%_", &key))
14495 if (locator_set_name_set == 0)
14497 errmsg ("missing locator-set name");
14503 errmsg ("EID address not set!");
14504 vec_free (locator_set_name);
14508 if (key && (0 == key_id))
14510 errmsg ("invalid key_id!");
14514 if (vec_len (key) > 64)
14516 errmsg ("key too long");
14521 if (vec_len (locator_set_name) > 64)
14523 errmsg ("locator-set name too long");
14524 vec_free (locator_set_name);
14527 vec_add1 (locator_set_name, 0);
14529 /* Construct the API message */
14530 M (ONE_ADD_DEL_LOCAL_EID, mp);
14532 mp->is_add = is_add;
14533 lisp_eid_put_vat (&mp->eid, eid);
14534 mp->vni = clib_host_to_net_u32 (vni);
14535 mp->key.id = key_id;
14536 clib_memcpy (mp->locator_set_name, locator_set_name,
14537 vec_len (locator_set_name));
14538 clib_memcpy (mp->key.key, key, vec_len (key));
14540 vec_free (locator_set_name);
14546 /* Wait for a reply... */
14551 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14554 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14556 u32 dp_table = 0, vni = 0;;
14557 unformat_input_t *input = vam->input;
14558 vl_api_gpe_add_del_fwd_entry_t *mp;
14560 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14561 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14562 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14563 u32 action = ~0, w;
14564 ip4_address_t rmt_rloc4, lcl_rloc4;
14565 ip6_address_t rmt_rloc6, lcl_rloc6;
14566 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14569 clib_memset (&rloc, 0, sizeof (rloc));
14571 /* Parse args required to build the message */
14572 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14574 if (unformat (input, "del"))
14576 else if (unformat (input, "add"))
14578 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14582 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14586 else if (unformat (input, "vrf %d", &dp_table))
14588 else if (unformat (input, "bd %d", &dp_table))
14590 else if (unformat (input, "vni %d", &vni))
14592 else if (unformat (input, "w %d", &w))
14596 errmsg ("No RLOC configured for setting priority/weight!");
14599 curr_rloc->weight = w;
14601 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14602 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14605 clib_memcpy (&rloc.addr.un.ip4, &lcl_rloc4, sizeof (lcl_rloc4));
14607 vec_add1 (lcl_locs, rloc);
14609 clib_memcpy (&rloc.addr.un.ip4, &rmt_rloc4, sizeof (rmt_rloc4));
14610 vec_add1 (rmt_locs, rloc);
14611 /* weight saved in rmt loc */
14612 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14614 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14615 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14618 clib_memcpy (&rloc.addr.un.ip6, &lcl_rloc6, sizeof (lcl_rloc6));
14620 vec_add1 (lcl_locs, rloc);
14622 clib_memcpy (&rloc.addr.un.ip6, &rmt_rloc6, sizeof (rmt_rloc6));
14623 vec_add1 (rmt_locs, rloc);
14624 /* weight saved in rmt loc */
14625 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14627 else if (unformat (input, "action %d", &action))
14633 clib_warning ("parse error '%U'", format_unformat_error, input);
14640 errmsg ("remote eid addresses not set");
14644 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14646 errmsg ("eid types don't match");
14650 if (0 == rmt_locs && (u32) ~ 0 == action)
14652 errmsg ("action not set for negative mapping");
14656 /* Construct the API message */
14657 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14658 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14660 mp->is_add = is_add;
14661 lisp_eid_put_vat (&mp->rmt_eid, rmt_eid);
14662 lisp_eid_put_vat (&mp->lcl_eid, lcl_eid);
14663 mp->dp_table = clib_host_to_net_u32 (dp_table);
14664 mp->vni = clib_host_to_net_u32 (vni);
14665 mp->action = action;
14667 if (0 != rmt_locs && 0 != lcl_locs)
14669 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14670 clib_memcpy (mp->locs, lcl_locs,
14671 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14673 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14674 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14675 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14677 vec_free (lcl_locs);
14678 vec_free (rmt_locs);
14683 /* Wait for a reply... */
14689 api_one_add_del_map_server (vat_main_t * vam)
14691 unformat_input_t *input = vam->input;
14692 vl_api_one_add_del_map_server_t *mp;
14696 ip4_address_t ipv4;
14697 ip6_address_t ipv6;
14700 /* Parse args required to build the message */
14701 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14703 if (unformat (input, "del"))
14707 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14711 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14719 if (ipv4_set && ipv6_set)
14721 errmsg ("both eid v4 and v6 addresses set");
14725 if (!ipv4_set && !ipv6_set)
14727 errmsg ("eid addresses not set");
14731 /* Construct the API message */
14732 M (ONE_ADD_DEL_MAP_SERVER, mp);
14734 mp->is_add = is_add;
14737 mp->ip_address.af = 1;
14738 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14742 mp->ip_address.af = 0;
14743 clib_memcpy (mp->ip_address.un.ip4, &ipv4, sizeof (ipv4));
14749 /* Wait for a reply... */
14754 #define api_lisp_add_del_map_server api_one_add_del_map_server
14757 api_one_add_del_map_resolver (vat_main_t * vam)
14759 unformat_input_t *input = vam->input;
14760 vl_api_one_add_del_map_resolver_t *mp;
14764 ip4_address_t ipv4;
14765 ip6_address_t ipv6;
14768 /* Parse args required to build the message */
14769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14771 if (unformat (input, "del"))
14775 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14779 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14787 if (ipv4_set && ipv6_set)
14789 errmsg ("both eid v4 and v6 addresses set");
14793 if (!ipv4_set && !ipv6_set)
14795 errmsg ("eid addresses not set");
14799 /* Construct the API message */
14800 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14802 mp->is_add = is_add;
14805 mp->ip_address.af = 1;
14806 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14810 mp->ip_address.af = 0;
14811 clib_memcpy (mp->ip_address.un.ip6, &ipv4, sizeof (ipv4));
14817 /* Wait for a reply... */
14822 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14825 api_lisp_gpe_enable_disable (vat_main_t * vam)
14827 unformat_input_t *input = vam->input;
14828 vl_api_gpe_enable_disable_t *mp;
14833 /* Parse args required to build the message */
14834 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14836 if (unformat (input, "enable"))
14841 else if (unformat (input, "disable"))
14852 errmsg ("Value not set");
14856 /* Construct the API message */
14857 M (GPE_ENABLE_DISABLE, mp);
14859 mp->is_enable = is_enable;
14864 /* Wait for a reply... */
14870 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14872 unformat_input_t *input = vam->input;
14873 vl_api_one_rloc_probe_enable_disable_t *mp;
14878 /* Parse args required to build the message */
14879 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14881 if (unformat (input, "enable"))
14886 else if (unformat (input, "disable"))
14894 errmsg ("Value not set");
14898 /* Construct the API message */
14899 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14901 mp->is_enable = is_enable;
14906 /* Wait for a reply... */
14911 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14914 api_one_map_register_enable_disable (vat_main_t * vam)
14916 unformat_input_t *input = vam->input;
14917 vl_api_one_map_register_enable_disable_t *mp;
14922 /* Parse args required to build the message */
14923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14925 if (unformat (input, "enable"))
14930 else if (unformat (input, "disable"))
14938 errmsg ("Value not set");
14942 /* Construct the API message */
14943 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14945 mp->is_enable = is_enable;
14950 /* Wait for a reply... */
14955 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14958 api_one_enable_disable (vat_main_t * vam)
14960 unformat_input_t *input = vam->input;
14961 vl_api_one_enable_disable_t *mp;
14966 /* Parse args required to build the message */
14967 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14969 if (unformat (input, "enable"))
14974 else if (unformat (input, "disable"))
14984 errmsg ("Value not set");
14988 /* Construct the API message */
14989 M (ONE_ENABLE_DISABLE, mp);
14991 mp->is_enable = is_enable;
14996 /* Wait for a reply... */
15001 #define api_lisp_enable_disable api_one_enable_disable
15004 api_one_enable_disable_xtr_mode (vat_main_t * vam)
15006 unformat_input_t *input = vam->input;
15007 vl_api_one_enable_disable_xtr_mode_t *mp;
15012 /* Parse args required to build the message */
15013 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15015 if (unformat (input, "enable"))
15020 else if (unformat (input, "disable"))
15030 errmsg ("Value not set");
15034 /* Construct the API message */
15035 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15037 mp->is_enable = is_enable;
15042 /* Wait for a reply... */
15048 api_one_show_xtr_mode (vat_main_t * vam)
15050 vl_api_one_show_xtr_mode_t *mp;
15053 /* Construct the API message */
15054 M (ONE_SHOW_XTR_MODE, mp);
15059 /* Wait for a reply... */
15065 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15067 unformat_input_t *input = vam->input;
15068 vl_api_one_enable_disable_pitr_mode_t *mp;
15073 /* Parse args required to build the message */
15074 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15076 if (unformat (input, "enable"))
15081 else if (unformat (input, "disable"))
15091 errmsg ("Value not set");
15095 /* Construct the API message */
15096 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15098 mp->is_enable = is_enable;
15103 /* Wait for a reply... */
15109 api_one_show_pitr_mode (vat_main_t * vam)
15111 vl_api_one_show_pitr_mode_t *mp;
15114 /* Construct the API message */
15115 M (ONE_SHOW_PITR_MODE, mp);
15120 /* Wait for a reply... */
15126 api_one_enable_disable_petr_mode (vat_main_t * vam)
15128 unformat_input_t *input = vam->input;
15129 vl_api_one_enable_disable_petr_mode_t *mp;
15134 /* Parse args required to build the message */
15135 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15137 if (unformat (input, "enable"))
15142 else if (unformat (input, "disable"))
15152 errmsg ("Value not set");
15156 /* Construct the API message */
15157 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15159 mp->is_enable = is_enable;
15164 /* Wait for a reply... */
15170 api_one_show_petr_mode (vat_main_t * vam)
15172 vl_api_one_show_petr_mode_t *mp;
15175 /* Construct the API message */
15176 M (ONE_SHOW_PETR_MODE, mp);
15181 /* Wait for a reply... */
15187 api_show_one_map_register_state (vat_main_t * vam)
15189 vl_api_show_one_map_register_state_t *mp;
15192 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15197 /* wait for reply */
15202 #define api_show_lisp_map_register_state api_show_one_map_register_state
15205 api_show_one_rloc_probe_state (vat_main_t * vam)
15207 vl_api_show_one_rloc_probe_state_t *mp;
15210 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15215 /* wait for reply */
15220 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15223 api_one_add_del_ndp_entry (vat_main_t * vam)
15225 vl_api_one_add_del_ndp_entry_t *mp;
15226 unformat_input_t *input = vam->input;
15231 u8 mac[6] = { 0, };
15232 u8 ip6[16] = { 0, };
15236 /* Parse args required to build the message */
15237 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15239 if (unformat (input, "del"))
15241 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15243 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15245 else if (unformat (input, "bd %d", &bd))
15249 errmsg ("parse error '%U'", format_unformat_error, input);
15254 if (!bd_set || !ip_set || (!mac_set && is_add))
15256 errmsg ("Missing BD, IP or MAC!");
15260 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15261 mp->is_add = is_add;
15262 clib_memcpy (&mp->entry.mac, mac, 6);
15263 mp->bd = clib_host_to_net_u32 (bd);
15264 clib_memcpy (&mp->entry.ip6, ip6, sizeof (mp->entry.ip6));
15269 /* wait for reply */
15275 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15277 vl_api_one_add_del_l2_arp_entry_t *mp;
15278 unformat_input_t *input = vam->input;
15283 u8 mac[6] = { 0, };
15284 u32 ip4 = 0, bd = ~0;
15287 /* Parse args required to build the message */
15288 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15290 if (unformat (input, "del"))
15292 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15294 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15296 else if (unformat (input, "bd %d", &bd))
15300 errmsg ("parse error '%U'", format_unformat_error, input);
15305 if (!bd_set || !ip_set || (!mac_set && is_add))
15307 errmsg ("Missing BD, IP or MAC!");
15311 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15312 mp->is_add = is_add;
15313 clib_memcpy (&mp->entry.mac, mac, 6);
15314 mp->bd = clib_host_to_net_u32 (bd);
15315 clib_memcpy (mp->entry.ip4, &ip4, sizeof (mp->entry.ip4));
15320 /* wait for reply */
15326 api_one_ndp_bd_get (vat_main_t * vam)
15328 vl_api_one_ndp_bd_get_t *mp;
15331 M (ONE_NDP_BD_GET, mp);
15336 /* wait for reply */
15342 api_one_ndp_entries_get (vat_main_t * vam)
15344 vl_api_one_ndp_entries_get_t *mp;
15345 unformat_input_t *input = vam->input;
15350 /* Parse args required to build the message */
15351 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15353 if (unformat (input, "bd %d", &bd))
15357 errmsg ("parse error '%U'", format_unformat_error, input);
15364 errmsg ("Expected bridge domain!");
15368 M (ONE_NDP_ENTRIES_GET, mp);
15369 mp->bd = clib_host_to_net_u32 (bd);
15374 /* wait for reply */
15380 api_one_l2_arp_bd_get (vat_main_t * vam)
15382 vl_api_one_l2_arp_bd_get_t *mp;
15385 M (ONE_L2_ARP_BD_GET, mp);
15390 /* wait for reply */
15396 api_one_l2_arp_entries_get (vat_main_t * vam)
15398 vl_api_one_l2_arp_entries_get_t *mp;
15399 unformat_input_t *input = vam->input;
15404 /* Parse args required to build the message */
15405 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15407 if (unformat (input, "bd %d", &bd))
15411 errmsg ("parse error '%U'", format_unformat_error, input);
15418 errmsg ("Expected bridge domain!");
15422 M (ONE_L2_ARP_ENTRIES_GET, mp);
15423 mp->bd = clib_host_to_net_u32 (bd);
15428 /* wait for reply */
15434 api_one_stats_enable_disable (vat_main_t * vam)
15436 vl_api_one_stats_enable_disable_t *mp;
15437 unformat_input_t *input = vam->input;
15442 /* Parse args required to build the message */
15443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15445 if (unformat (input, "enable"))
15450 else if (unformat (input, "disable"))
15460 errmsg ("Value not set");
15464 M (ONE_STATS_ENABLE_DISABLE, mp);
15465 mp->is_enable = is_enable;
15470 /* wait for reply */
15476 api_show_one_stats_enable_disable (vat_main_t * vam)
15478 vl_api_show_one_stats_enable_disable_t *mp;
15481 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15486 /* wait for reply */
15492 api_show_one_map_request_mode (vat_main_t * vam)
15494 vl_api_show_one_map_request_mode_t *mp;
15497 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15502 /* wait for reply */
15507 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15510 api_one_map_request_mode (vat_main_t * vam)
15512 unformat_input_t *input = vam->input;
15513 vl_api_one_map_request_mode_t *mp;
15517 /* Parse args required to build the message */
15518 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15520 if (unformat (input, "dst-only"))
15522 else if (unformat (input, "src-dst"))
15526 errmsg ("parse error '%U'", format_unformat_error, input);
15531 M (ONE_MAP_REQUEST_MODE, mp);
15538 /* wait for reply */
15543 #define api_lisp_map_request_mode api_one_map_request_mode
15546 * Enable/disable ONE proxy ITR.
15548 * @param vam vpp API test context
15549 * @return return code
15552 api_one_pitr_set_locator_set (vat_main_t * vam)
15554 u8 ls_name_set = 0;
15555 unformat_input_t *input = vam->input;
15556 vl_api_one_pitr_set_locator_set_t *mp;
15561 /* Parse args required to build the message */
15562 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15564 if (unformat (input, "del"))
15566 else if (unformat (input, "locator-set %s", &ls_name))
15570 errmsg ("parse error '%U'", format_unformat_error, input);
15577 errmsg ("locator-set name not set!");
15581 M (ONE_PITR_SET_LOCATOR_SET, mp);
15583 mp->is_add = is_add;
15584 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15585 vec_free (ls_name);
15590 /* wait for reply */
15595 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15598 api_one_nsh_set_locator_set (vat_main_t * vam)
15600 u8 ls_name_set = 0;
15601 unformat_input_t *input = vam->input;
15602 vl_api_one_nsh_set_locator_set_t *mp;
15607 /* Parse args required to build the message */
15608 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15610 if (unformat (input, "del"))
15612 else if (unformat (input, "ls %s", &ls_name))
15616 errmsg ("parse error '%U'", format_unformat_error, input);
15621 if (!ls_name_set && is_add)
15623 errmsg ("locator-set name not set!");
15627 M (ONE_NSH_SET_LOCATOR_SET, mp);
15629 mp->is_add = is_add;
15630 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15631 vec_free (ls_name);
15636 /* wait for reply */
15642 api_show_one_pitr (vat_main_t * vam)
15644 vl_api_show_one_pitr_t *mp;
15647 if (!vam->json_output)
15649 print (vam->ofp, "%=20s", "lisp status:");
15652 M (SHOW_ONE_PITR, mp);
15656 /* Wait for a reply... */
15661 #define api_show_lisp_pitr api_show_one_pitr
15664 api_one_use_petr (vat_main_t * vam)
15666 unformat_input_t *input = vam->input;
15667 vl_api_one_use_petr_t *mp;
15672 clib_memset (&ip, 0, sizeof (ip));
15674 /* Parse args required to build the message */
15675 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15677 if (unformat (input, "disable"))
15680 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15683 ip_addr_version (&ip) = AF_IP4;
15686 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15689 ip_addr_version (&ip) = AF_IP6;
15693 errmsg ("parse error '%U'", format_unformat_error, input);
15698 M (ONE_USE_PETR, mp);
15700 mp->is_add = is_add;
15703 mp->ip_address.af = ip_addr_version (&ip) == AF_IP4 ? 0 : 1;
15704 if (mp->ip_address.af)
15705 clib_memcpy (mp->ip_address.un.ip6, &ip, 16);
15707 clib_memcpy (mp->ip_address.un.ip4, &ip, 4);
15713 /* wait for reply */
15718 #define api_lisp_use_petr api_one_use_petr
15721 api_show_one_nsh_mapping (vat_main_t * vam)
15723 vl_api_show_one_use_petr_t *mp;
15726 if (!vam->json_output)
15728 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15731 M (SHOW_ONE_NSH_MAPPING, mp);
15735 /* Wait for a reply... */
15741 api_show_one_use_petr (vat_main_t * vam)
15743 vl_api_show_one_use_petr_t *mp;
15746 if (!vam->json_output)
15748 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15751 M (SHOW_ONE_USE_PETR, mp);
15755 /* Wait for a reply... */
15760 #define api_show_lisp_use_petr api_show_one_use_petr
15763 * Add/delete mapping between vni and vrf
15766 api_one_eid_table_add_del_map (vat_main_t * vam)
15768 unformat_input_t *input = vam->input;
15769 vl_api_one_eid_table_add_del_map_t *mp;
15770 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15771 u32 vni, vrf, bd_index;
15774 /* Parse args required to build the message */
15775 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15777 if (unformat (input, "del"))
15779 else if (unformat (input, "vrf %d", &vrf))
15781 else if (unformat (input, "bd_index %d", &bd_index))
15783 else if (unformat (input, "vni %d", &vni))
15789 if (!vni_set || (!vrf_set && !bd_index_set))
15791 errmsg ("missing arguments!");
15795 if (vrf_set && bd_index_set)
15797 errmsg ("error: both vrf and bd entered!");
15801 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15803 mp->is_add = is_add;
15804 mp->vni = htonl (vni);
15805 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15806 mp->is_l2 = bd_index_set;
15811 /* wait for reply */
15816 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15819 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15821 u32 *action = va_arg (*args, u32 *);
15824 if (unformat (input, "%s", &s))
15826 if (!strcmp ((char *) s, "no-action"))
15828 else if (!strcmp ((char *) s, "natively-forward"))
15830 else if (!strcmp ((char *) s, "send-map-request"))
15832 else if (!strcmp ((char *) s, "drop"))
15836 clib_warning ("invalid action: '%s'", s);
15848 * Add/del remote mapping to/from ONE control plane
15850 * @param vam vpp API test context
15851 * @return return code
15854 api_one_add_del_remote_mapping (vat_main_t * vam)
15856 unformat_input_t *input = vam->input;
15857 vl_api_one_add_del_remote_mapping_t *mp;
15859 lisp_eid_vat_t _eid, *eid = &_eid;
15860 lisp_eid_vat_t _seid, *seid = &_seid;
15861 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15862 u32 action = ~0, p, w, data_len;
15863 ip4_address_t rloc4;
15864 ip6_address_t rloc6;
15865 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15868 clib_memset (&rloc, 0, sizeof (rloc));
15870 /* Parse args required to build the message */
15871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15873 if (unformat (input, "del-all"))
15877 else if (unformat (input, "del"))
15881 else if (unformat (input, "add"))
15885 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15889 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15893 else if (unformat (input, "vni %d", &vni))
15897 else if (unformat (input, "p %d w %d", &p, &w))
15901 errmsg ("No RLOC configured for setting priority/weight!");
15904 curr_rloc->priority = p;
15905 curr_rloc->weight = w;
15907 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15909 rloc.ip_address.af = 0;
15910 clib_memcpy (&rloc.ip_address.un.ip6, &rloc6, sizeof (rloc6));
15911 vec_add1 (rlocs, rloc);
15912 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15914 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15916 rloc.ip_address.af = 1;
15917 clib_memcpy (&rloc.ip_address.un.ip4, &rloc4, sizeof (rloc4));
15918 vec_add1 (rlocs, rloc);
15919 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15921 else if (unformat (input, "action %U",
15922 unformat_negative_mapping_action, &action))
15928 clib_warning ("parse error '%U'", format_unformat_error, input);
15935 errmsg ("missing params!");
15939 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15941 errmsg ("no action set for negative map-reply!");
15945 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15947 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15948 mp->is_add = is_add;
15949 mp->vni = htonl (vni);
15950 mp->action = (u8) action;
15951 mp->is_src_dst = seid_set;
15952 mp->del_all = del_all;
15953 lisp_eid_put_vat (&mp->deid, eid);
15954 lisp_eid_put_vat (&mp->seid, seid);
15956 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15957 clib_memcpy (mp->rlocs, rlocs, data_len);
15963 /* Wait for a reply... */
15968 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15971 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15972 * forwarding entries in data-plane accordingly.
15974 * @param vam vpp API test context
15975 * @return return code
15978 api_one_add_del_adjacency (vat_main_t * vam)
15980 unformat_input_t *input = vam->input;
15981 vl_api_one_add_del_adjacency_t *mp;
15985 lisp_eid_vat_t leid, reid;
15987 leid.type = reid.type = (u8) ~ 0;
15989 /* Parse args required to build the message */
15990 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15992 if (unformat (input, "del"))
15996 else if (unformat (input, "add"))
16000 else if (unformat (input, "reid %U/%d", unformat_ip46_address,
16001 &reid.addr.ip, &reid.len))
16003 reid.type = 0; /* ipv4 */
16005 else if (unformat (input, "reid %U", unformat_ethernet_address,
16008 reid.type = 1; /* mac */
16010 else if (unformat (input, "leid %U/%d", unformat_ip46_address,
16011 &leid.addr.ip, &leid.len))
16013 leid.type = 0; /* ipv4 */
16015 else if (unformat (input, "leid %U", unformat_ethernet_address,
16018 leid.type = 1; /* mac */
16020 else if (unformat (input, "vni %d", &vni))
16026 errmsg ("parse error '%U'", format_unformat_error, input);
16031 if ((u8) ~ 0 == reid.type)
16033 errmsg ("missing params!");
16037 if (leid.type != reid.type)
16039 errmsg ("remote and local EIDs are of different types!");
16043 M (ONE_ADD_DEL_ADJACENCY, mp);
16044 mp->is_add = is_add;
16045 mp->vni = htonl (vni);
16046 lisp_eid_put_vat (&mp->leid, &leid);
16047 lisp_eid_put_vat (&mp->reid, &reid);
16052 /* Wait for a reply... */
16057 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16060 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16062 u32 *mode = va_arg (*args, u32 *);
16064 if (unformat (input, "lisp"))
16066 else if (unformat (input, "vxlan"))
16075 api_gpe_get_encap_mode (vat_main_t * vam)
16077 vl_api_gpe_get_encap_mode_t *mp;
16080 /* Construct the API message */
16081 M (GPE_GET_ENCAP_MODE, mp);
16086 /* Wait for a reply... */
16092 api_gpe_set_encap_mode (vat_main_t * vam)
16094 unformat_input_t *input = vam->input;
16095 vl_api_gpe_set_encap_mode_t *mp;
16099 /* Parse args required to build the message */
16100 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16102 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16108 /* Construct the API message */
16109 M (GPE_SET_ENCAP_MODE, mp);
16111 mp->is_vxlan = mode;
16116 /* Wait for a reply... */
16122 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16124 unformat_input_t *input = vam->input;
16125 vl_api_gpe_add_del_iface_t *mp;
16126 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16127 u32 dp_table = 0, vni = 0;
16130 /* Parse args required to build the message */
16131 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16133 if (unformat (input, "up"))
16138 else if (unformat (input, "down"))
16143 else if (unformat (input, "table_id %d", &dp_table))
16147 else if (unformat (input, "bd_id %d", &dp_table))
16152 else if (unformat (input, "vni %d", &vni))
16160 if (action_set == 0)
16162 errmsg ("Action not set");
16165 if (dp_table_set == 0 || vni_set == 0)
16167 errmsg ("vni and dp_table must be set");
16171 /* Construct the API message */
16172 M (GPE_ADD_DEL_IFACE, mp);
16174 mp->is_add = is_add;
16175 mp->dp_table = clib_host_to_net_u32 (dp_table);
16177 mp->vni = clib_host_to_net_u32 (vni);
16182 /* Wait for a reply... */
16188 api_one_map_register_fallback_threshold (vat_main_t * vam)
16190 unformat_input_t *input = vam->input;
16191 vl_api_one_map_register_fallback_threshold_t *mp;
16196 /* Parse args required to build the message */
16197 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16199 if (unformat (input, "%u", &value))
16203 clib_warning ("parse error '%U'", format_unformat_error, input);
16210 errmsg ("fallback threshold value is missing!");
16214 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16215 mp->value = clib_host_to_net_u32 (value);
16220 /* Wait for a reply... */
16226 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16228 vl_api_show_one_map_register_fallback_threshold_t *mp;
16231 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16236 /* Wait for a reply... */
16242 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16244 u32 *proto = va_arg (*args, u32 *);
16246 if (unformat (input, "udp"))
16248 else if (unformat (input, "api"))
16257 api_one_set_transport_protocol (vat_main_t * vam)
16259 unformat_input_t *input = vam->input;
16260 vl_api_one_set_transport_protocol_t *mp;
16265 /* Parse args required to build the message */
16266 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16268 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16272 clib_warning ("parse error '%U'", format_unformat_error, input);
16279 errmsg ("Transport protocol missing!");
16283 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16284 mp->protocol = (u8) protocol;
16289 /* Wait for a reply... */
16295 api_one_get_transport_protocol (vat_main_t * vam)
16297 vl_api_one_get_transport_protocol_t *mp;
16300 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16305 /* Wait for a reply... */
16311 api_one_map_register_set_ttl (vat_main_t * vam)
16313 unformat_input_t *input = vam->input;
16314 vl_api_one_map_register_set_ttl_t *mp;
16319 /* Parse args required to build the message */
16320 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16322 if (unformat (input, "%u", &ttl))
16326 clib_warning ("parse error '%U'", format_unformat_error, input);
16333 errmsg ("TTL value missing!");
16337 M (ONE_MAP_REGISTER_SET_TTL, mp);
16338 mp->ttl = clib_host_to_net_u32 (ttl);
16343 /* Wait for a reply... */
16349 api_show_one_map_register_ttl (vat_main_t * vam)
16351 vl_api_show_one_map_register_ttl_t *mp;
16354 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16359 /* Wait for a reply... */
16365 * Add/del map request itr rlocs from ONE control plane and updates
16367 * @param vam vpp API test context
16368 * @return return code
16371 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16373 unformat_input_t *input = vam->input;
16374 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16375 u8 *locator_set_name = 0;
16376 u8 locator_set_name_set = 0;
16380 /* Parse args required to build the message */
16381 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16383 if (unformat (input, "del"))
16387 else if (unformat (input, "%_%v%_", &locator_set_name))
16389 locator_set_name_set = 1;
16393 clib_warning ("parse error '%U'", format_unformat_error, input);
16398 if (is_add && !locator_set_name_set)
16400 errmsg ("itr-rloc is not set!");
16404 if (is_add && vec_len (locator_set_name) > 64)
16406 errmsg ("itr-rloc locator-set name too long");
16407 vec_free (locator_set_name);
16411 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16412 mp->is_add = is_add;
16415 clib_memcpy (mp->locator_set_name, locator_set_name,
16416 vec_len (locator_set_name));
16420 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16422 vec_free (locator_set_name);
16427 /* Wait for a reply... */
16432 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16435 api_one_locator_dump (vat_main_t * vam)
16437 unformat_input_t *input = vam->input;
16438 vl_api_one_locator_dump_t *mp;
16439 vl_api_control_ping_t *mp_ping;
16440 u8 is_index_set = 0, is_name_set = 0;
16445 /* Parse args required to build the message */
16446 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16448 if (unformat (input, "ls_name %_%v%_", &ls_name))
16452 else if (unformat (input, "ls_index %d", &ls_index))
16458 errmsg ("parse error '%U'", format_unformat_error, input);
16463 if (!is_index_set && !is_name_set)
16465 errmsg ("error: expected one of index or name!");
16469 if (is_index_set && is_name_set)
16471 errmsg ("error: only one param expected!");
16475 if (vec_len (ls_name) > 62)
16477 errmsg ("error: locator set name too long!");
16481 if (!vam->json_output)
16483 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16486 M (ONE_LOCATOR_DUMP, mp);
16487 mp->is_index_set = is_index_set;
16490 mp->ls_index = clib_host_to_net_u32 (ls_index);
16493 vec_add1 (ls_name, 0);
16494 strncpy ((char *) mp->ls_name, (char *) ls_name,
16495 sizeof (mp->ls_name) - 1);
16501 /* Use a control ping for synchronization */
16502 MPING (CONTROL_PING, mp_ping);
16505 /* Wait for a reply... */
16510 #define api_lisp_locator_dump api_one_locator_dump
16513 api_one_locator_set_dump (vat_main_t * vam)
16515 vl_api_one_locator_set_dump_t *mp;
16516 vl_api_control_ping_t *mp_ping;
16517 unformat_input_t *input = vam->input;
16521 /* Parse args required to build the message */
16522 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16524 if (unformat (input, "local"))
16528 else if (unformat (input, "remote"))
16534 errmsg ("parse error '%U'", format_unformat_error, input);
16539 if (!vam->json_output)
16541 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16544 M (ONE_LOCATOR_SET_DUMP, mp);
16546 mp->filter = filter;
16551 /* Use a control ping for synchronization */
16552 MPING (CONTROL_PING, mp_ping);
16555 /* Wait for a reply... */
16560 #define api_lisp_locator_set_dump api_one_locator_set_dump
16563 api_one_eid_table_map_dump (vat_main_t * vam)
16567 unformat_input_t *input = vam->input;
16568 vl_api_one_eid_table_map_dump_t *mp;
16569 vl_api_control_ping_t *mp_ping;
16572 /* Parse args required to build the message */
16573 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16575 if (unformat (input, "l2"))
16580 else if (unformat (input, "l3"))
16587 errmsg ("parse error '%U'", format_unformat_error, input);
16594 errmsg ("expected one of 'l2' or 'l3' parameter!");
16598 if (!vam->json_output)
16600 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16603 M (ONE_EID_TABLE_MAP_DUMP, mp);
16609 /* Use a control ping for synchronization */
16610 MPING (CONTROL_PING, mp_ping);
16613 /* Wait for a reply... */
16618 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16621 api_one_eid_table_vni_dump (vat_main_t * vam)
16623 vl_api_one_eid_table_vni_dump_t *mp;
16624 vl_api_control_ping_t *mp_ping;
16627 if (!vam->json_output)
16629 print (vam->ofp, "VNI");
16632 M (ONE_EID_TABLE_VNI_DUMP, mp);
16637 /* Use a control ping for synchronization */
16638 MPING (CONTROL_PING, mp_ping);
16641 /* Wait for a reply... */
16646 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16649 api_one_eid_table_dump (vat_main_t * vam)
16651 unformat_input_t *i = vam->input;
16652 vl_api_one_eid_table_dump_t *mp;
16653 vl_api_control_ping_t *mp_ping;
16657 lisp_eid_vat_t eid;
16660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16663 (i, "eid %U/%d", unformat_ip46_address, &eid.addr.ip, &eid.len))
16669 if (unformat (i, "eid %U", unformat_ethernet_address, &eid.addr.mac))
16674 else if (unformat (i, "eid %U", unformat_nsh_address, &eid.addr.nsh))
16679 else if (unformat (i, "vni %d", &t))
16683 else if (unformat (i, "local"))
16687 else if (unformat (i, "remote"))
16693 errmsg ("parse error '%U'", format_unformat_error, i);
16698 if (!vam->json_output)
16700 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16701 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16704 M (ONE_EID_TABLE_DUMP, mp);
16706 mp->filter = filter;
16710 mp->vni = htonl (vni);
16711 lisp_eid_put_vat (&mp->eid, &eid);
16717 /* Use a control ping for synchronization */
16718 MPING (CONTROL_PING, mp_ping);
16721 /* Wait for a reply... */
16726 #define api_lisp_eid_table_dump api_one_eid_table_dump
16729 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16731 unformat_input_t *i = vam->input;
16732 vl_api_gpe_fwd_entries_get_t *mp;
16737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16739 if (unformat (i, "vni %d", &vni))
16745 errmsg ("parse error '%U'", format_unformat_error, i);
16752 errmsg ("vni not set!");
16756 if (!vam->json_output)
16758 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16762 M (GPE_FWD_ENTRIES_GET, mp);
16763 mp->vni = clib_host_to_net_u32 (vni);
16768 /* Wait for a reply... */
16773 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16774 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16775 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16776 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16777 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16778 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16779 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16780 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16783 api_one_adjacencies_get (vat_main_t * vam)
16785 unformat_input_t *i = vam->input;
16786 vl_api_one_adjacencies_get_t *mp;
16791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16793 if (unformat (i, "vni %d", &vni))
16799 errmsg ("parse error '%U'", format_unformat_error, i);
16806 errmsg ("vni not set!");
16810 if (!vam->json_output)
16812 print (vam->ofp, "%s %40s", "leid", "reid");
16815 M (ONE_ADJACENCIES_GET, mp);
16816 mp->vni = clib_host_to_net_u32 (vni);
16821 /* Wait for a reply... */
16826 #define api_lisp_adjacencies_get api_one_adjacencies_get
16829 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16831 unformat_input_t *i = vam->input;
16832 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16834 u8 ip_family_set = 0, is_ip4 = 1;
16836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16838 if (unformat (i, "ip4"))
16843 else if (unformat (i, "ip6"))
16850 errmsg ("parse error '%U'", format_unformat_error, i);
16855 if (!ip_family_set)
16857 errmsg ("ip family not set!");
16861 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16862 mp->is_ip4 = is_ip4;
16867 /* Wait for a reply... */
16873 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16875 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16878 if (!vam->json_output)
16880 print (vam->ofp, "VNIs");
16883 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16888 /* Wait for a reply... */
16894 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16896 unformat_input_t *i = vam->input;
16897 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16899 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16900 struct in_addr ip4;
16901 struct in6_addr ip6;
16902 u32 table_id = 0, nh_sw_if_index = ~0;
16904 clib_memset (&ip4, 0, sizeof (ip4));
16905 clib_memset (&ip6, 0, sizeof (ip6));
16907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16909 if (unformat (i, "del"))
16911 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16912 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16917 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16918 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16923 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16927 nh_sw_if_index = ~0;
16929 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16933 nh_sw_if_index = ~0;
16935 else if (unformat (i, "table %d", &table_id))
16939 errmsg ("parse error '%U'", format_unformat_error, i);
16946 errmsg ("nh addr not set!");
16950 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16951 mp->is_add = is_add;
16952 mp->table_id = clib_host_to_net_u32 (table_id);
16953 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16954 mp->nh_addr.af = is_ip4 ? 0 : 1;
16956 clib_memcpy (mp->nh_addr.un.ip4, &ip4, sizeof (ip4));
16958 clib_memcpy (mp->nh_addr.un.ip6, &ip6, sizeof (ip6));
16963 /* Wait for a reply... */
16969 api_one_map_server_dump (vat_main_t * vam)
16971 vl_api_one_map_server_dump_t *mp;
16972 vl_api_control_ping_t *mp_ping;
16975 if (!vam->json_output)
16977 print (vam->ofp, "%=20s", "Map server");
16980 M (ONE_MAP_SERVER_DUMP, mp);
16984 /* Use a control ping for synchronization */
16985 MPING (CONTROL_PING, mp_ping);
16988 /* Wait for a reply... */
16993 #define api_lisp_map_server_dump api_one_map_server_dump
16996 api_one_map_resolver_dump (vat_main_t * vam)
16998 vl_api_one_map_resolver_dump_t *mp;
16999 vl_api_control_ping_t *mp_ping;
17002 if (!vam->json_output)
17004 print (vam->ofp, "%=20s", "Map resolver");
17007 M (ONE_MAP_RESOLVER_DUMP, mp);
17011 /* Use a control ping for synchronization */
17012 MPING (CONTROL_PING, mp_ping);
17015 /* Wait for a reply... */
17020 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17023 api_one_stats_flush (vat_main_t * vam)
17025 vl_api_one_stats_flush_t *mp;
17028 M (ONE_STATS_FLUSH, mp);
17035 api_one_stats_dump (vat_main_t * vam)
17037 vl_api_one_stats_dump_t *mp;
17038 vl_api_control_ping_t *mp_ping;
17041 M (ONE_STATS_DUMP, mp);
17045 /* Use a control ping for synchronization */
17046 MPING (CONTROL_PING, mp_ping);
17049 /* Wait for a reply... */
17055 api_show_one_status (vat_main_t * vam)
17057 vl_api_show_one_status_t *mp;
17060 if (!vam->json_output)
17062 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17065 M (SHOW_ONE_STATUS, mp);
17068 /* Wait for a reply... */
17073 #define api_show_lisp_status api_show_one_status
17076 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17078 vl_api_gpe_fwd_entry_path_dump_t *mp;
17079 vl_api_control_ping_t *mp_ping;
17080 unformat_input_t *i = vam->input;
17081 u32 fwd_entry_index = ~0;
17084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17086 if (unformat (i, "index %d", &fwd_entry_index))
17092 if (~0 == fwd_entry_index)
17094 errmsg ("no index specified!");
17098 if (!vam->json_output)
17100 print (vam->ofp, "first line");
17103 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17107 /* Use a control ping for synchronization */
17108 MPING (CONTROL_PING, mp_ping);
17111 /* Wait for a reply... */
17117 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17119 vl_api_one_get_map_request_itr_rlocs_t *mp;
17122 if (!vam->json_output)
17124 print (vam->ofp, "%=20s", "itr-rlocs:");
17127 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17130 /* Wait for a reply... */
17135 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17138 api_af_packet_create (vat_main_t * vam)
17140 unformat_input_t *i = vam->input;
17141 vl_api_af_packet_create_t *mp;
17142 u8 *host_if_name = 0;
17144 u8 random_hw_addr = 1;
17147 clib_memset (hw_addr, 0, sizeof (hw_addr));
17149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17151 if (unformat (i, "name %s", &host_if_name))
17152 vec_add1 (host_if_name, 0);
17153 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17154 random_hw_addr = 0;
17159 if (!vec_len (host_if_name))
17161 errmsg ("host-interface name must be specified");
17165 if (vec_len (host_if_name) > 64)
17167 errmsg ("host-interface name too long");
17171 M (AF_PACKET_CREATE, mp);
17173 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17174 clib_memcpy (mp->hw_addr, hw_addr, 6);
17175 mp->use_random_hw_addr = random_hw_addr;
17176 vec_free (host_if_name);
17184 fprintf (vam->ofp ? vam->ofp : stderr,
17185 " new sw_if_index = %d\n", vam->sw_if_index);
17192 api_af_packet_delete (vat_main_t * vam)
17194 unformat_input_t *i = vam->input;
17195 vl_api_af_packet_delete_t *mp;
17196 u8 *host_if_name = 0;
17199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17201 if (unformat (i, "name %s", &host_if_name))
17202 vec_add1 (host_if_name, 0);
17207 if (!vec_len (host_if_name))
17209 errmsg ("host-interface name must be specified");
17213 if (vec_len (host_if_name) > 64)
17215 errmsg ("host-interface name too long");
17219 M (AF_PACKET_DELETE, mp);
17221 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17222 vec_free (host_if_name);
17229 static void vl_api_af_packet_details_t_handler
17230 (vl_api_af_packet_details_t * mp)
17232 vat_main_t *vam = &vat_main;
17234 print (vam->ofp, "%-16s %d",
17235 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17238 static void vl_api_af_packet_details_t_handler_json
17239 (vl_api_af_packet_details_t * mp)
17241 vat_main_t *vam = &vat_main;
17242 vat_json_node_t *node = NULL;
17244 if (VAT_JSON_ARRAY != vam->json_tree.type)
17246 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17247 vat_json_init_array (&vam->json_tree);
17249 node = vat_json_array_add (&vam->json_tree);
17251 vat_json_init_object (node);
17252 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17253 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17257 api_af_packet_dump (vat_main_t * vam)
17259 vl_api_af_packet_dump_t *mp;
17260 vl_api_control_ping_t *mp_ping;
17263 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17264 /* Get list of tap interfaces */
17265 M (AF_PACKET_DUMP, mp);
17268 /* Use a control ping for synchronization */
17269 MPING (CONTROL_PING, mp_ping);
17277 api_policer_add_del (vat_main_t * vam)
17279 unformat_input_t *i = vam->input;
17280 vl_api_policer_add_del_t *mp;
17290 u8 color_aware = 0;
17291 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17294 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17295 conform_action.dscp = 0;
17296 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17297 exceed_action.dscp = 0;
17298 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17299 violate_action.dscp = 0;
17301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17303 if (unformat (i, "del"))
17305 else if (unformat (i, "name %s", &name))
17306 vec_add1 (name, 0);
17307 else if (unformat (i, "cir %u", &cir))
17309 else if (unformat (i, "eir %u", &eir))
17311 else if (unformat (i, "cb %u", &cb))
17313 else if (unformat (i, "eb %u", &eb))
17315 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17318 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17321 else if (unformat (i, "type %U", unformat_policer_type, &type))
17323 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17326 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17329 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17332 else if (unformat (i, "color-aware"))
17338 if (!vec_len (name))
17340 errmsg ("policer name must be specified");
17344 if (vec_len (name) > 64)
17346 errmsg ("policer name too long");
17350 M (POLICER_ADD_DEL, mp);
17352 clib_memcpy (mp->name, name, vec_len (name));
17354 mp->is_add = is_add;
17355 mp->cir = ntohl (cir);
17356 mp->eir = ntohl (eir);
17357 mp->cb = clib_net_to_host_u64 (cb);
17358 mp->eb = clib_net_to_host_u64 (eb);
17359 mp->rate_type = rate_type;
17360 mp->round_type = round_type;
17362 mp->conform_action.type = conform_action.action_type;
17363 mp->conform_action.dscp = conform_action.dscp;
17364 mp->exceed_action.type = exceed_action.action_type;
17365 mp->exceed_action.dscp = exceed_action.dscp;
17366 mp->violate_action.type = violate_action.action_type;
17367 mp->violate_action.dscp = violate_action.dscp;
17368 mp->color_aware = color_aware;
17376 api_policer_dump (vat_main_t * vam)
17378 unformat_input_t *i = vam->input;
17379 vl_api_policer_dump_t *mp;
17380 vl_api_control_ping_t *mp_ping;
17381 u8 *match_name = 0;
17382 u8 match_name_valid = 0;
17385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17387 if (unformat (i, "name %s", &match_name))
17389 vec_add1 (match_name, 0);
17390 match_name_valid = 1;
17396 M (POLICER_DUMP, mp);
17397 mp->match_name_valid = match_name_valid;
17398 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17399 vec_free (match_name);
17403 /* Use a control ping for synchronization */
17404 MPING (CONTROL_PING, mp_ping);
17407 /* Wait for a reply... */
17413 api_policer_classify_set_interface (vat_main_t * vam)
17415 unformat_input_t *i = vam->input;
17416 vl_api_policer_classify_set_interface_t *mp;
17418 int sw_if_index_set;
17419 u32 ip4_table_index = ~0;
17420 u32 ip6_table_index = ~0;
17421 u32 l2_table_index = ~0;
17425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17427 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17428 sw_if_index_set = 1;
17429 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17430 sw_if_index_set = 1;
17431 else if (unformat (i, "del"))
17433 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17435 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17437 else if (unformat (i, "l2-table %d", &l2_table_index))
17441 clib_warning ("parse error '%U'", format_unformat_error, i);
17446 if (sw_if_index_set == 0)
17448 errmsg ("missing interface name or sw_if_index");
17452 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17454 mp->sw_if_index = ntohl (sw_if_index);
17455 mp->ip4_table_index = ntohl (ip4_table_index);
17456 mp->ip6_table_index = ntohl (ip6_table_index);
17457 mp->l2_table_index = ntohl (l2_table_index);
17458 mp->is_add = is_add;
17466 api_policer_classify_dump (vat_main_t * vam)
17468 unformat_input_t *i = vam->input;
17469 vl_api_policer_classify_dump_t *mp;
17470 vl_api_control_ping_t *mp_ping;
17471 u8 type = POLICER_CLASSIFY_N_TABLES;
17474 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17478 errmsg ("classify table type must be specified");
17482 if (!vam->json_output)
17484 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17487 M (POLICER_CLASSIFY_DUMP, mp);
17492 /* Use a control ping for synchronization */
17493 MPING (CONTROL_PING, mp_ping);
17496 /* Wait for a reply... */
17502 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17504 vl_api_fib_path_nh_proto_t proto =
17505 va_arg (*args, vl_api_fib_path_nh_proto_t);
17509 case FIB_API_PATH_NH_PROTO_IP4:
17510 s = format (s, "ip4");
17512 case FIB_API_PATH_NH_PROTO_IP6:
17513 s = format (s, "ip6");
17515 case FIB_API_PATH_NH_PROTO_MPLS:
17516 s = format (s, "mpls");
17518 case FIB_API_PATH_NH_PROTO_BIER:
17519 s = format (s, "bier");
17521 case FIB_API_PATH_NH_PROTO_ETHERNET:
17522 s = format (s, "ethernet");
17530 format_vl_api_ip_address_union (u8 * s, va_list * args)
17532 vl_api_address_family_t af = va_arg (*args, int);
17533 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17538 s = format (s, "%U", format_ip4_address, u->ip4);
17541 s = format (s, "%U", format_ip6_address, u->ip6);
17548 format_vl_api_fib_path_type (u8 * s, va_list * args)
17550 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17554 case FIB_API_PATH_TYPE_NORMAL:
17555 s = format (s, "normal");
17557 case FIB_API_PATH_TYPE_LOCAL:
17558 s = format (s, "local");
17560 case FIB_API_PATH_TYPE_DROP:
17561 s = format (s, "drop");
17563 case FIB_API_PATH_TYPE_UDP_ENCAP:
17564 s = format (s, "udp-encap");
17566 case FIB_API_PATH_TYPE_BIER_IMP:
17567 s = format (s, "bier-imp");
17569 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17570 s = format (s, "unreach");
17572 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17573 s = format (s, "prohibit");
17575 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17576 s = format (s, "src-lookup");
17578 case FIB_API_PATH_TYPE_DVR:
17579 s = format (s, "dvr");
17581 case FIB_API_PATH_TYPE_INTERFACE_RX:
17582 s = format (s, "interface-rx");
17584 case FIB_API_PATH_TYPE_CLASSIFY:
17585 s = format (s, "classify");
17593 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17596 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17597 ntohl (fp->weight), ntohl (fp->sw_if_index),
17598 format_vl_api_fib_path_type, fp->type,
17599 format_fib_api_path_nh_proto, fp->proto,
17600 format_vl_api_ip_address_union, &fp->nh.address);
17604 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17605 vl_api_fib_path_t * fp)
17607 struct in_addr ip4;
17608 struct in6_addr ip6;
17610 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17611 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17612 vat_json_object_add_uint (node, "type", fp->type);
17613 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17614 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17616 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17617 vat_json_object_add_ip4 (node, "next_hop", ip4);
17619 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
17621 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17622 vat_json_object_add_ip6 (node, "next_hop", ip6);
17627 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17629 vat_main_t *vam = &vat_main;
17630 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17631 vl_api_fib_path_t *fp;
17634 print (vam->ofp, "sw_if_index %d via:",
17635 ntohl (mp->mt_tunnel.mt_sw_if_index));
17636 fp = mp->mt_tunnel.mt_paths;
17637 for (i = 0; i < count; i++)
17639 vl_api_fib_path_print (vam, fp);
17643 print (vam->ofp, "");
17646 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17647 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17650 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17652 vat_main_t *vam = &vat_main;
17653 vat_json_node_t *node = NULL;
17654 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17655 vl_api_fib_path_t *fp;
17658 if (VAT_JSON_ARRAY != vam->json_tree.type)
17660 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17661 vat_json_init_array (&vam->json_tree);
17663 node = vat_json_array_add (&vam->json_tree);
17665 vat_json_init_object (node);
17666 vat_json_object_add_uint (node, "sw_if_index",
17667 ntohl (mp->mt_tunnel.mt_sw_if_index));
17669 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17671 fp = mp->mt_tunnel.mt_paths;
17672 for (i = 0; i < count; i++)
17674 vl_api_mpls_fib_path_json_print (node, fp);
17680 api_mpls_tunnel_dump (vat_main_t * vam)
17682 vl_api_mpls_tunnel_dump_t *mp;
17683 vl_api_control_ping_t *mp_ping;
17686 M (MPLS_TUNNEL_DUMP, mp);
17690 /* Use a control ping for synchronization */
17691 MPING (CONTROL_PING, mp_ping);
17698 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17699 #define vl_api_mpls_table_details_t_print vl_noop_handler
17703 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17705 vat_main_t *vam = &vat_main;
17707 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17710 static void vl_api_mpls_table_details_t_handler_json
17711 (vl_api_mpls_table_details_t * mp)
17713 vat_main_t *vam = &vat_main;
17714 vat_json_node_t *node = NULL;
17716 if (VAT_JSON_ARRAY != vam->json_tree.type)
17718 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17719 vat_json_init_array (&vam->json_tree);
17721 node = vat_json_array_add (&vam->json_tree);
17723 vat_json_init_object (node);
17724 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17728 api_mpls_table_dump (vat_main_t * vam)
17730 vl_api_mpls_table_dump_t *mp;
17731 vl_api_control_ping_t *mp_ping;
17734 M (MPLS_TABLE_DUMP, mp);
17737 /* Use a control ping for synchronization */
17738 MPING (CONTROL_PING, mp_ping);
17745 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17746 #define vl_api_mpls_route_details_t_print vl_noop_handler
17749 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17751 vat_main_t *vam = &vat_main;
17752 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17753 vl_api_fib_path_t *fp;
17757 "table-id %d, label %u, ess_bit %u",
17758 ntohl (mp->mr_route.mr_table_id),
17759 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17760 fp = mp->mr_route.mr_paths;
17761 for (i = 0; i < count; i++)
17763 vl_api_fib_path_print (vam, fp);
17768 static void vl_api_mpls_route_details_t_handler_json
17769 (vl_api_mpls_route_details_t * mp)
17771 vat_main_t *vam = &vat_main;
17772 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17773 vat_json_node_t *node = NULL;
17774 vl_api_fib_path_t *fp;
17777 if (VAT_JSON_ARRAY != vam->json_tree.type)
17779 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17780 vat_json_init_array (&vam->json_tree);
17782 node = vat_json_array_add (&vam->json_tree);
17784 vat_json_init_object (node);
17785 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17786 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17787 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17788 vat_json_object_add_uint (node, "path_count", count);
17789 fp = mp->mr_route.mr_paths;
17790 for (i = 0; i < count; i++)
17792 vl_api_mpls_fib_path_json_print (node, fp);
17798 api_mpls_route_dump (vat_main_t * vam)
17800 unformat_input_t *input = vam->input;
17801 vl_api_mpls_route_dump_t *mp;
17802 vl_api_control_ping_t *mp_ping;
17806 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17808 if (unformat (input, "table_id %d", &table_id))
17813 if (table_id == ~0)
17815 errmsg ("missing table id");
17819 M (MPLS_ROUTE_DUMP, mp);
17821 mp->table.mt_table_id = ntohl (table_id);
17824 /* Use a control ping for synchronization */
17825 MPING (CONTROL_PING, mp_ping);
17832 #define vl_api_ip_table_details_t_endian vl_noop_handler
17833 #define vl_api_ip_table_details_t_print vl_noop_handler
17836 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17838 vat_main_t *vam = &vat_main;
17841 "%s; table-id %d, prefix %U/%d",
17842 mp->table.name, ntohl (mp->table.table_id));
17846 static void vl_api_ip_table_details_t_handler_json
17847 (vl_api_ip_table_details_t * mp)
17849 vat_main_t *vam = &vat_main;
17850 vat_json_node_t *node = NULL;
17852 if (VAT_JSON_ARRAY != vam->json_tree.type)
17854 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17855 vat_json_init_array (&vam->json_tree);
17857 node = vat_json_array_add (&vam->json_tree);
17859 vat_json_init_object (node);
17860 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17864 api_ip_table_dump (vat_main_t * vam)
17866 vl_api_ip_table_dump_t *mp;
17867 vl_api_control_ping_t *mp_ping;
17870 M (IP_TABLE_DUMP, mp);
17873 /* Use a control ping for synchronization */
17874 MPING (CONTROL_PING, mp_ping);
17882 api_ip_mtable_dump (vat_main_t * vam)
17884 vl_api_ip_mtable_dump_t *mp;
17885 vl_api_control_ping_t *mp_ping;
17888 M (IP_MTABLE_DUMP, mp);
17891 /* Use a control ping for synchronization */
17892 MPING (CONTROL_PING, mp_ping);
17900 api_ip_mroute_dump (vat_main_t * vam)
17902 unformat_input_t *input = vam->input;
17903 vl_api_control_ping_t *mp_ping;
17904 vl_api_ip_mroute_dump_t *mp;
17909 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17911 if (unformat (input, "table_id %d", &table_id))
17913 else if (unformat (input, "ip6"))
17915 else if (unformat (input, "ip4"))
17920 if (table_id == ~0)
17922 errmsg ("missing table id");
17926 M (IP_MROUTE_DUMP, mp);
17927 mp->table.table_id = table_id;
17928 mp->table.is_ip6 = is_ip6;
17931 /* Use a control ping for synchronization */
17932 MPING (CONTROL_PING, mp_ping);
17939 #define vl_api_ip_route_details_t_endian vl_noop_handler
17940 #define vl_api_ip_route_details_t_print vl_noop_handler
17943 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17945 vat_main_t *vam = &vat_main;
17946 u8 count = mp->route.n_paths;
17947 vl_api_fib_path_t *fp;
17951 "table-id %d, prefix %U/%d",
17952 ntohl (mp->route.table_id),
17953 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17954 for (i = 0; i < count; i++)
17956 fp = &mp->route.paths[i];
17958 vl_api_fib_path_print (vam, fp);
17963 static void vl_api_ip_route_details_t_handler_json
17964 (vl_api_ip_route_details_t * mp)
17966 vat_main_t *vam = &vat_main;
17967 u8 count = mp->route.n_paths;
17968 vat_json_node_t *node = NULL;
17969 struct in_addr ip4;
17970 struct in6_addr ip6;
17971 vl_api_fib_path_t *fp;
17974 if (VAT_JSON_ARRAY != vam->json_tree.type)
17976 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17977 vat_json_init_array (&vam->json_tree);
17979 node = vat_json_array_add (&vam->json_tree);
17981 vat_json_init_object (node);
17982 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
17983 if (ADDRESS_IP6 == mp->route.prefix.address.af)
17985 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
17986 vat_json_object_add_ip6 (node, "prefix", ip6);
17990 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
17991 vat_json_object_add_ip4 (node, "prefix", ip4);
17993 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
17994 vat_json_object_add_uint (node, "path_count", count);
17995 for (i = 0; i < count; i++)
17997 fp = &mp->route.paths[i];
17998 vl_api_mpls_fib_path_json_print (node, fp);
18003 api_ip_route_dump (vat_main_t * vam)
18005 unformat_input_t *input = vam->input;
18006 vl_api_ip_route_dump_t *mp;
18007 vl_api_control_ping_t *mp_ping;
18013 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18015 if (unformat (input, "table_id %d", &table_id))
18017 else if (unformat (input, "ip6"))
18019 else if (unformat (input, "ip4"))
18024 if (table_id == ~0)
18026 errmsg ("missing table id");
18030 M (IP_ROUTE_DUMP, mp);
18032 mp->table.table_id = table_id;
18033 mp->table.is_ip6 = is_ip6;
18037 /* Use a control ping for synchronization */
18038 MPING (CONTROL_PING, mp_ping);
18046 api_classify_table_ids (vat_main_t * vam)
18048 vl_api_classify_table_ids_t *mp;
18051 /* Construct the API message */
18052 M (CLASSIFY_TABLE_IDS, mp);
18061 api_classify_table_by_interface (vat_main_t * vam)
18063 unformat_input_t *input = vam->input;
18064 vl_api_classify_table_by_interface_t *mp;
18066 u32 sw_if_index = ~0;
18068 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18070 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18072 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18077 if (sw_if_index == ~0)
18079 errmsg ("missing interface name or sw_if_index");
18083 /* Construct the API message */
18084 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18086 mp->sw_if_index = ntohl (sw_if_index);
18094 api_classify_table_info (vat_main_t * vam)
18096 unformat_input_t *input = vam->input;
18097 vl_api_classify_table_info_t *mp;
18101 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18103 if (unformat (input, "table_id %d", &table_id))
18108 if (table_id == ~0)
18110 errmsg ("missing table id");
18114 /* Construct the API message */
18115 M (CLASSIFY_TABLE_INFO, mp);
18117 mp->table_id = ntohl (table_id);
18125 api_classify_session_dump (vat_main_t * vam)
18127 unformat_input_t *input = vam->input;
18128 vl_api_classify_session_dump_t *mp;
18129 vl_api_control_ping_t *mp_ping;
18133 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18135 if (unformat (input, "table_id %d", &table_id))
18140 if (table_id == ~0)
18142 errmsg ("missing table id");
18146 /* Construct the API message */
18147 M (CLASSIFY_SESSION_DUMP, mp);
18149 mp->table_id = ntohl (table_id);
18152 /* Use a control ping for synchronization */
18153 MPING (CONTROL_PING, mp_ping);
18161 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18163 vat_main_t *vam = &vat_main;
18165 print (vam->ofp, "collector_address %U, collector_port %d, "
18166 "src_address %U, vrf_id %d, path_mtu %u, "
18167 "template_interval %u, udp_checksum %d",
18168 format_ip4_address, mp->collector_address,
18169 ntohs (mp->collector_port),
18170 format_ip4_address, mp->src_address,
18171 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18172 ntohl (mp->template_interval), mp->udp_checksum);
18175 vam->result_ready = 1;
18179 vl_api_ipfix_exporter_details_t_handler_json
18180 (vl_api_ipfix_exporter_details_t * mp)
18182 vat_main_t *vam = &vat_main;
18183 vat_json_node_t node;
18184 struct in_addr collector_address;
18185 struct in_addr src_address;
18187 vat_json_init_object (&node);
18188 clib_memcpy (&collector_address, &mp->collector_address,
18189 sizeof (collector_address));
18190 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18191 vat_json_object_add_uint (&node, "collector_port",
18192 ntohs (mp->collector_port));
18193 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18194 vat_json_object_add_ip4 (&node, "src_address", src_address);
18195 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18196 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18197 vat_json_object_add_uint (&node, "template_interval",
18198 ntohl (mp->template_interval));
18199 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18201 vat_json_print (vam->ofp, &node);
18202 vat_json_free (&node);
18204 vam->result_ready = 1;
18208 api_ipfix_exporter_dump (vat_main_t * vam)
18210 vl_api_ipfix_exporter_dump_t *mp;
18213 /* Construct the API message */
18214 M (IPFIX_EXPORTER_DUMP, mp);
18223 api_ipfix_classify_stream_dump (vat_main_t * vam)
18225 vl_api_ipfix_classify_stream_dump_t *mp;
18228 /* Construct the API message */
18229 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18240 vl_api_ipfix_classify_stream_details_t_handler
18241 (vl_api_ipfix_classify_stream_details_t * mp)
18243 vat_main_t *vam = &vat_main;
18244 print (vam->ofp, "domain_id %d, src_port %d",
18245 ntohl (mp->domain_id), ntohs (mp->src_port));
18247 vam->result_ready = 1;
18251 vl_api_ipfix_classify_stream_details_t_handler_json
18252 (vl_api_ipfix_classify_stream_details_t * mp)
18254 vat_main_t *vam = &vat_main;
18255 vat_json_node_t node;
18257 vat_json_init_object (&node);
18258 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18259 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18261 vat_json_print (vam->ofp, &node);
18262 vat_json_free (&node);
18264 vam->result_ready = 1;
18268 api_ipfix_classify_table_dump (vat_main_t * vam)
18270 vl_api_ipfix_classify_table_dump_t *mp;
18271 vl_api_control_ping_t *mp_ping;
18274 if (!vam->json_output)
18276 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18277 "transport_protocol");
18280 /* Construct the API message */
18281 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18286 /* Use a control ping for synchronization */
18287 MPING (CONTROL_PING, mp_ping);
18295 vl_api_ipfix_classify_table_details_t_handler
18296 (vl_api_ipfix_classify_table_details_t * mp)
18298 vat_main_t *vam = &vat_main;
18299 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18300 mp->transport_protocol);
18304 vl_api_ipfix_classify_table_details_t_handler_json
18305 (vl_api_ipfix_classify_table_details_t * mp)
18307 vat_json_node_t *node = NULL;
18308 vat_main_t *vam = &vat_main;
18310 if (VAT_JSON_ARRAY != vam->json_tree.type)
18312 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18313 vat_json_init_array (&vam->json_tree);
18316 node = vat_json_array_add (&vam->json_tree);
18317 vat_json_init_object (node);
18319 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18320 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18321 vat_json_object_add_uint (node, "transport_protocol",
18322 mp->transport_protocol);
18326 api_sw_interface_span_enable_disable (vat_main_t * vam)
18328 unformat_input_t *i = vam->input;
18329 vl_api_sw_interface_span_enable_disable_t *mp;
18330 u32 src_sw_if_index = ~0;
18331 u32 dst_sw_if_index = ~0;
18336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18339 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18341 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18345 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18347 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18349 else if (unformat (i, "disable"))
18351 else if (unformat (i, "rx"))
18353 else if (unformat (i, "tx"))
18355 else if (unformat (i, "both"))
18357 else if (unformat (i, "l2"))
18363 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18365 mp->sw_if_index_from = htonl (src_sw_if_index);
18366 mp->sw_if_index_to = htonl (dst_sw_if_index);
18376 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18379 vat_main_t *vam = &vat_main;
18380 u8 *sw_if_from_name = 0;
18381 u8 *sw_if_to_name = 0;
18382 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18383 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18384 char *states[] = { "none", "rx", "tx", "both" };
18388 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18390 if ((u32) p->value[0] == sw_if_index_from)
18392 sw_if_from_name = (u8 *)(p->key);
18396 if ((u32) p->value[0] == sw_if_index_to)
18398 sw_if_to_name = (u8 *)(p->key);
18399 if (sw_if_from_name)
18404 print (vam->ofp, "%20s => %20s (%s) %s",
18405 sw_if_from_name, sw_if_to_name, states[mp->state],
18406 mp->is_l2 ? "l2" : "device");
18410 vl_api_sw_interface_span_details_t_handler_json
18411 (vl_api_sw_interface_span_details_t * mp)
18413 vat_main_t *vam = &vat_main;
18414 vat_json_node_t *node = NULL;
18415 u8 *sw_if_from_name = 0;
18416 u8 *sw_if_to_name = 0;
18417 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18418 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18422 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18424 if ((u32) p->value[0] == sw_if_index_from)
18426 sw_if_from_name = (u8 *)(p->key);
18430 if ((u32) p->value[0] == sw_if_index_to)
18432 sw_if_to_name = (u8 *)(p->key);
18433 if (sw_if_from_name)
18439 if (VAT_JSON_ARRAY != vam->json_tree.type)
18441 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18442 vat_json_init_array (&vam->json_tree);
18444 node = vat_json_array_add (&vam->json_tree);
18446 vat_json_init_object (node);
18447 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18448 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18449 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18450 if (0 != sw_if_to_name)
18452 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18454 vat_json_object_add_uint (node, "state", mp->state);
18455 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18459 api_sw_interface_span_dump (vat_main_t * vam)
18461 unformat_input_t *input = vam->input;
18462 vl_api_sw_interface_span_dump_t *mp;
18463 vl_api_control_ping_t *mp_ping;
18467 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18469 if (unformat (input, "l2"))
18475 M (SW_INTERFACE_SPAN_DUMP, mp);
18479 /* Use a control ping for synchronization */
18480 MPING (CONTROL_PING, mp_ping);
18488 api_pg_create_interface (vat_main_t * vam)
18490 unformat_input_t *input = vam->input;
18491 vl_api_pg_create_interface_t *mp;
18493 u32 if_id = ~0, gso_size = 0;
18494 u8 gso_enabled = 0;
18496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18498 if (unformat (input, "if_id %d", &if_id))
18500 else if (unformat (input, "gso-enabled"))
18503 if (unformat (input, "gso-size %u", &gso_size))
18507 errmsg ("missing gso-size");
18516 errmsg ("missing pg interface index");
18520 /* Construct the API message */
18521 M (PG_CREATE_INTERFACE, mp);
18523 mp->interface_id = ntohl (if_id);
18524 mp->gso_enabled = gso_enabled;
18532 api_pg_capture (vat_main_t * vam)
18534 unformat_input_t *input = vam->input;
18535 vl_api_pg_capture_t *mp;
18540 u8 pcap_file_set = 0;
18543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18545 if (unformat (input, "if_id %d", &if_id))
18547 else if (unformat (input, "pcap %s", &pcap_file))
18549 else if (unformat (input, "count %d", &count))
18551 else if (unformat (input, "disable"))
18558 errmsg ("missing pg interface index");
18561 if (pcap_file_set > 0)
18563 if (vec_len (pcap_file) > 255)
18565 errmsg ("pcap file name is too long");
18570 /* Construct the API message */
18571 M (PG_CAPTURE, mp);
18573 mp->interface_id = ntohl (if_id);
18574 mp->is_enabled = enable;
18575 mp->count = ntohl (count);
18576 if (pcap_file_set != 0)
18578 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
18580 vec_free (pcap_file);
18588 api_pg_enable_disable (vat_main_t * vam)
18590 unformat_input_t *input = vam->input;
18591 vl_api_pg_enable_disable_t *mp;
18594 u8 stream_name_set = 0;
18595 u8 *stream_name = 0;
18597 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18599 if (unformat (input, "stream %s", &stream_name))
18600 stream_name_set = 1;
18601 else if (unformat (input, "disable"))
18607 if (stream_name_set > 0)
18609 if (vec_len (stream_name) > 255)
18611 errmsg ("stream name too long");
18616 /* Construct the API message */
18617 M (PG_ENABLE_DISABLE, mp);
18619 mp->is_enabled = enable;
18620 if (stream_name_set != 0)
18622 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
18624 vec_free (stream_name);
18632 api_pg_interface_enable_disable_coalesce (vat_main_t * vam)
18634 unformat_input_t *input = vam->input;
18635 vl_api_pg_interface_enable_disable_coalesce_t *mp;
18637 u32 sw_if_index = ~0;
18640 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18642 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18644 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18646 else if (unformat (input, "disable"))
18652 if (sw_if_index == ~0)
18654 errmsg ("Interface required but not specified");
18658 /* Construct the API message */
18659 M (PG_INTERFACE_ENABLE_DISABLE_COALESCE, mp);
18661 mp->coalesce_enabled = enable;
18662 mp->sw_if_index = htonl (sw_if_index);
18670 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18672 unformat_input_t *input = vam->input;
18673 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18675 u16 *low_ports = 0;
18676 u16 *high_ports = 0;
18679 vl_api_prefix_t prefix;
18686 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18688 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18690 else if (unformat (input, "vrf %d", &vrf_id))
18692 else if (unformat (input, "del"))
18694 else if (unformat (input, "port %d", &tmp))
18696 if (tmp == 0 || tmp > 65535)
18698 errmsg ("port %d out of range", tmp);
18702 this_hi = this_low + 1;
18703 vec_add1 (low_ports, this_low);
18704 vec_add1 (high_ports, this_hi);
18706 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18708 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18710 errmsg ("incorrect range parameters");
18714 /* Note: in debug CLI +1 is added to high before
18715 passing to real fn that does "the work"
18716 (ip_source_and_port_range_check_add_del).
18717 This fn is a wrapper around the binary API fn a
18718 control plane will call, which expects this increment
18719 to have occurred. Hence letting the binary API control
18720 plane fn do the increment for consistency between VAT
18721 and other control planes.
18724 vec_add1 (low_ports, this_low);
18725 vec_add1 (high_ports, this_hi);
18731 if (prefix_set == 0)
18733 errmsg ("<address>/<mask> not specified");
18739 errmsg ("VRF ID required, not specified");
18746 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18750 if (vec_len (low_ports) == 0)
18752 errmsg ("At least one port or port range required");
18756 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18758 mp->is_add = is_add;
18760 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18762 mp->number_of_ranges = vec_len (low_ports);
18764 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18765 vec_free (low_ports);
18767 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18768 vec_free (high_ports);
18770 mp->vrf_id = ntohl (vrf_id);
18778 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18780 unformat_input_t *input = vam->input;
18781 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18782 u32 sw_if_index = ~0;
18784 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18785 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18789 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18791 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18793 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18795 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18797 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18799 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18801 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18803 else if (unformat (input, "del"))
18809 if (sw_if_index == ~0)
18811 errmsg ("Interface required but not specified");
18817 errmsg ("VRF ID required but not specified");
18821 if (tcp_out_vrf_id == 0
18822 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18825 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18829 /* Construct the API message */
18830 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18832 mp->sw_if_index = ntohl (sw_if_index);
18833 mp->is_add = is_add;
18834 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18835 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18836 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18837 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18842 /* Wait for a reply... */
18848 api_set_punt (vat_main_t * vam)
18850 unformat_input_t *i = vam->input;
18851 vl_api_address_family_t af;
18852 vl_api_set_punt_t *mp;
18858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18860 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18862 else if (unformat (i, "protocol %d", &protocol))
18864 else if (unformat (i, "port %d", &port))
18866 else if (unformat (i, "del"))
18870 clib_warning ("parse error '%U'", format_unformat_error, i);
18877 mp->is_add = (u8) is_add;
18878 mp->punt.type = PUNT_API_TYPE_L4;
18879 mp->punt.punt.l4.af = af;
18880 mp->punt.punt.l4.protocol = (u8) protocol;
18881 mp->punt.punt.l4.port = htons ((u16) port);
18889 api_delete_subif (vat_main_t * vam)
18891 unformat_input_t *i = vam->input;
18892 vl_api_delete_subif_t *mp;
18893 u32 sw_if_index = ~0;
18896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18898 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18900 if (unformat (i, "sw_if_index %d", &sw_if_index))
18906 if (sw_if_index == ~0)
18908 errmsg ("missing sw_if_index");
18912 /* Construct the API message */
18913 M (DELETE_SUBIF, mp);
18914 mp->sw_if_index = ntohl (sw_if_index);
18921 #define foreach_pbb_vtr_op \
18922 _("disable", L2_VTR_DISABLED) \
18923 _("pop", L2_VTR_POP_2) \
18924 _("push", L2_VTR_PUSH_2)
18927 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18929 unformat_input_t *i = vam->input;
18930 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18931 u32 sw_if_index = ~0, vtr_op = ~0;
18932 u16 outer_tag = ~0;
18933 u8 dmac[6], smac[6];
18934 u8 dmac_set = 0, smac_set = 0;
18940 /* Shut up coverity */
18941 clib_memset (dmac, 0, sizeof (dmac));
18942 clib_memset (smac, 0, sizeof (smac));
18944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18946 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18948 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18950 else if (unformat (i, "vtr_op %d", &vtr_op))
18952 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18955 else if (unformat (i, "translate_pbb_stag"))
18957 if (unformat (i, "%d", &tmp))
18959 vtr_op = L2_VTR_TRANSLATE_2_1;
18965 ("translate_pbb_stag operation requires outer tag definition");
18969 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18971 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18973 else if (unformat (i, "sid %d", &sid))
18975 else if (unformat (i, "vlanid %d", &tmp))
18979 clib_warning ("parse error '%U'", format_unformat_error, i);
18984 if ((sw_if_index == ~0) || (vtr_op == ~0))
18986 errmsg ("missing sw_if_index or vtr operation");
18989 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18990 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18993 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18997 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18998 mp->sw_if_index = ntohl (sw_if_index);
18999 mp->vtr_op = ntohl (vtr_op);
19000 mp->outer_tag = ntohs (outer_tag);
19001 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19002 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19003 mp->b_vlanid = ntohs (vlanid);
19004 mp->i_sid = ntohl (sid);
19012 api_flow_classify_set_interface (vat_main_t * vam)
19014 unformat_input_t *i = vam->input;
19015 vl_api_flow_classify_set_interface_t *mp;
19017 int sw_if_index_set;
19018 u32 ip4_table_index = ~0;
19019 u32 ip6_table_index = ~0;
19023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19025 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19026 sw_if_index_set = 1;
19027 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19028 sw_if_index_set = 1;
19029 else if (unformat (i, "del"))
19031 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19033 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19037 clib_warning ("parse error '%U'", format_unformat_error, i);
19042 if (sw_if_index_set == 0)
19044 errmsg ("missing interface name or sw_if_index");
19048 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19050 mp->sw_if_index = ntohl (sw_if_index);
19051 mp->ip4_table_index = ntohl (ip4_table_index);
19052 mp->ip6_table_index = ntohl (ip6_table_index);
19053 mp->is_add = is_add;
19061 api_flow_classify_dump (vat_main_t * vam)
19063 unformat_input_t *i = vam->input;
19064 vl_api_flow_classify_dump_t *mp;
19065 vl_api_control_ping_t *mp_ping;
19066 u8 type = FLOW_CLASSIFY_N_TABLES;
19069 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19073 errmsg ("classify table type must be specified");
19077 if (!vam->json_output)
19079 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19082 M (FLOW_CLASSIFY_DUMP, mp);
19087 /* Use a control ping for synchronization */
19088 MPING (CONTROL_PING, mp_ping);
19091 /* Wait for a reply... */
19097 api_feature_enable_disable (vat_main_t * vam)
19099 unformat_input_t *i = vam->input;
19100 vl_api_feature_enable_disable_t *mp;
19102 u8 *feature_name = 0;
19103 u32 sw_if_index = ~0;
19107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19109 if (unformat (i, "arc_name %s", &arc_name))
19111 else if (unformat (i, "feature_name %s", &feature_name))
19114 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19116 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19118 else if (unformat (i, "disable"))
19126 errmsg ("missing arc name");
19129 if (vec_len (arc_name) > 63)
19131 errmsg ("arc name too long");
19134 if (feature_name == 0)
19136 errmsg ("missing feature name");
19139 if (vec_len (feature_name) > 63)
19141 errmsg ("feature name too long");
19144 if (sw_if_index == ~0)
19146 errmsg ("missing interface name or sw_if_index");
19150 /* Construct the API message */
19151 M (FEATURE_ENABLE_DISABLE, mp);
19152 mp->sw_if_index = ntohl (sw_if_index);
19153 mp->enable = enable;
19154 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19155 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19156 vec_free (arc_name);
19157 vec_free (feature_name);
19165 api_feature_gso_enable_disable (vat_main_t * vam)
19167 unformat_input_t *i = vam->input;
19168 vl_api_feature_gso_enable_disable_t *mp;
19169 u32 sw_if_index = ~0;
19173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19175 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19177 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19179 else if (unformat (i, "enable"))
19181 else if (unformat (i, "disable"))
19187 if (sw_if_index == ~0)
19189 errmsg ("missing interface name or sw_if_index");
19193 /* Construct the API message */
19194 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19195 mp->sw_if_index = ntohl (sw_if_index);
19196 mp->enable_disable = enable;
19204 api_sw_interface_tag_add_del (vat_main_t * vam)
19206 unformat_input_t *i = vam->input;
19207 vl_api_sw_interface_tag_add_del_t *mp;
19208 u32 sw_if_index = ~0;
19213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19215 if (unformat (i, "tag %s", &tag))
19217 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19219 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19221 else if (unformat (i, "del"))
19227 if (sw_if_index == ~0)
19229 errmsg ("missing interface name or sw_if_index");
19233 if (enable && (tag == 0))
19235 errmsg ("no tag specified");
19239 /* Construct the API message */
19240 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19241 mp->sw_if_index = ntohl (sw_if_index);
19242 mp->is_add = enable;
19244 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19253 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19255 unformat_input_t *i = vam->input;
19256 vl_api_mac_address_t mac = { 0 };
19257 vl_api_sw_interface_add_del_mac_address_t *mp;
19258 u32 sw_if_index = ~0;
19263 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19265 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19267 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19269 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19271 else if (unformat (i, "del"))
19277 if (sw_if_index == ~0)
19279 errmsg ("missing interface name or sw_if_index");
19285 errmsg ("missing MAC address");
19289 /* Construct the API message */
19290 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19291 mp->sw_if_index = ntohl (sw_if_index);
19292 mp->is_add = is_add;
19293 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19300 static void vl_api_l2_xconnect_details_t_handler
19301 (vl_api_l2_xconnect_details_t * mp)
19303 vat_main_t *vam = &vat_main;
19305 print (vam->ofp, "%15d%15d",
19306 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19309 static void vl_api_l2_xconnect_details_t_handler_json
19310 (vl_api_l2_xconnect_details_t * mp)
19312 vat_main_t *vam = &vat_main;
19313 vat_json_node_t *node = NULL;
19315 if (VAT_JSON_ARRAY != vam->json_tree.type)
19317 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19318 vat_json_init_array (&vam->json_tree);
19320 node = vat_json_array_add (&vam->json_tree);
19322 vat_json_init_object (node);
19323 vat_json_object_add_uint (node, "rx_sw_if_index",
19324 ntohl (mp->rx_sw_if_index));
19325 vat_json_object_add_uint (node, "tx_sw_if_index",
19326 ntohl (mp->tx_sw_if_index));
19330 api_l2_xconnect_dump (vat_main_t * vam)
19332 vl_api_l2_xconnect_dump_t *mp;
19333 vl_api_control_ping_t *mp_ping;
19336 if (!vam->json_output)
19338 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19341 M (L2_XCONNECT_DUMP, mp);
19345 /* Use a control ping for synchronization */
19346 MPING (CONTROL_PING, mp_ping);
19354 api_hw_interface_set_mtu (vat_main_t * vam)
19356 unformat_input_t *i = vam->input;
19357 vl_api_hw_interface_set_mtu_t *mp;
19358 u32 sw_if_index = ~0;
19362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19364 if (unformat (i, "mtu %d", &mtu))
19366 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19374 if (sw_if_index == ~0)
19376 errmsg ("missing interface name or sw_if_index");
19382 errmsg ("no mtu specified");
19386 /* Construct the API message */
19387 M (HW_INTERFACE_SET_MTU, mp);
19388 mp->sw_if_index = ntohl (sw_if_index);
19389 mp->mtu = ntohs ((u16) mtu);
19397 api_p2p_ethernet_add (vat_main_t * vam)
19399 unformat_input_t *i = vam->input;
19400 vl_api_p2p_ethernet_add_t *mp;
19401 u32 parent_if_index = ~0;
19407 clib_memset (remote_mac, 0, sizeof (remote_mac));
19408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19410 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19412 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19416 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19418 else if (unformat (i, "sub_id %d", &sub_id))
19422 clib_warning ("parse error '%U'", format_unformat_error, i);
19427 if (parent_if_index == ~0)
19429 errmsg ("missing interface name or sw_if_index");
19434 errmsg ("missing remote mac address");
19439 errmsg ("missing sub-interface id");
19443 M (P2P_ETHERNET_ADD, mp);
19444 mp->parent_if_index = ntohl (parent_if_index);
19445 mp->subif_id = ntohl (sub_id);
19446 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19454 api_p2p_ethernet_del (vat_main_t * vam)
19456 unformat_input_t *i = vam->input;
19457 vl_api_p2p_ethernet_del_t *mp;
19458 u32 parent_if_index = ~0;
19463 clib_memset (remote_mac, 0, sizeof (remote_mac));
19464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19466 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19468 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19472 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19476 clib_warning ("parse error '%U'", format_unformat_error, i);
19481 if (parent_if_index == ~0)
19483 errmsg ("missing interface name or sw_if_index");
19488 errmsg ("missing remote mac address");
19492 M (P2P_ETHERNET_DEL, mp);
19493 mp->parent_if_index = ntohl (parent_if_index);
19494 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19502 api_lldp_config (vat_main_t * vam)
19504 unformat_input_t *i = vam->input;
19505 vl_api_lldp_config_t *mp;
19507 int tx_interval = 0;
19508 u8 *sys_name = NULL;
19511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19513 if (unformat (i, "system-name %s", &sys_name))
19515 else if (unformat (i, "tx-hold %d", &tx_hold))
19517 else if (unformat (i, "tx-interval %d", &tx_interval))
19521 clib_warning ("parse error '%U'", format_unformat_error, i);
19526 vec_add1 (sys_name, 0);
19528 M (LLDP_CONFIG, mp);
19529 mp->tx_hold = htonl (tx_hold);
19530 mp->tx_interval = htonl (tx_interval);
19531 vl_api_vec_to_api_string (sys_name, &mp->system_name);
19532 vec_free (sys_name);
19540 api_sw_interface_set_lldp (vat_main_t * vam)
19542 unformat_input_t *i = vam->input;
19543 vl_api_sw_interface_set_lldp_t *mp;
19544 u32 sw_if_index = ~0;
19546 u8 *port_desc = NULL, *mgmt_oid = NULL;
19547 ip4_address_t ip4_addr;
19548 ip6_address_t ip6_addr;
19551 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19552 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19554 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19556 if (unformat (i, "disable"))
19559 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19561 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19563 else if (unformat (i, "port-desc %s", &port_desc))
19565 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19567 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19569 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19575 if (sw_if_index == ~0)
19577 errmsg ("missing interface name or sw_if_index");
19581 /* Construct the API message */
19582 vec_add1 (port_desc, 0);
19583 vec_add1 (mgmt_oid, 0);
19584 M (SW_INTERFACE_SET_LLDP, mp);
19585 mp->sw_if_index = ntohl (sw_if_index);
19586 mp->enable = enable;
19587 vl_api_vec_to_api_string (port_desc, &mp->port_desc);
19588 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19589 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19590 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19591 vec_free (port_desc);
19592 vec_free (mgmt_oid);
19600 api_tcp_configure_src_addresses (vat_main_t * vam)
19602 vl_api_tcp_configure_src_addresses_t *mp;
19603 unformat_input_t *i = vam->input;
19604 vl_api_address_t first, last;
19609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19611 if (unformat (i, "%U - %U",
19612 unformat_vl_api_address, &first,
19613 unformat_vl_api_address, &last))
19617 errmsg ("one range per message (range already set)");
19622 else if (unformat (i, "vrf %d", &vrf_id))
19628 if (range_set == 0)
19630 errmsg ("address range not set");
19634 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19636 mp->vrf_id = ntohl (vrf_id);
19637 clib_memcpy (&mp->first_address, &first, sizeof (first));
19638 clib_memcpy (&mp->last_address, &last, sizeof (last));
19645 static void vl_api_app_namespace_add_del_reply_t_handler
19646 (vl_api_app_namespace_add_del_reply_t * mp)
19648 vat_main_t *vam = &vat_main;
19649 i32 retval = ntohl (mp->retval);
19650 if (vam->async_mode)
19652 vam->async_errors += (retval < 0);
19656 vam->retval = retval;
19658 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19659 vam->result_ready = 1;
19663 static void vl_api_app_namespace_add_del_reply_t_handler_json
19664 (vl_api_app_namespace_add_del_reply_t * mp)
19666 vat_main_t *vam = &vat_main;
19667 vat_json_node_t node;
19669 vat_json_init_object (&node);
19670 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19671 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19673 vat_json_print (vam->ofp, &node);
19674 vat_json_free (&node);
19676 vam->retval = ntohl (mp->retval);
19677 vam->result_ready = 1;
19681 api_app_namespace_add_del (vat_main_t * vam)
19683 vl_api_app_namespace_add_del_t *mp;
19684 unformat_input_t *i = vam->input;
19685 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19686 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19692 if (unformat (i, "id %_%v%_", &ns_id))
19694 else if (unformat (i, "secret %lu", &secret))
19696 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19697 sw_if_index_set = 1;
19698 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19700 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19705 if (!ns_id || !secret_set || !sw_if_index_set)
19707 errmsg ("namespace id, secret and sw_if_index must be set");
19710 if (vec_len (ns_id) > 64)
19712 errmsg ("namespace id too long");
19715 M (APP_NAMESPACE_ADD_DEL, mp);
19717 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
19718 mp->secret = clib_host_to_net_u64 (secret);
19719 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19720 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19721 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19729 api_sock_init_shm (vat_main_t * vam)
19731 #if VPP_API_TEST_BUILTIN == 0
19732 unformat_input_t *i = vam->input;
19733 vl_api_shm_elem_config_t *config = 0;
19734 u64 size = 64 << 20;
19737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19739 if (unformat (i, "size %U", unformat_memory_size, &size))
19746 * Canned custom ring allocator config.
19747 * Should probably parse all of this
19749 vec_validate (config, 6);
19750 config[0].type = VL_API_VLIB_RING;
19751 config[0].size = 256;
19752 config[0].count = 32;
19754 config[1].type = VL_API_VLIB_RING;
19755 config[1].size = 1024;
19756 config[1].count = 16;
19758 config[2].type = VL_API_VLIB_RING;
19759 config[2].size = 4096;
19760 config[2].count = 2;
19762 config[3].type = VL_API_CLIENT_RING;
19763 config[3].size = 256;
19764 config[3].count = 32;
19766 config[4].type = VL_API_CLIENT_RING;
19767 config[4].size = 1024;
19768 config[4].count = 16;
19770 config[5].type = VL_API_CLIENT_RING;
19771 config[5].size = 4096;
19772 config[5].count = 2;
19774 config[6].type = VL_API_QUEUE;
19775 config[6].count = 128;
19776 config[6].size = sizeof (uword);
19778 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19780 vam->client_index_invalid = 1;
19788 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19790 vat_main_t *vam = &vat_main;
19791 fib_prefix_t lcl, rmt;
19793 ip_prefix_decode (&mp->lcl, &lcl);
19794 ip_prefix_decode (&mp->rmt, &rmt);
19796 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19799 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19800 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19801 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
19802 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19803 &rmt.fp_addr.ip4, rmt.fp_len,
19804 clib_net_to_host_u16 (mp->rmt_port),
19805 clib_net_to_host_u32 (mp->action_index), mp->tag);
19810 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19811 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19812 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
19813 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19814 &rmt.fp_addr.ip6, rmt.fp_len,
19815 clib_net_to_host_u16 (mp->rmt_port),
19816 clib_net_to_host_u32 (mp->action_index), mp->tag);
19821 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19824 vat_main_t *vam = &vat_main;
19825 vat_json_node_t *node = NULL;
19826 struct in6_addr ip6;
19827 struct in_addr ip4;
19829 fib_prefix_t lcl, rmt;
19831 ip_prefix_decode (&mp->lcl, &lcl);
19832 ip_prefix_decode (&mp->rmt, &rmt);
19834 if (VAT_JSON_ARRAY != vam->json_tree.type)
19836 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19837 vat_json_init_array (&vam->json_tree);
19839 node = vat_json_array_add (&vam->json_tree);
19840 vat_json_init_object (node);
19842 vat_json_object_add_uint (node, "appns_index",
19843 clib_net_to_host_u32 (mp->appns_index));
19844 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19845 vat_json_object_add_uint (node, "scope", mp->scope);
19846 vat_json_object_add_uint (node, "action_index",
19847 clib_net_to_host_u32 (mp->action_index));
19848 vat_json_object_add_uint (node, "lcl_port",
19849 clib_net_to_host_u16 (mp->lcl_port));
19850 vat_json_object_add_uint (node, "rmt_port",
19851 clib_net_to_host_u16 (mp->rmt_port));
19852 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
19853 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
19854 vat_json_object_add_string_copy (node, "tag", mp->tag);
19855 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19857 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
19858 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19859 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
19860 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19864 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
19865 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19866 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
19867 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19872 api_session_rule_add_del (vat_main_t * vam)
19874 vl_api_session_rule_add_del_t *mp;
19875 unformat_input_t *i = vam->input;
19876 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19877 u32 appns_index = 0, scope = 0;
19878 ip4_address_t lcl_ip4, rmt_ip4;
19879 ip6_address_t lcl_ip6, rmt_ip6;
19880 u8 is_ip4 = 1, conn_set = 0;
19881 u8 is_add = 1, *tag = 0;
19883 fib_prefix_t lcl, rmt;
19885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19887 if (unformat (i, "del"))
19889 else if (unformat (i, "add"))
19891 else if (unformat (i, "proto tcp"))
19893 else if (unformat (i, "proto udp"))
19895 else if (unformat (i, "appns %d", &appns_index))
19897 else if (unformat (i, "scope %d", &scope))
19899 else if (unformat (i, "tag %_%v%_", &tag))
19903 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19904 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19912 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19913 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19919 else if (unformat (i, "action %d", &action))
19924 if (proto == ~0 || !conn_set || action == ~0)
19926 errmsg ("transport proto, connection and action must be set");
19932 errmsg ("scope should be 0-3");
19936 M (SESSION_RULE_ADD_DEL, mp);
19938 clib_memset (&lcl, 0, sizeof (lcl));
19939 clib_memset (&rmt, 0, sizeof (rmt));
19942 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
19943 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
19944 lcl.fp_len = lcl_plen;
19945 rmt.fp_len = rmt_plen;
19949 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
19950 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
19951 lcl.fp_len = lcl_plen;
19952 rmt.fp_len = rmt_plen;
19956 ip_prefix_encode (&lcl, &mp->lcl);
19957 ip_prefix_encode (&rmt, &mp->rmt);
19958 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19959 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19960 mp->transport_proto =
19961 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
19962 mp->action_index = clib_host_to_net_u32 (action);
19963 mp->appns_index = clib_host_to_net_u32 (appns_index);
19965 mp->is_add = is_add;
19968 clib_memcpy (mp->tag, tag, vec_len (tag));
19978 api_session_rules_dump (vat_main_t * vam)
19980 vl_api_session_rules_dump_t *mp;
19981 vl_api_control_ping_t *mp_ping;
19984 if (!vam->json_output)
19986 print (vam->ofp, "%=20s", "Session Rules");
19989 M (SESSION_RULES_DUMP, mp);
19993 /* Use a control ping for synchronization */
19994 MPING (CONTROL_PING, mp_ping);
19997 /* Wait for a reply... */
20003 api_ip_container_proxy_add_del (vat_main_t * vam)
20005 vl_api_ip_container_proxy_add_del_t *mp;
20006 unformat_input_t *i = vam->input;
20007 u32 sw_if_index = ~0;
20008 vl_api_prefix_t pfx = { };
20012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20014 if (unformat (i, "del"))
20016 else if (unformat (i, "add"))
20018 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20020 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20025 if (sw_if_index == ~0 || pfx.len == 0)
20027 errmsg ("address and sw_if_index must be set");
20031 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20033 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20034 mp->is_add = is_add;
20035 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20043 api_qos_record_enable_disable (vat_main_t * vam)
20045 unformat_input_t *i = vam->input;
20046 vl_api_qos_record_enable_disable_t *mp;
20047 u32 sw_if_index, qs = 0xff;
20048 u8 sw_if_index_set = 0;
20052 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20054 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20055 sw_if_index_set = 1;
20056 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20057 sw_if_index_set = 1;
20058 else if (unformat (i, "%U", unformat_qos_source, &qs))
20060 else if (unformat (i, "disable"))
20064 clib_warning ("parse error '%U'", format_unformat_error, i);
20069 if (sw_if_index_set == 0)
20071 errmsg ("missing interface name or sw_if_index");
20076 errmsg ("input location must be specified");
20080 M (QOS_RECORD_ENABLE_DISABLE, mp);
20082 mp->record.sw_if_index = ntohl (sw_if_index);
20083 mp->record.input_source = qs;
20084 mp->enable = enable;
20093 q_or_quit (vat_main_t * vam)
20095 #if VPP_API_TEST_BUILTIN == 0
20096 longjmp (vam->jump_buf, 1);
20098 return 0; /* not so much */
20102 q (vat_main_t * vam)
20104 return q_or_quit (vam);
20108 quit (vat_main_t * vam)
20110 return q_or_quit (vam);
20114 comment (vat_main_t * vam)
20120 elog_save (vat_main_t * vam)
20122 #if VPP_API_TEST_BUILTIN == 0
20123 elog_main_t *em = &vam->elog_main;
20124 unformat_input_t *i = vam->input;
20125 char *file, *chroot_file;
20126 clib_error_t *error;
20128 if (!unformat (i, "%s", &file))
20130 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20134 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20135 if (strstr (file, "..") || index (file, '/'))
20137 errmsg ("illegal characters in filename '%s'", file);
20141 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20145 errmsg ("Saving %wd of %wd events to %s",
20146 elog_n_events_in_buffer (em),
20147 elog_buffer_capacity (em), chroot_file);
20149 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20150 vec_free (chroot_file);
20153 clib_error_report (error);
20155 errmsg ("Use the vpp event loger...");
20162 elog_setup (vat_main_t * vam)
20164 #if VPP_API_TEST_BUILTIN == 0
20165 elog_main_t *em = &vam->elog_main;
20166 unformat_input_t *i = vam->input;
20167 u32 nevents = 128 << 10;
20169 (void) unformat (i, "nevents %d", &nevents);
20171 elog_init (em, nevents);
20172 vl_api_set_elog_main (em);
20173 vl_api_set_elog_trace_api_messages (1);
20174 errmsg ("Event logger initialized with %u events", nevents);
20176 errmsg ("Use the vpp event loger...");
20182 elog_enable (vat_main_t * vam)
20184 #if VPP_API_TEST_BUILTIN == 0
20185 elog_main_t *em = &vam->elog_main;
20187 elog_enable_disable (em, 1 /* enable */ );
20188 vl_api_set_elog_trace_api_messages (1);
20189 errmsg ("Event logger enabled...");
20191 errmsg ("Use the vpp event loger...");
20197 elog_disable (vat_main_t * vam)
20199 #if VPP_API_TEST_BUILTIN == 0
20200 elog_main_t *em = &vam->elog_main;
20202 elog_enable_disable (em, 0 /* enable */ );
20203 vl_api_set_elog_trace_api_messages (1);
20204 errmsg ("Event logger disabled...");
20206 errmsg ("Use the vpp event loger...");
20212 statseg (vat_main_t * vam)
20214 ssvm_private_t *ssvmp = &vam->stat_segment;
20215 ssvm_shared_header_t *shared_header = ssvmp->sh;
20216 vlib_counter_t **counters;
20217 u64 thread0_index1_packets;
20218 u64 thread0_index1_bytes;
20219 f64 vector_rate, input_rate;
20222 uword *counter_vector_by_name;
20223 if (vam->stat_segment_lockp == 0)
20225 errmsg ("Stat segment not mapped...");
20229 /* look up "/if/rx for sw_if_index 1 as a test */
20231 clib_spinlock_lock (vam->stat_segment_lockp);
20233 counter_vector_by_name = (uword *) shared_header->opaque[1];
20235 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20238 clib_spinlock_unlock (vam->stat_segment_lockp);
20239 errmsg ("/if/tx not found?");
20243 /* Fish per-thread vector of combined counters from shared memory */
20244 counters = (vlib_counter_t **) p[0];
20246 if (vec_len (counters[0]) < 2)
20248 clib_spinlock_unlock (vam->stat_segment_lockp);
20249 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20253 /* Read thread 0 sw_if_index 1 counter */
20254 thread0_index1_packets = counters[0][1].packets;
20255 thread0_index1_bytes = counters[0][1].bytes;
20257 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20260 clib_spinlock_unlock (vam->stat_segment_lockp);
20261 errmsg ("vector_rate not found?");
20265 vector_rate = *(f64 *) (p[0]);
20266 p = hash_get_mem (counter_vector_by_name, "input_rate");
20269 clib_spinlock_unlock (vam->stat_segment_lockp);
20270 errmsg ("input_rate not found?");
20273 input_rate = *(f64 *) (p[0]);
20275 clib_spinlock_unlock (vam->stat_segment_lockp);
20277 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20278 vector_rate, input_rate);
20279 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20280 thread0_index1_packets, thread0_index1_bytes);
20286 cmd_cmp (void *a1, void *a2)
20291 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20295 help (vat_main_t * vam)
20300 unformat_input_t *i = vam->input;
20303 if (unformat (i, "%s", &name))
20307 vec_add1 (name, 0);
20309 hs = hash_get_mem (vam->help_by_name, name);
20311 print (vam->ofp, "usage: %s %s", name, hs[0]);
20313 print (vam->ofp, "No such msg / command '%s'", name);
20318 print (vam->ofp, "Help is available for the following:");
20321 hash_foreach_pair (p, vam->function_by_name,
20323 vec_add1 (cmds, (u8 *)(p->key));
20327 vec_sort_with_function (cmds, cmd_cmp);
20329 for (j = 0; j < vec_len (cmds); j++)
20330 print (vam->ofp, "%s", cmds[j]);
20337 set (vat_main_t * vam)
20339 u8 *name = 0, *value = 0;
20340 unformat_input_t *i = vam->input;
20342 if (unformat (i, "%s", &name))
20344 /* The input buffer is a vector, not a string. */
20345 value = vec_dup (i->buffer);
20346 vec_delete (value, i->index, 0);
20347 /* Almost certainly has a trailing newline */
20348 if (value[vec_len (value) - 1] == '\n')
20349 value[vec_len (value) - 1] = 0;
20350 /* Make sure it's a proper string, one way or the other */
20351 vec_add1 (value, 0);
20352 (void) clib_macro_set_value (&vam->macro_main,
20353 (char *) name, (char *) value);
20356 errmsg ("usage: set <name> <value>");
20364 unset (vat_main_t * vam)
20368 if (unformat (vam->input, "%s", &name))
20369 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20370 errmsg ("unset: %s wasn't set", name);
20383 macro_sort_cmp (void *a1, void *a2)
20385 macro_sort_t *s1 = a1;
20386 macro_sort_t *s2 = a2;
20388 return strcmp ((char *) (s1->name), (char *) (s2->name));
20392 dump_macro_table (vat_main_t * vam)
20394 macro_sort_t *sort_me = 0, *sm;
20399 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20401 vec_add2 (sort_me, sm, 1);
20402 sm->name = (u8 *)(p->key);
20403 sm->value = (u8 *) (p->value[0]);
20407 vec_sort_with_function (sort_me, macro_sort_cmp);
20409 if (vec_len (sort_me))
20410 print (vam->ofp, "%-15s%s", "Name", "Value");
20412 print (vam->ofp, "The macro table is empty...");
20414 for (i = 0; i < vec_len (sort_me); i++)
20415 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20420 dump_node_table (vat_main_t * vam)
20423 vlib_node_t *node, *next_node;
20425 if (vec_len (vam->graph_nodes) == 0)
20427 print (vam->ofp, "Node table empty, issue get_node_graph...");
20431 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20433 node = vam->graph_nodes[0][i];
20434 print (vam->ofp, "[%d] %s", i, node->name);
20435 for (j = 0; j < vec_len (node->next_nodes); j++)
20437 if (node->next_nodes[j] != ~0)
20439 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20440 print (vam->ofp, " [%d] %s", j, next_node->name);
20448 value_sort_cmp (void *a1, void *a2)
20450 name_sort_t *n1 = a1;
20451 name_sort_t *n2 = a2;
20453 if (n1->value < n2->value)
20455 if (n1->value > n2->value)
20462 dump_msg_api_table (vat_main_t * vam)
20464 api_main_t *am = vlibapi_get_main ();
20465 name_sort_t *nses = 0, *ns;
20470 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20472 vec_add2 (nses, ns, 1);
20473 ns->name = (u8 *)(hp->key);
20474 ns->value = (u32) hp->value[0];
20478 vec_sort_with_function (nses, value_sort_cmp);
20480 for (i = 0; i < vec_len (nses); i++)
20481 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20487 get_msg_id (vat_main_t * vam)
20492 if (unformat (vam->input, "%s", &name_and_crc))
20494 message_index = vl_msg_api_get_msg_index (name_and_crc);
20495 if (message_index == ~0)
20497 print (vam->ofp, " '%s' not found", name_and_crc);
20500 print (vam->ofp, " '%s' has message index %d",
20501 name_and_crc, message_index);
20504 errmsg ("name_and_crc required...");
20509 search_node_table (vat_main_t * vam)
20511 unformat_input_t *line_input = vam->input;
20514 vlib_node_t *node, *next_node;
20517 if (vam->graph_node_index_by_name == 0)
20519 print (vam->ofp, "Node table empty, issue get_node_graph...");
20523 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20525 if (unformat (line_input, "%s", &node_to_find))
20527 vec_add1 (node_to_find, 0);
20528 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20531 print (vam->ofp, "%s not found...", node_to_find);
20534 node = vam->graph_nodes[0][p[0]];
20535 print (vam->ofp, "[%d] %s", p[0], node->name);
20536 for (j = 0; j < vec_len (node->next_nodes); j++)
20538 if (node->next_nodes[j] != ~0)
20540 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20541 print (vam->ofp, " [%d] %s", j, next_node->name);
20548 clib_warning ("parse error '%U'", format_unformat_error,
20554 vec_free (node_to_find);
20563 script (vat_main_t * vam)
20565 #if (VPP_API_TEST_BUILTIN==0)
20567 char *save_current_file;
20568 unformat_input_t save_input;
20569 jmp_buf save_jump_buf;
20570 u32 save_line_number;
20572 FILE *new_fp, *save_ifp;
20574 if (unformat (vam->input, "%s", &s))
20576 new_fp = fopen ((char *) s, "r");
20579 errmsg ("Couldn't open script file %s", s);
20586 errmsg ("Missing script name");
20590 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20591 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20592 save_ifp = vam->ifp;
20593 save_line_number = vam->input_line_number;
20594 save_current_file = (char *) vam->current_file;
20596 vam->input_line_number = 0;
20598 vam->current_file = s;
20601 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20602 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20603 vam->ifp = save_ifp;
20604 vam->input_line_number = save_line_number;
20605 vam->current_file = (u8 *) save_current_file;
20610 clib_warning ("use the exec command...");
20616 echo (vat_main_t * vam)
20618 print (vam->ofp, "%v", vam->input->buffer);
20622 /* List of API message constructors, CLI names map to api_xxx */
20623 #define foreach_vpe_api_msg \
20624 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20625 _(sw_interface_dump,"") \
20626 _(sw_interface_set_flags, \
20627 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20628 _(sw_interface_add_del_address, \
20629 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20630 _(sw_interface_set_rx_mode, \
20631 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20632 _(sw_interface_set_rx_placement, \
20633 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20634 _(sw_interface_rx_placement_dump, \
20635 "[<intfc> | sw_if_index <id>]") \
20636 _(sw_interface_set_table, \
20637 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20638 _(sw_interface_set_mpls_enable, \
20639 "<intfc> | sw_if_index [disable | dis]") \
20640 _(sw_interface_set_vpath, \
20641 "<intfc> | sw_if_index <id> enable | disable") \
20642 _(sw_interface_set_vxlan_bypass, \
20643 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20644 _(sw_interface_set_geneve_bypass, \
20645 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20646 _(sw_interface_set_l2_xconnect, \
20647 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20648 "enable | disable") \
20649 _(sw_interface_set_l2_bridge, \
20650 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20651 "[shg <split-horizon-group>] [bvi]\n" \
20652 "enable | disable") \
20653 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20654 _(bridge_domain_add_del, \
20655 "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") \
20656 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20658 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20659 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20660 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20662 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20664 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20666 "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload | gro-coalesce] [persist] [attach] [tun] [packed] [in-order]") \
20668 "<vpp-if-name> | sw_if_index <id>") \
20669 _(sw_interface_tap_v2_dump, "") \
20670 _(virtio_pci_create, \
20671 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20672 _(virtio_pci_delete, \
20673 "<vpp-if-name> | sw_if_index <id>") \
20674 _(sw_interface_virtio_pci_dump, "") \
20676 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20677 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20680 "<vpp-if-name> | sw_if_index <id>") \
20681 _(bond_add_member, \
20682 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20683 _(bond_detach_member, \
20684 "sw_if_index <n>") \
20685 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20686 _(sw_bond_interface_dump, "<intfc> | sw_if_index <nn>") \
20687 _(sw_member_interface_dump, \
20688 "<vpp-if-name> | sw_if_index <id>") \
20689 _(ip_table_add_del, \
20690 "table <n> [ipv6] [add | del]\n") \
20691 _(ip_route_add_del, \
20692 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20693 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20694 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20695 "[multipath] [count <n>] [del]") \
20696 _(ip_mroute_add_del, \
20697 "<src> <grp>/<mask> [table-id <n>]\n" \
20698 "[<intfc> | sw_if_index <id>] [local] [del]") \
20699 _(mpls_table_add_del, \
20700 "table <n> [add | del]\n") \
20701 _(mpls_route_add_del, \
20702 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20703 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20704 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20705 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20706 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20707 "[count <n>] [del]") \
20708 _(mpls_ip_bind_unbind, \
20709 "<label> <addr/len>") \
20710 _(mpls_tunnel_add_del, \
20711 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20712 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20713 "[l2-only] [out-label <n>]") \
20714 _(sr_mpls_policy_add, \
20715 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20716 _(sr_mpls_policy_del, \
20718 _(bier_table_add_del, \
20719 "<label> <sub-domain> <set> <bsl> [del]") \
20720 _(bier_route_add_del, \
20721 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20722 "[<intfc> | sw_if_index <id>]" \
20723 "[weight <n>] [del] [multipath]") \
20724 _(sw_interface_set_unnumbered, \
20725 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20726 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20727 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20728 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20729 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20730 "[outer_vlan_id_any][inner_vlan_id_any]") \
20731 _(ip_table_replace_begin, "table <n> [ipv6]") \
20732 _(ip_table_flush, "table <n> [ipv6]") \
20733 _(ip_table_replace_end, "table <n> [ipv6]") \
20734 _(set_ip_flow_hash, \
20735 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20736 _(sw_interface_ip6_enable_disable, \
20737 "<intfc> | sw_if_index <id> enable | disable") \
20738 _(l2_patch_add_del, \
20739 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20740 "enable | disable") \
20741 _(sr_localsid_add_del, \
20742 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20743 "fib-table <num> (end.psp) sw_if_index <num>") \
20744 _(classify_add_del_table, \
20745 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20746 " [del] [del-chain] mask <mask-value>\n" \
20747 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20748 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20749 _(classify_add_del_session, \
20750 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20751 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20752 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20753 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20754 _(classify_set_interface_ip_table, \
20755 "<intfc> | sw_if_index <nn> table <nn>") \
20756 _(classify_set_interface_l2_tables, \
20757 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20758 " [other-table <nn>]") \
20759 _(get_node_index, "node <node-name") \
20760 _(add_node_next, "node <node-name> next <next-node-name>") \
20761 _(l2tpv3_create_tunnel, \
20762 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20763 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20764 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20765 _(l2tpv3_set_tunnel_cookies, \
20766 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20767 "[new_remote_cookie <nn>]\n") \
20768 _(l2tpv3_interface_enable_disable, \
20769 "<intfc> | sw_if_index <nn> enable | disable") \
20770 _(l2tpv3_set_lookup_key, \
20771 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20772 _(sw_if_l2tpv3_tunnel_dump, "") \
20773 _(vxlan_offload_rx, \
20774 "hw { <interface name> | hw_if_index <nn>} " \
20775 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20776 _(vxlan_add_del_tunnel, \
20777 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20778 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20779 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20780 _(geneve_add_del_tunnel, \
20781 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20782 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20783 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20784 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20785 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20786 _(gre_tunnel_add_del, \
20787 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20788 "[teb | erspan <session-id>] [del]") \
20789 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20790 _(l2_fib_clear_table, "") \
20791 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20792 _(l2_interface_vlan_tag_rewrite, \
20793 "<intfc> | sw_if_index <nn> \n" \
20794 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20795 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20796 _(create_vhost_user_if, \
20797 "socket <filename> [server] [renumber <dev_instance>] " \
20798 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20799 "[mac <mac_address>] [packed]") \
20800 _(modify_vhost_user_if, \
20801 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20802 "[server] [renumber <dev_instance>] [gso] [packed]") \
20803 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20804 _(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
20805 _(show_version, "") \
20806 _(show_threads, "") \
20807 _(vxlan_gpe_add_del_tunnel, \
20808 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20809 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20810 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20811 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20812 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20813 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20814 _(interface_name_renumber, \
20815 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20816 _(input_acl_set_interface, \
20817 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20818 " [l2-table <nn>] [del]") \
20819 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20820 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20821 _(ip_dump, "ipv4 | ipv6") \
20822 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20823 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20825 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20826 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20827 " integ_alg <alg> integ_key <hex>") \
20828 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20829 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20830 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20831 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20832 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20833 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20834 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20835 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20836 " [instance <n>]") \
20837 _(ipsec_sa_dump, "[sa_id <n>]") \
20838 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20839 _(delete_loopback,"sw_if_index <nn>") \
20840 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20841 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20842 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20843 _(want_interface_events, "enable|disable") \
20844 _(get_first_msg_id, "client <name>") \
20845 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20846 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20847 "fib-id <nn> [ip4][ip6][default]") \
20848 _(get_node_graph, " ") \
20849 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20850 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20851 _(ioam_disable, "") \
20852 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20853 " sw_if_index <sw_if_index> p <priority> " \
20854 "w <weight>] [del]") \
20855 _(one_add_del_locator, "locator-set <locator_name> " \
20856 "iface <intf> | sw_if_index <sw_if_index> " \
20857 "p <priority> w <weight> [del]") \
20858 _(one_add_del_local_eid,"vni <vni> eid " \
20859 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20860 "locator-set <locator_name> [del]" \
20861 "[key-id sha1|sha256 secret-key <secret-key>]")\
20862 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20863 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20864 _(one_enable_disable, "enable|disable") \
20865 _(one_map_register_enable_disable, "enable|disable") \
20866 _(one_map_register_fallback_threshold, "<value>") \
20867 _(one_rloc_probe_enable_disable, "enable|disable") \
20868 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20870 "rloc <locator> p <prio> " \
20871 "w <weight> [rloc <loc> ... ] " \
20872 "action <action> [del-all]") \
20873 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20875 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20876 _(one_use_petr, "ip-address> | disable") \
20877 _(one_map_request_mode, "src-dst|dst-only") \
20878 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20879 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20880 _(one_locator_set_dump, "[local | remote]") \
20881 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20882 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20883 "[local] | [remote]") \
20884 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20885 _(one_ndp_bd_get, "") \
20886 _(one_ndp_entries_get, "bd <bridge-domain>") \
20887 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20888 _(one_l2_arp_bd_get, "") \
20889 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20890 _(one_stats_enable_disable, "enable|disable") \
20891 _(show_one_stats_enable_disable, "") \
20892 _(one_eid_table_vni_dump, "") \
20893 _(one_eid_table_map_dump, "l2|l3") \
20894 _(one_map_resolver_dump, "") \
20895 _(one_map_server_dump, "") \
20896 _(one_adjacencies_get, "vni <vni>") \
20897 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20898 _(show_one_rloc_probe_state, "") \
20899 _(show_one_map_register_state, "") \
20900 _(show_one_status, "") \
20901 _(one_stats_dump, "") \
20902 _(one_stats_flush, "") \
20903 _(one_get_map_request_itr_rlocs, "") \
20904 _(one_map_register_set_ttl, "<ttl>") \
20905 _(one_set_transport_protocol, "udp|api") \
20906 _(one_get_transport_protocol, "") \
20907 _(one_enable_disable_xtr_mode, "enable|disable") \
20908 _(one_show_xtr_mode, "") \
20909 _(one_enable_disable_pitr_mode, "enable|disable") \
20910 _(one_show_pitr_mode, "") \
20911 _(one_enable_disable_petr_mode, "enable|disable") \
20912 _(one_show_petr_mode, "") \
20913 _(show_one_nsh_mapping, "") \
20914 _(show_one_pitr, "") \
20915 _(show_one_use_petr, "") \
20916 _(show_one_map_request_mode, "") \
20917 _(show_one_map_register_ttl, "") \
20918 _(show_one_map_register_fallback_threshold, "") \
20919 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20920 " sw_if_index <sw_if_index> p <priority> " \
20921 "w <weight>] [del]") \
20922 _(lisp_add_del_locator, "locator-set <locator_name> " \
20923 "iface <intf> | sw_if_index <sw_if_index> " \
20924 "p <priority> w <weight> [del]") \
20925 _(lisp_add_del_local_eid,"vni <vni> eid " \
20926 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20927 "locator-set <locator_name> [del]" \
20928 "[key-id sha1|sha256 secret-key <secret-key>]") \
20929 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20930 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20931 _(lisp_enable_disable, "enable|disable") \
20932 _(lisp_map_register_enable_disable, "enable|disable") \
20933 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20934 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20936 "rloc <locator> p <prio> " \
20937 "w <weight> [rloc <loc> ... ] " \
20938 "action <action> [del-all]") \
20939 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20941 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20942 _(lisp_use_petr, "<ip-address> | disable") \
20943 _(lisp_map_request_mode, "src-dst|dst-only") \
20944 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20945 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20946 _(lisp_locator_set_dump, "[local | remote]") \
20947 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20948 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20949 "[local] | [remote]") \
20950 _(lisp_eid_table_vni_dump, "") \
20951 _(lisp_eid_table_map_dump, "l2|l3") \
20952 _(lisp_map_resolver_dump, "") \
20953 _(lisp_map_server_dump, "") \
20954 _(lisp_adjacencies_get, "vni <vni>") \
20955 _(gpe_fwd_entry_vnis_get, "") \
20956 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20957 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20958 "[table <table-id>]") \
20959 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20960 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20961 _(gpe_set_encap_mode, "lisp|vxlan") \
20962 _(gpe_get_encap_mode, "") \
20963 _(lisp_gpe_add_del_iface, "up|down") \
20964 _(lisp_gpe_enable_disable, "enable|disable") \
20965 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20966 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20967 _(show_lisp_rloc_probe_state, "") \
20968 _(show_lisp_map_register_state, "") \
20969 _(show_lisp_status, "") \
20970 _(lisp_get_map_request_itr_rlocs, "") \
20971 _(show_lisp_pitr, "") \
20972 _(show_lisp_use_petr, "") \
20973 _(show_lisp_map_request_mode, "") \
20974 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20975 _(af_packet_delete, "name <host interface name>") \
20976 _(af_packet_dump, "") \
20977 _(policer_add_del, "name <policer name> <params> [del]") \
20978 _(policer_dump, "[name <policer name>]") \
20979 _(policer_classify_set_interface, \
20980 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20981 " [l2-table <nn>] [del]") \
20982 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20983 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20984 _(mpls_table_dump, "") \
20985 _(mpls_route_dump, "table-id <ID>") \
20986 _(classify_table_ids, "") \
20987 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20988 _(classify_table_info, "table_id <nn>") \
20989 _(classify_session_dump, "table_id <nn>") \
20990 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20991 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20992 "[template_interval <nn>] [udp_checksum]") \
20993 _(ipfix_exporter_dump, "") \
20994 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20995 _(ipfix_classify_stream_dump, "") \
20996 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20997 _(ipfix_classify_table_dump, "") \
20998 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20999 _(sw_interface_span_dump, "[l2]") \
21000 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
21001 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
21002 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
21003 _(pg_enable_disable, "[stream <id>] disable") \
21004 _(pg_interface_enable_disable_coalesce, "<intf> | sw_if_index <nn> enable | disable") \
21005 _(ip_source_and_port_range_check_add_del, \
21006 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21007 _(ip_source_and_port_range_check_interface_add_del, \
21008 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21009 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21010 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21011 _(l2_interface_pbb_tag_rewrite, \
21012 "<intfc> | sw_if_index <nn> \n" \
21013 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21014 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21015 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21016 _(flow_classify_set_interface, \
21017 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21018 _(flow_classify_dump, "type [ip4|ip6]") \
21019 _(ip_table_dump, "") \
21020 _(ip_route_dump, "table-id [ip4|ip6]") \
21021 _(ip_mtable_dump, "") \
21022 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21023 _(feature_enable_disable, "arc_name <arc_name> " \
21024 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21025 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21026 "[enable | disable] ") \
21027 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21029 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21030 "mac <mac-address> [del]") \
21031 _(l2_xconnect_dump, "") \
21032 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21033 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21034 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21035 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21036 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21037 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21038 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21039 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21040 _(sock_init_shm, "size <nnn>") \
21041 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21042 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21043 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21044 _(session_rules_dump, "") \
21045 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21046 _(output_acl_set_interface, \
21047 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21048 " [l2-table <nn>] [del]") \
21049 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21051 /* List of command functions, CLI names map directly to functions */
21052 #define foreach_cli_function \
21053 _(comment, "usage: comment <ignore-rest-of-line>") \
21054 _(dump_interface_table, "usage: dump_interface_table") \
21055 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21056 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21057 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21058 _(dump_macro_table, "usage: dump_macro_table ") \
21059 _(dump_node_table, "usage: dump_node_table") \
21060 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21061 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21062 _(elog_disable, "usage: elog_disable") \
21063 _(elog_enable, "usage: elog_enable") \
21064 _(elog_save, "usage: elog_save <filename>") \
21065 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21066 _(echo, "usage: echo <message>") \
21067 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21068 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21069 _(help, "usage: help") \
21070 _(q, "usage: quit") \
21071 _(quit, "usage: quit") \
21072 _(search_node_table, "usage: search_node_table <name>...") \
21073 _(set, "usage: set <variable-name> <value>") \
21074 _(script, "usage: script <file-name>") \
21075 _(statseg, "usage: statseg") \
21076 _(unset, "usage: unset <variable-name>")
21079 static void vl_api_##n##_t_handler_uni \
21080 (vl_api_##n##_t * mp) \
21082 vat_main_t * vam = &vat_main; \
21083 if (vam->json_output) { \
21084 vl_api_##n##_t_handler_json(mp); \
21086 vl_api_##n##_t_handler(mp); \
21089 foreach_vpe_api_reply_msg;
21090 #if VPP_API_TEST_BUILTIN == 0
21091 foreach_standalone_reply_msg;
21096 vat_api_hookup (vat_main_t * vam)
21099 vl_msg_api_set_handlers(VL_API_##N, #n, \
21100 vl_api_##n##_t_handler_uni, \
21102 vl_api_##n##_t_endian, \
21103 vl_api_##n##_t_print, \
21104 sizeof(vl_api_##n##_t), 1);
21105 foreach_vpe_api_reply_msg;
21106 #if VPP_API_TEST_BUILTIN == 0
21107 foreach_standalone_reply_msg;
21111 #if (VPP_API_TEST_BUILTIN==0)
21112 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21114 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21116 vam->function_by_name = hash_create_string (0, sizeof (uword));
21118 vam->help_by_name = hash_create_string (0, sizeof (uword));
21121 /* API messages we can send */
21122 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21123 foreach_vpe_api_msg;
21127 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21128 foreach_vpe_api_msg;
21131 /* CLI functions */
21132 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21133 foreach_cli_function;
21137 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21138 foreach_cli_function;
21142 #if VPP_API_TEST_BUILTIN
21143 static clib_error_t *
21144 vat_api_hookup_shim (vlib_main_t * vm)
21146 vat_api_hookup (&vat_main);
21150 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21154 * fd.io coding-style-patch-verification: ON
21157 * eval: (c-set-style "gnu")