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)
5174 static void vl_api_##n##_t_handler \
5175 (vl_api_##n##_t * mp) \
5177 vat_main_t * vam = &vat_main; \
5178 i32 retval = ntohl(mp->retval); \
5179 if (vam->async_mode) { \
5180 vam->async_errors += (retval < 0); \
5182 vam->retval = retval; \
5183 vam->result_ready = 1; \
5186 foreach_standard_reply_retval_handler;
5190 static void vl_api_##n##_t_handler_json \
5191 (vl_api_##n##_t * mp) \
5193 vat_main_t * vam = &vat_main; \
5194 vat_json_node_t node; \
5195 vat_json_init_object(&node); \
5196 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5197 vat_json_print(vam->ofp, &node); \
5198 vam->retval = ntohl(mp->retval); \
5199 vam->result_ready = 1; \
5201 foreach_standard_reply_retval_handler;
5205 * Table of message reply handlers, must include boilerplate handlers
5209 #define foreach_vpe_api_reply_msg \
5210 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5211 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5212 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5213 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5214 _(CONTROL_PING_REPLY, control_ping_reply) \
5215 _(CLI_REPLY, cli_reply) \
5216 _(CLI_INBAND_REPLY, cli_inband_reply) \
5217 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5218 sw_interface_add_del_address_reply) \
5219 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5220 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5221 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5222 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5223 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5224 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5225 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5226 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5227 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5228 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5229 sw_interface_set_l2_xconnect_reply) \
5230 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5231 sw_interface_set_l2_bridge_reply) \
5232 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5233 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5234 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5235 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5236 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5237 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5238 _(L2_FLAGS_REPLY, l2_flags_reply) \
5239 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5240 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5241 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5242 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5243 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5244 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5245 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5246 _(BOND_CREATE_REPLY, bond_create_reply) \
5247 _(BOND_DELETE_REPLY, bond_delete_reply) \
5248 _(BOND_ADD_MEMBER_REPLY, bond_add_member_reply) \
5249 _(BOND_DETACH_MEMBER_REPLY, bond_detach_member_reply) \
5250 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5251 _(SW_BOND_INTERFACE_DETAILS, sw_bond_interface_details) \
5252 _(SW_MEMBER_INTERFACE_DETAILS, sw_member_interface_details) \
5253 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5254 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5255 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5256 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5257 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5258 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5259 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5260 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5261 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5262 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5263 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5264 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5265 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5266 sw_interface_set_unnumbered_reply) \
5267 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5268 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5269 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5270 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5271 sw_interface_ip6_enable_disable_reply) \
5272 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5273 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5274 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5275 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5276 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5277 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5278 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5279 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5280 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5281 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5282 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5283 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5284 classify_set_interface_ip_table_reply) \
5285 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5286 classify_set_interface_l2_tables_reply) \
5287 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5288 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5289 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5290 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5291 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5292 l2tpv3_interface_enable_disable_reply) \
5293 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5294 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5295 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5296 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5297 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5298 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5299 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5300 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5301 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5302 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5303 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5304 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5305 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5306 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5307 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5308 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5309 _(SHOW_VERSION_REPLY, show_version_reply) \
5310 _(SHOW_THREADS_REPLY, show_threads_reply) \
5311 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5312 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5313 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5314 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5315 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5316 _(L2_MACS_EVENT, l2_macs_event) \
5317 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5318 _(IP_ADDRESS_DETAILS, ip_address_details) \
5319 _(IP_DETAILS, ip_details) \
5320 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5321 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5322 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5323 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5324 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5325 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5326 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5327 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5328 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5329 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5330 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5331 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5332 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5333 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5334 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5335 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5336 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5337 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5338 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5339 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5340 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5341 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5342 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5343 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5344 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5345 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5346 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5347 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5348 one_map_register_enable_disable_reply) \
5349 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5350 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5351 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5352 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5353 one_map_register_fallback_threshold_reply) \
5354 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5355 one_rloc_probe_enable_disable_reply) \
5356 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5357 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5358 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5359 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5360 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5361 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5362 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5363 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5364 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5365 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5366 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5367 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5368 _(ONE_STATS_DETAILS, one_stats_details) \
5369 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5370 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5371 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5372 show_one_stats_enable_disable_reply) \
5373 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5374 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5375 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5376 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5377 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5378 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5379 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5380 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5381 one_enable_disable_pitr_mode_reply) \
5382 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5383 one_enable_disable_petr_mode_reply) \
5384 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5385 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5386 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5387 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5388 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5389 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5390 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5391 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5392 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5393 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5394 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5395 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5396 gpe_add_del_native_fwd_rpath_reply) \
5397 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5398 gpe_fwd_entry_path_details) \
5399 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5400 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5401 one_add_del_map_request_itr_rlocs_reply) \
5402 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5403 one_get_map_request_itr_rlocs_reply) \
5404 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5405 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5406 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5407 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5408 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5409 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5410 show_one_map_register_state_reply) \
5411 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5412 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5413 show_one_map_register_fallback_threshold_reply) \
5414 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5415 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5416 _(AF_PACKET_DETAILS, af_packet_details) \
5417 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5418 _(POLICER_DETAILS, policer_details) \
5419 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5420 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5421 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5422 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5423 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5424 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5425 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5426 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5427 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5428 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5429 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5430 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5431 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5432 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5433 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5434 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5435 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5436 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5437 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5438 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5439 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5440 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5441 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5442 _(PG_INTERFACE_ENABLE_DISABLE_COALESCE_REPLY, pg_interface_enable_disable_coalesce_reply) \
5443 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5444 ip_source_and_port_range_check_add_del_reply) \
5445 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5446 ip_source_and_port_range_check_interface_add_del_reply) \
5447 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5448 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5449 _(SET_PUNT_REPLY, set_punt_reply) \
5450 _(IP_TABLE_DETAILS, ip_table_details) \
5451 _(IP_ROUTE_DETAILS, ip_route_details) \
5452 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5453 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5454 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5455 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5456 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5457 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5458 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5459 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5460 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5461 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5462 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5463 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5464 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5465 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5466 _(SESSION_RULES_DETAILS, session_rules_details) \
5467 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5468 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5469 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5471 #define foreach_standalone_reply_msg \
5472 _(SW_INTERFACE_EVENT, sw_interface_event)
5480 #define STR_VTR_OP_CASE(op) \
5481 case L2_VTR_ ## op: \
5485 str_vtr_op (u32 vtr_op)
5489 STR_VTR_OP_CASE (DISABLED);
5490 STR_VTR_OP_CASE (PUSH_1);
5491 STR_VTR_OP_CASE (PUSH_2);
5492 STR_VTR_OP_CASE (POP_1);
5493 STR_VTR_OP_CASE (POP_2);
5494 STR_VTR_OP_CASE (TRANSLATE_1_1);
5495 STR_VTR_OP_CASE (TRANSLATE_1_2);
5496 STR_VTR_OP_CASE (TRANSLATE_2_1);
5497 STR_VTR_OP_CASE (TRANSLATE_2_2);
5504 dump_sub_interface_table (vat_main_t * vam)
5506 const sw_interface_subif_t *sub = NULL;
5508 if (vam->json_output)
5511 ("JSON output supported only for VPE API calls and dump_stats_table");
5516 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5517 "Interface", "sw_if_index",
5518 "sub id", "dot1ad", "tags", "outer id",
5519 "inner id", "exact", "default", "outer any", "inner any");
5521 vec_foreach (sub, vam->sw_if_subif_table)
5524 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5525 sub->interface_name,
5527 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5528 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5529 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5530 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5531 if (sub->vtr_op != L2_VTR_DISABLED)
5534 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5535 "tag1: %d tag2: %d ]",
5536 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5537 sub->vtr_tag1, sub->vtr_tag2);
5545 name_sort_cmp (void *a1, void *a2)
5547 name_sort_t *n1 = a1;
5548 name_sort_t *n2 = a2;
5550 return strcmp ((char *) n1->name, (char *) n2->name);
5554 dump_interface_table (vat_main_t * vam)
5557 name_sort_t *nses = 0, *ns;
5559 if (vam->json_output)
5562 ("JSON output supported only for VPE API calls and dump_stats_table");
5567 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5569 vec_add2 (nses, ns, 1);
5570 ns->name = (u8 *)(p->key);
5571 ns->value = (u32) p->value[0];
5575 vec_sort_with_function (nses, name_sort_cmp);
5577 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5578 vec_foreach (ns, nses)
5580 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5587 dump_ip_table (vat_main_t * vam, int is_ipv6)
5589 const ip_details_t *det = NULL;
5590 const ip_address_details_t *address = NULL;
5593 print (vam->ofp, "%-12s", "sw_if_index");
5595 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5602 print (vam->ofp, "%-12d", i);
5603 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5608 vec_foreach (address, det->addr)
5612 is_ipv6 ? format_ip6_address : format_ip4_address,
5613 address->ip, address->prefix_length);
5621 dump_ipv4_table (vat_main_t * vam)
5623 if (vam->json_output)
5626 ("JSON output supported only for VPE API calls and dump_stats_table");
5630 return dump_ip_table (vam, 0);
5634 dump_ipv6_table (vat_main_t * vam)
5636 if (vam->json_output)
5639 ("JSON output supported only for VPE API calls and dump_stats_table");
5643 return dump_ip_table (vam, 1);
5647 * Pass CLI buffers directly in the CLI_INBAND API message,
5648 * instead of an additional shared memory area.
5651 exec_inband (vat_main_t * vam)
5653 vl_api_cli_inband_t *mp;
5654 unformat_input_t *i = vam->input;
5657 if (vec_len (i->buffer) == 0)
5660 if (vam->exec_mode == 0 && unformat (i, "mode"))
5665 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5672 * In order for the CLI command to work, it
5673 * must be a vector ending in \n, not a C-string ending
5676 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
5677 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
5681 /* json responses may or may not include a useful reply... */
5682 if (vec_len (vam->cmd_reply))
5683 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5688 exec (vat_main_t * vam)
5690 return exec_inband (vam);
5694 api_create_loopback (vat_main_t * vam)
5696 unformat_input_t *i = vam->input;
5697 vl_api_create_loopback_t *mp;
5698 vl_api_create_loopback_instance_t *mp_lbi;
5701 u8 is_specified = 0;
5702 u32 user_instance = 0;
5705 clib_memset (mac_address, 0, sizeof (mac_address));
5707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5709 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5711 if (unformat (i, "instance %d", &user_instance))
5719 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5720 mp_lbi->is_specified = is_specified;
5722 mp_lbi->user_instance = htonl (user_instance);
5724 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5729 /* Construct the API message */
5730 M (CREATE_LOOPBACK, mp);
5732 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5741 api_delete_loopback (vat_main_t * vam)
5743 unformat_input_t *i = vam->input;
5744 vl_api_delete_loopback_t *mp;
5745 u32 sw_if_index = ~0;
5748 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5750 if (unformat (i, "sw_if_index %d", &sw_if_index))
5756 if (sw_if_index == ~0)
5758 errmsg ("missing sw_if_index");
5762 /* Construct the API message */
5763 M (DELETE_LOOPBACK, mp);
5764 mp->sw_if_index = ntohl (sw_if_index);
5772 api_want_interface_events (vat_main_t * vam)
5774 unformat_input_t *i = vam->input;
5775 vl_api_want_interface_events_t *mp;
5779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5781 if (unformat (i, "enable"))
5783 else if (unformat (i, "disable"))
5791 errmsg ("missing enable|disable");
5795 M (WANT_INTERFACE_EVENTS, mp);
5796 mp->enable_disable = enable;
5798 vam->interface_event_display = enable;
5806 /* Note: non-static, called once to set up the initial intfc table */
5808 api_sw_interface_dump (vat_main_t * vam)
5810 vl_api_sw_interface_dump_t *mp;
5811 vl_api_control_ping_t *mp_ping;
5813 name_sort_t *nses = 0, *ns;
5814 sw_interface_subif_t *sub = NULL;
5817 /* Toss the old name table */
5819 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5821 vec_add2 (nses, ns, 1);
5822 ns->name = (u8 *)(p->key);
5823 ns->value = (u32) p->value[0];
5827 hash_free (vam->sw_if_index_by_interface_name);
5829 vec_foreach (ns, nses) vec_free (ns->name);
5833 vec_foreach (sub, vam->sw_if_subif_table)
5835 vec_free (sub->interface_name);
5837 vec_free (vam->sw_if_subif_table);
5839 /* recreate the interface name hash table */
5840 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5843 * Ask for all interface names. Otherwise, the epic catalog of
5844 * name filters becomes ridiculously long, and vat ends up needing
5845 * to be taught about new interface types.
5847 M (SW_INTERFACE_DUMP, mp);
5850 /* Use a control ping for synchronization */
5851 MPING (CONTROL_PING, mp_ping);
5859 api_sw_interface_set_flags (vat_main_t * vam)
5861 unformat_input_t *i = vam->input;
5862 vl_api_sw_interface_set_flags_t *mp;
5864 u8 sw_if_index_set = 0;
5868 /* Parse args required to build the message */
5869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5871 if (unformat (i, "admin-up"))
5873 else if (unformat (i, "admin-down"))
5876 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5877 sw_if_index_set = 1;
5878 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5879 sw_if_index_set = 1;
5884 if (sw_if_index_set == 0)
5886 errmsg ("missing interface name or sw_if_index");
5890 /* Construct the API message */
5891 M (SW_INTERFACE_SET_FLAGS, mp);
5892 mp->sw_if_index = ntohl (sw_if_index);
5893 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5898 /* Wait for a reply, return the good/bad news... */
5904 api_sw_interface_set_rx_mode (vat_main_t * vam)
5906 unformat_input_t *i = vam->input;
5907 vl_api_sw_interface_set_rx_mode_t *mp;
5909 u8 sw_if_index_set = 0;
5911 u8 queue_id_valid = 0;
5913 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5915 /* Parse args required to build the message */
5916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5918 if (unformat (i, "queue %d", &queue_id))
5920 else if (unformat (i, "polling"))
5921 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5922 else if (unformat (i, "interrupt"))
5923 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5924 else if (unformat (i, "adaptive"))
5925 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5927 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5928 sw_if_index_set = 1;
5929 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5930 sw_if_index_set = 1;
5935 if (sw_if_index_set == 0)
5937 errmsg ("missing interface name or sw_if_index");
5940 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5942 errmsg ("missing rx-mode");
5946 /* Construct the API message */
5947 M (SW_INTERFACE_SET_RX_MODE, mp);
5948 mp->sw_if_index = ntohl (sw_if_index);
5949 mp->mode = (vl_api_rx_mode_t) mode;
5950 mp->queue_id_valid = queue_id_valid;
5951 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5956 /* Wait for a reply, return the good/bad news... */
5962 api_sw_interface_set_rx_placement (vat_main_t * vam)
5964 unformat_input_t *i = vam->input;
5965 vl_api_sw_interface_set_rx_placement_t *mp;
5967 u8 sw_if_index_set = 0;
5970 u32 queue_id, thread_index;
5972 /* Parse args required to build the message */
5973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5975 if (unformat (i, "queue %d", &queue_id))
5977 else if (unformat (i, "main"))
5979 else if (unformat (i, "worker %d", &thread_index))
5982 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5983 sw_if_index_set = 1;
5984 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5985 sw_if_index_set = 1;
5990 if (sw_if_index_set == 0)
5992 errmsg ("missing interface name or sw_if_index");
5998 /* Construct the API message */
5999 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6000 mp->sw_if_index = ntohl (sw_if_index);
6001 mp->worker_id = ntohl (thread_index);
6002 mp->queue_id = ntohl (queue_id);
6003 mp->is_main = is_main;
6007 /* Wait for a reply, return the good/bad news... */
6012 static void vl_api_sw_interface_rx_placement_details_t_handler
6013 (vl_api_sw_interface_rx_placement_details_t * mp)
6015 vat_main_t *vam = &vat_main;
6016 u32 worker_id = ntohl (mp->worker_id);
6019 "\n%-11d %-11s %-6d %-5d %-9s",
6020 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6021 worker_id, ntohl (mp->queue_id),
6023 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6026 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6027 (vl_api_sw_interface_rx_placement_details_t * mp)
6029 vat_main_t *vam = &vat_main;
6030 vat_json_node_t *node = NULL;
6032 if (VAT_JSON_ARRAY != vam->json_tree.type)
6034 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6035 vat_json_init_array (&vam->json_tree);
6037 node = vat_json_array_add (&vam->json_tree);
6039 vat_json_init_object (node);
6040 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6041 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6042 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6043 vat_json_object_add_uint (node, "mode", mp->mode);
6047 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6049 unformat_input_t *i = vam->input;
6050 vl_api_sw_interface_rx_placement_dump_t *mp;
6051 vl_api_control_ping_t *mp_ping;
6054 u8 sw_if_index_set = 0;
6056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6058 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6060 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6067 "\n%-11s %-11s %-6s %-5s %-4s",
6068 "sw_if_index", "main/worker", "thread", "queue", "mode");
6070 /* Dump Interface rx placement */
6071 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6073 if (sw_if_index_set)
6074 mp->sw_if_index = htonl (sw_if_index);
6076 mp->sw_if_index = ~0;
6080 /* Use a control ping for synchronization */
6081 MPING (CONTROL_PING, mp_ping);
6089 api_sw_interface_clear_stats (vat_main_t * vam)
6091 unformat_input_t *i = vam->input;
6092 vl_api_sw_interface_clear_stats_t *mp;
6094 u8 sw_if_index_set = 0;
6097 /* Parse args required to build the message */
6098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6100 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6101 sw_if_index_set = 1;
6102 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6103 sw_if_index_set = 1;
6108 /* Construct the API message */
6109 M (SW_INTERFACE_CLEAR_STATS, mp);
6111 if (sw_if_index_set == 1)
6112 mp->sw_if_index = ntohl (sw_if_index);
6114 mp->sw_if_index = ~0;
6119 /* Wait for a reply, return the good/bad news... */
6125 api_sw_interface_add_del_address (vat_main_t * vam)
6127 unformat_input_t *i = vam->input;
6128 vl_api_sw_interface_add_del_address_t *mp;
6130 u8 sw_if_index_set = 0;
6131 u8 is_add = 1, del_all = 0;
6132 u32 address_length = 0;
6133 u8 v4_address_set = 0;
6134 u8 v6_address_set = 0;
6135 ip4_address_t v4address;
6136 ip6_address_t v6address;
6139 /* Parse args required to build the message */
6140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6142 if (unformat (i, "del-all"))
6144 else if (unformat (i, "del"))
6147 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6148 sw_if_index_set = 1;
6149 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6150 sw_if_index_set = 1;
6151 else if (unformat (i, "%U/%d",
6152 unformat_ip4_address, &v4address, &address_length))
6154 else if (unformat (i, "%U/%d",
6155 unformat_ip6_address, &v6address, &address_length))
6161 if (sw_if_index_set == 0)
6163 errmsg ("missing interface name or sw_if_index");
6166 if (v4_address_set && v6_address_set)
6168 errmsg ("both v4 and v6 addresses set");
6171 if (!v4_address_set && !v6_address_set && !del_all)
6173 errmsg ("no addresses set");
6177 /* Construct the API message */
6178 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6180 mp->sw_if_index = ntohl (sw_if_index);
6181 mp->is_add = is_add;
6182 mp->del_all = del_all;
6185 mp->prefix.address.af = ADDRESS_IP6;
6186 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6190 mp->prefix.address.af = ADDRESS_IP4;
6191 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6193 mp->prefix.len = address_length;
6198 /* Wait for a reply, return good/bad news */
6204 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6206 unformat_input_t *i = vam->input;
6207 vl_api_sw_interface_set_mpls_enable_t *mp;
6209 u8 sw_if_index_set = 0;
6213 /* Parse args required to build the message */
6214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6217 sw_if_index_set = 1;
6218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6219 sw_if_index_set = 1;
6220 else if (unformat (i, "disable"))
6222 else if (unformat (i, "dis"))
6228 if (sw_if_index_set == 0)
6230 errmsg ("missing interface name or sw_if_index");
6234 /* Construct the API message */
6235 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6237 mp->sw_if_index = ntohl (sw_if_index);
6238 mp->enable = enable;
6243 /* Wait for a reply... */
6249 api_sw_interface_set_table (vat_main_t * vam)
6251 unformat_input_t *i = vam->input;
6252 vl_api_sw_interface_set_table_t *mp;
6253 u32 sw_if_index, vrf_id = 0;
6254 u8 sw_if_index_set = 0;
6258 /* Parse args required to build the message */
6259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6261 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6262 sw_if_index_set = 1;
6263 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6264 sw_if_index_set = 1;
6265 else if (unformat (i, "vrf %d", &vrf_id))
6267 else if (unformat (i, "ipv6"))
6273 if (sw_if_index_set == 0)
6275 errmsg ("missing interface name or sw_if_index");
6279 /* Construct the API message */
6280 M (SW_INTERFACE_SET_TABLE, mp);
6282 mp->sw_if_index = ntohl (sw_if_index);
6283 mp->is_ipv6 = is_ipv6;
6284 mp->vrf_id = ntohl (vrf_id);
6289 /* Wait for a reply... */
6294 static void vl_api_sw_interface_get_table_reply_t_handler
6295 (vl_api_sw_interface_get_table_reply_t * mp)
6297 vat_main_t *vam = &vat_main;
6299 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6301 vam->retval = ntohl (mp->retval);
6302 vam->result_ready = 1;
6306 static void vl_api_sw_interface_get_table_reply_t_handler_json
6307 (vl_api_sw_interface_get_table_reply_t * mp)
6309 vat_main_t *vam = &vat_main;
6310 vat_json_node_t node;
6312 vat_json_init_object (&node);
6313 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6314 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6316 vat_json_print (vam->ofp, &node);
6317 vat_json_free (&node);
6319 vam->retval = ntohl (mp->retval);
6320 vam->result_ready = 1;
6324 api_sw_interface_get_table (vat_main_t * vam)
6326 unformat_input_t *i = vam->input;
6327 vl_api_sw_interface_get_table_t *mp;
6329 u8 sw_if_index_set = 0;
6333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6335 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6336 sw_if_index_set = 1;
6337 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6338 sw_if_index_set = 1;
6339 else if (unformat (i, "ipv6"))
6345 if (sw_if_index_set == 0)
6347 errmsg ("missing interface name or sw_if_index");
6351 M (SW_INTERFACE_GET_TABLE, mp);
6352 mp->sw_if_index = htonl (sw_if_index);
6353 mp->is_ipv6 = is_ipv6;
6361 api_sw_interface_set_vpath (vat_main_t * vam)
6363 unformat_input_t *i = vam->input;
6364 vl_api_sw_interface_set_vpath_t *mp;
6365 u32 sw_if_index = 0;
6366 u8 sw_if_index_set = 0;
6370 /* Parse args required to build the message */
6371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6373 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6374 sw_if_index_set = 1;
6375 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6376 sw_if_index_set = 1;
6377 else if (unformat (i, "enable"))
6379 else if (unformat (i, "disable"))
6385 if (sw_if_index_set == 0)
6387 errmsg ("missing interface name or sw_if_index");
6391 /* Construct the API message */
6392 M (SW_INTERFACE_SET_VPATH, mp);
6394 mp->sw_if_index = ntohl (sw_if_index);
6395 mp->enable = is_enable;
6400 /* Wait for a reply... */
6406 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6408 unformat_input_t *i = vam->input;
6409 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6410 u32 sw_if_index = 0;
6411 u8 sw_if_index_set = 0;
6416 /* Parse args required to build the message */
6417 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6419 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6420 sw_if_index_set = 1;
6421 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6422 sw_if_index_set = 1;
6423 else if (unformat (i, "enable"))
6425 else if (unformat (i, "disable"))
6427 else if (unformat (i, "ip4"))
6429 else if (unformat (i, "ip6"))
6435 if (sw_if_index_set == 0)
6437 errmsg ("missing interface name or sw_if_index");
6441 /* Construct the API message */
6442 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6444 mp->sw_if_index = ntohl (sw_if_index);
6445 mp->enable = is_enable;
6446 mp->is_ipv6 = is_ipv6;
6451 /* Wait for a reply... */
6457 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6459 unformat_input_t *i = vam->input;
6460 vl_api_sw_interface_set_geneve_bypass_t *mp;
6461 u32 sw_if_index = 0;
6462 u8 sw_if_index_set = 0;
6467 /* Parse args required to build the message */
6468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6470 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6471 sw_if_index_set = 1;
6472 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6473 sw_if_index_set = 1;
6474 else if (unformat (i, "enable"))
6476 else if (unformat (i, "disable"))
6478 else if (unformat (i, "ip4"))
6480 else if (unformat (i, "ip6"))
6486 if (sw_if_index_set == 0)
6488 errmsg ("missing interface name or sw_if_index");
6492 /* Construct the API message */
6493 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6495 mp->sw_if_index = ntohl (sw_if_index);
6496 mp->enable = is_enable;
6497 mp->is_ipv6 = is_ipv6;
6502 /* Wait for a reply... */
6508 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6510 unformat_input_t *i = vam->input;
6511 vl_api_sw_interface_set_l2_xconnect_t *mp;
6513 u8 rx_sw_if_index_set = 0;
6515 u8 tx_sw_if_index_set = 0;
6519 /* Parse args required to build the message */
6520 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6522 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6523 rx_sw_if_index_set = 1;
6524 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6525 tx_sw_if_index_set = 1;
6526 else if (unformat (i, "rx"))
6528 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6530 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6532 rx_sw_if_index_set = 1;
6537 else if (unformat (i, "tx"))
6539 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6541 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6543 tx_sw_if_index_set = 1;
6548 else if (unformat (i, "enable"))
6550 else if (unformat (i, "disable"))
6556 if (rx_sw_if_index_set == 0)
6558 errmsg ("missing rx interface name or rx_sw_if_index");
6562 if (enable && (tx_sw_if_index_set == 0))
6564 errmsg ("missing tx interface name or tx_sw_if_index");
6568 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6570 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6571 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6572 mp->enable = enable;
6580 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6582 unformat_input_t *i = vam->input;
6583 vl_api_sw_interface_set_l2_bridge_t *mp;
6584 vl_api_l2_port_type_t port_type;
6586 u8 rx_sw_if_index_set = 0;
6593 port_type = L2_API_PORT_TYPE_NORMAL;
6595 /* Parse args required to build the message */
6596 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6598 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6599 rx_sw_if_index_set = 1;
6600 else if (unformat (i, "bd_id %d", &bd_id))
6604 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6605 rx_sw_if_index_set = 1;
6606 else if (unformat (i, "shg %d", &shg))
6608 else if (unformat (i, "bvi"))
6609 port_type = L2_API_PORT_TYPE_BVI;
6610 else if (unformat (i, "uu-fwd"))
6611 port_type = L2_API_PORT_TYPE_UU_FWD;
6612 else if (unformat (i, "enable"))
6614 else if (unformat (i, "disable"))
6620 if (rx_sw_if_index_set == 0)
6622 errmsg ("missing rx interface name or sw_if_index");
6626 if (enable && (bd_id_set == 0))
6628 errmsg ("missing bridge domain");
6632 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6634 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6635 mp->bd_id = ntohl (bd_id);
6637 mp->port_type = ntohl (port_type);
6638 mp->enable = enable;
6646 api_bridge_domain_dump (vat_main_t * vam)
6648 unformat_input_t *i = vam->input;
6649 vl_api_bridge_domain_dump_t *mp;
6650 vl_api_control_ping_t *mp_ping;
6654 /* Parse args required to build the message */
6655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6657 if (unformat (i, "bd_id %d", &bd_id))
6663 M (BRIDGE_DOMAIN_DUMP, mp);
6664 mp->bd_id = ntohl (bd_id);
6667 /* Use a control ping for synchronization */
6668 MPING (CONTROL_PING, mp_ping);
6676 api_bridge_domain_add_del (vat_main_t * vam)
6678 unformat_input_t *i = vam->input;
6679 vl_api_bridge_domain_add_del_t *mp;
6682 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6687 /* Parse args required to build the message */
6688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6690 if (unformat (i, "bd_id %d", &bd_id))
6692 else if (unformat (i, "flood %d", &flood))
6694 else if (unformat (i, "uu-flood %d", &uu_flood))
6696 else if (unformat (i, "forward %d", &forward))
6698 else if (unformat (i, "learn %d", &learn))
6700 else if (unformat (i, "arp-term %d", &arp_term))
6702 else if (unformat (i, "mac-age %d", &mac_age))
6704 else if (unformat (i, "bd-tag %s", &bd_tag))
6706 else if (unformat (i, "del"))
6709 flood = uu_flood = forward = learn = 0;
6717 errmsg ("missing bridge domain");
6724 errmsg ("mac age must be less than 256 ");
6729 if ((bd_tag) && (vec_len (bd_tag) > 63))
6731 errmsg ("bd-tag cannot be longer than 63");
6736 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6738 mp->bd_id = ntohl (bd_id);
6740 mp->uu_flood = uu_flood;
6741 mp->forward = forward;
6743 mp->arp_term = arp_term;
6744 mp->is_add = is_add;
6745 mp->mac_age = (u8) mac_age;
6748 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6749 mp->bd_tag[vec_len (bd_tag)] = 0;
6760 api_l2fib_flush_bd (vat_main_t * vam)
6762 unformat_input_t *i = vam->input;
6763 vl_api_l2fib_flush_bd_t *mp;
6767 /* Parse args required to build the message */
6768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6770 if (unformat (i, "bd_id %d", &bd_id));
6777 errmsg ("missing bridge domain");
6781 M (L2FIB_FLUSH_BD, mp);
6783 mp->bd_id = htonl (bd_id);
6791 api_l2fib_flush_int (vat_main_t * vam)
6793 unformat_input_t *i = vam->input;
6794 vl_api_l2fib_flush_int_t *mp;
6795 u32 sw_if_index = ~0;
6798 /* Parse args required to build the message */
6799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6801 if (unformat (i, "sw_if_index %d", &sw_if_index));
6803 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6808 if (sw_if_index == ~0)
6810 errmsg ("missing interface name or sw_if_index");
6814 M (L2FIB_FLUSH_INT, mp);
6816 mp->sw_if_index = ntohl (sw_if_index);
6824 api_l2fib_add_del (vat_main_t * vam)
6826 unformat_input_t *i = vam->input;
6827 vl_api_l2fib_add_del_t *mp;
6833 u32 sw_if_index = 0;
6834 u8 sw_if_index_set = 0;
6843 /* Parse args required to build the message */
6844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6846 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6848 else if (unformat (i, "bd_id %d", &bd_id))
6850 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6851 sw_if_index_set = 1;
6852 else if (unformat (i, "sw_if"))
6854 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6857 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6858 sw_if_index_set = 1;
6863 else if (unformat (i, "static"))
6865 else if (unformat (i, "filter"))
6870 else if (unformat (i, "bvi"))
6875 else if (unformat (i, "del"))
6877 else if (unformat (i, "count %d", &count))
6885 errmsg ("missing mac address");
6891 errmsg ("missing bridge domain");
6895 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6897 errmsg ("missing interface name or sw_if_index");
6903 /* Turn on async mode */
6904 vam->async_mode = 1;
6905 vam->async_errors = 0;
6906 before = vat_time_now (vam);
6909 for (j = 0; j < count; j++)
6911 M (L2FIB_ADD_DEL, mp);
6913 clib_memcpy (mp->mac, mac, 6);
6914 mp->bd_id = ntohl (bd_id);
6915 mp->is_add = is_add;
6916 mp->sw_if_index = ntohl (sw_if_index);
6920 mp->static_mac = static_mac;
6921 mp->filter_mac = filter_mac;
6922 mp->bvi_mac = bvi_mac;
6924 increment_mac_address (mac);
6931 vl_api_control_ping_t *mp_ping;
6934 /* Shut off async mode */
6935 vam->async_mode = 0;
6937 MPING (CONTROL_PING, mp_ping);
6940 timeout = vat_time_now (vam) + 1.0;
6941 while (vat_time_now (vam) < timeout)
6942 if (vam->result_ready == 1)
6947 if (vam->retval == -99)
6950 if (vam->async_errors > 0)
6952 errmsg ("%d asynchronous errors", vam->async_errors);
6955 vam->async_errors = 0;
6956 after = vat_time_now (vam);
6958 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6959 count, after - before, count / (after - before));
6965 /* Wait for a reply... */
6969 /* Return the good/bad news */
6970 return (vam->retval);
6974 api_bridge_domain_set_mac_age (vat_main_t * vam)
6976 unformat_input_t *i = vam->input;
6977 vl_api_bridge_domain_set_mac_age_t *mp;
6982 /* Parse args required to build the message */
6983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6985 if (unformat (i, "bd_id %d", &bd_id));
6986 else if (unformat (i, "mac-age %d", &mac_age));
6993 errmsg ("missing bridge domain");
6999 errmsg ("mac age must be less than 256 ");
7003 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7005 mp->bd_id = htonl (bd_id);
7006 mp->mac_age = (u8) mac_age;
7014 api_l2_flags (vat_main_t * vam)
7016 unformat_input_t *i = vam->input;
7017 vl_api_l2_flags_t *mp;
7020 u8 sw_if_index_set = 0;
7024 /* Parse args required to build the message */
7025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7027 if (unformat (i, "sw_if_index %d", &sw_if_index))
7028 sw_if_index_set = 1;
7029 else if (unformat (i, "sw_if"))
7031 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7034 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7035 sw_if_index_set = 1;
7040 else if (unformat (i, "learn"))
7042 else if (unformat (i, "forward"))
7044 else if (unformat (i, "flood"))
7046 else if (unformat (i, "uu-flood"))
7047 flags |= L2_UU_FLOOD;
7048 else if (unformat (i, "arp-term"))
7049 flags |= L2_ARP_TERM;
7050 else if (unformat (i, "off"))
7052 else if (unformat (i, "disable"))
7058 if (sw_if_index_set == 0)
7060 errmsg ("missing interface name or sw_if_index");
7066 mp->sw_if_index = ntohl (sw_if_index);
7067 mp->feature_bitmap = ntohl (flags);
7068 mp->is_set = is_set;
7076 api_bridge_flags (vat_main_t * vam)
7078 unformat_input_t *i = vam->input;
7079 vl_api_bridge_flags_t *mp;
7083 bd_flags_t flags = 0;
7086 /* Parse args required to build the message */
7087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7089 if (unformat (i, "bd_id %d", &bd_id))
7091 else if (unformat (i, "learn"))
7092 flags |= BRIDGE_API_FLAG_LEARN;
7093 else if (unformat (i, "forward"))
7094 flags |= BRIDGE_API_FLAG_FWD;
7095 else if (unformat (i, "flood"))
7096 flags |= BRIDGE_API_FLAG_FLOOD;
7097 else if (unformat (i, "uu-flood"))
7098 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7099 else if (unformat (i, "arp-term"))
7100 flags |= BRIDGE_API_FLAG_ARP_TERM;
7101 else if (unformat (i, "off"))
7103 else if (unformat (i, "disable"))
7111 errmsg ("missing bridge domain");
7115 M (BRIDGE_FLAGS, mp);
7117 mp->bd_id = ntohl (bd_id);
7118 mp->flags = ntohl (flags);
7119 mp->is_set = is_set;
7127 api_bd_ip_mac_add_del (vat_main_t * vam)
7129 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7130 vl_api_mac_address_t mac = { 0 };
7131 unformat_input_t *i = vam->input;
7132 vl_api_bd_ip_mac_add_del_t *mp;
7141 /* Parse args required to build the message */
7142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7144 if (unformat (i, "bd_id %d", &bd_id))
7148 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7152 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7156 else if (unformat (i, "del"))
7164 errmsg ("missing bridge domain");
7167 else if (ip_set == 0)
7169 errmsg ("missing IP address");
7172 else if (mac_set == 0)
7174 errmsg ("missing MAC address");
7178 M (BD_IP_MAC_ADD_DEL, mp);
7180 mp->entry.bd_id = ntohl (bd_id);
7181 mp->is_add = is_add;
7183 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7184 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7192 api_bd_ip_mac_flush (vat_main_t * vam)
7194 unformat_input_t *i = vam->input;
7195 vl_api_bd_ip_mac_flush_t *mp;
7200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7202 if (unformat (i, "bd_id %d", &bd_id))
7212 errmsg ("missing bridge domain");
7216 M (BD_IP_MAC_FLUSH, mp);
7218 mp->bd_id = ntohl (bd_id);
7225 static void vl_api_bd_ip_mac_details_t_handler
7226 (vl_api_bd_ip_mac_details_t * mp)
7228 vat_main_t *vam = &vat_main;
7232 ntohl (mp->entry.bd_id),
7233 format_vl_api_mac_address, mp->entry.mac,
7234 format_vl_api_address, &mp->entry.ip);
7237 static void vl_api_bd_ip_mac_details_t_handler_json
7238 (vl_api_bd_ip_mac_details_t * mp)
7240 vat_main_t *vam = &vat_main;
7241 vat_json_node_t *node = NULL;
7243 if (VAT_JSON_ARRAY != vam->json_tree.type)
7245 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7246 vat_json_init_array (&vam->json_tree);
7248 node = vat_json_array_add (&vam->json_tree);
7250 vat_json_init_object (node);
7251 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7252 vat_json_object_add_string_copy (node, "mac_address",
7253 format (0, "%U", format_vl_api_mac_address,
7257 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7258 vat_json_object_add_string_copy (node, "ip_address", ip);
7263 api_bd_ip_mac_dump (vat_main_t * vam)
7265 unformat_input_t *i = vam->input;
7266 vl_api_bd_ip_mac_dump_t *mp;
7267 vl_api_control_ping_t *mp_ping;
7272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7274 if (unformat (i, "bd_id %d", &bd_id))
7283 "\n%-5s %-7s %-20s %-30s",
7284 "bd_id", "is_ipv6", "mac_address", "ip_address");
7286 /* Dump Bridge Domain Ip to Mac entries */
7287 M (BD_IP_MAC_DUMP, mp);
7290 mp->bd_id = htonl (bd_id);
7296 /* Use a control ping for synchronization */
7297 MPING (CONTROL_PING, mp_ping);
7305 api_tap_create_v2 (vat_main_t * vam)
7307 unformat_input_t *i = vam->input;
7308 vl_api_tap_create_v2_t *mp;
7312 u32 num_rx_queues = 0;
7313 u8 *host_if_name = 0;
7314 u8 host_if_name_set = 0;
7317 u8 host_mac_addr[6];
7318 u8 host_mac_addr_set = 0;
7319 u8 *host_bridge = 0;
7320 u8 host_bridge_set = 0;
7321 u8 host_ip4_prefix_set = 0;
7322 u8 host_ip6_prefix_set = 0;
7323 ip4_address_t host_ip4_addr;
7324 ip4_address_t host_ip4_gw;
7325 u8 host_ip4_gw_set = 0;
7326 u32 host_ip4_prefix_len = 0;
7327 ip6_address_t host_ip6_addr;
7328 ip6_address_t host_ip6_gw;
7329 u8 host_ip6_gw_set = 0;
7330 u32 host_ip6_prefix_len = 0;
7331 u32 host_mtu_size = 0;
7332 u8 host_mtu_set = 0;
7335 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7337 clib_memset (mac_address, 0, sizeof (mac_address));
7339 /* Parse args required to build the message */
7340 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7342 if (unformat (i, "id %u", &id))
7346 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7348 else if (unformat (i, "host-if-name %s", &host_if_name))
7349 host_if_name_set = 1;
7350 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
7352 else if (unformat (i, "host-ns %s", &host_ns))
7354 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7356 host_mac_addr_set = 1;
7357 else if (unformat (i, "host-bridge %s", &host_bridge))
7358 host_bridge_set = 1;
7359 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
7360 &host_ip4_addr, &host_ip4_prefix_len))
7361 host_ip4_prefix_set = 1;
7362 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
7363 &host_ip6_addr, &host_ip6_prefix_len))
7364 host_ip6_prefix_set = 1;
7365 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7367 host_ip4_gw_set = 1;
7368 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7370 host_ip6_gw_set = 1;
7371 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7373 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7375 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
7377 else if (unformat (i, "no-gso"))
7378 tap_flags &= ~TAP_API_FLAG_GSO;
7379 else if (unformat (i, "gso"))
7380 tap_flags |= TAP_API_FLAG_GSO;
7381 else if (unformat (i, "csum-offload"))
7382 tap_flags |= TAP_API_FLAG_CSUM_OFFLOAD;
7383 else if (unformat (i, "persist"))
7384 tap_flags |= TAP_API_FLAG_PERSIST;
7385 else if (unformat (i, "attach"))
7386 tap_flags |= TAP_API_FLAG_ATTACH;
7387 else if (unformat (i, "tun"))
7388 tap_flags |= TAP_API_FLAG_TUN;
7389 else if (unformat (i, "gro-coalesce"))
7390 tap_flags |= TAP_API_FLAG_GRO_COALESCE;
7395 if (vec_len (host_if_name) > 63)
7397 errmsg ("tap name too long. ");
7400 if (vec_len (host_ns) > 63)
7402 errmsg ("host name space too long. ");
7405 if (vec_len (host_bridge) > 63)
7407 errmsg ("host bridge name too long. ");
7410 if (host_ip4_prefix_len > 32)
7412 errmsg ("host ip4 prefix length not valid. ");
7415 if (host_ip6_prefix_len > 128)
7417 errmsg ("host ip6 prefix length not valid. ");
7420 if (!is_pow2 (rx_ring_sz))
7422 errmsg ("rx ring size must be power of 2. ");
7425 if (rx_ring_sz > 32768)
7427 errmsg ("rx ring size must be 32768 or lower. ");
7430 if (!is_pow2 (tx_ring_sz))
7432 errmsg ("tx ring size must be power of 2. ");
7435 if (tx_ring_sz > 32768)
7437 errmsg ("tx ring size must be 32768 or lower. ");
7440 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7442 errmsg ("host MTU size must be in between 64 and 65355. ");
7446 /* Construct the API message */
7447 M (TAP_CREATE_V2, mp);
7449 mp->id = ntohl (id);
7450 mp->use_random_mac = random_mac;
7451 mp->num_rx_queues = (u8) num_rx_queues;
7452 mp->tx_ring_sz = ntohs (tx_ring_sz);
7453 mp->rx_ring_sz = ntohs (rx_ring_sz);
7454 mp->host_mtu_set = host_mtu_set;
7455 mp->host_mtu_size = ntohl (host_mtu_size);
7456 mp->host_mac_addr_set = host_mac_addr_set;
7457 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7458 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7459 mp->host_ip4_gw_set = host_ip4_gw_set;
7460 mp->host_ip6_gw_set = host_ip6_gw_set;
7461 mp->tap_flags = ntohl (tap_flags);
7462 mp->host_namespace_set = host_ns_set;
7463 mp->host_if_name_set = host_if_name_set;
7464 mp->host_bridge_set = host_bridge_set;
7466 if (random_mac == 0)
7467 clib_memcpy (mp->mac_address, mac_address, 6);
7468 if (host_mac_addr_set)
7469 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7470 if (host_if_name_set)
7471 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7473 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7474 if (host_bridge_set)
7475 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7476 if (host_ip4_prefix_set)
7478 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7479 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7481 if (host_ip6_prefix_set)
7483 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7484 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7486 if (host_ip4_gw_set)
7487 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7488 if (host_ip6_gw_set)
7489 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7492 vec_free (host_if_name);
7493 vec_free (host_bridge);
7498 /* Wait for a reply... */
7504 api_tap_delete_v2 (vat_main_t * vam)
7506 unformat_input_t *i = vam->input;
7507 vl_api_tap_delete_v2_t *mp;
7508 u32 sw_if_index = ~0;
7509 u8 sw_if_index_set = 0;
7512 /* Parse args required to build the message */
7513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7515 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7516 sw_if_index_set = 1;
7517 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7518 sw_if_index_set = 1;
7523 if (sw_if_index_set == 0)
7525 errmsg ("missing vpp interface name. ");
7529 /* Construct the API message */
7530 M (TAP_DELETE_V2, mp);
7532 mp->sw_if_index = ntohl (sw_if_index);
7537 /* Wait for a reply... */
7543 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7545 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7548 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7551 addr->domain = x[0];
7554 addr->function = x[3];
7560 api_virtio_pci_create (vat_main_t * vam)
7562 unformat_input_t *i = vam->input;
7563 vl_api_virtio_pci_create_t *mp;
7567 u8 checksum_offload_enabled = 0;
7569 u64 features = (u64) ~ (0ULL);
7572 clib_memset (mac_address, 0, sizeof (mac_address));
7574 /* Parse args required to build the message */
7575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7577 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7581 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7583 else if (unformat (i, "features 0x%llx", &features))
7585 else if (unformat (i, "gso-enabled"))
7587 else if (unformat (i, "csum-offload-enabled"))
7588 checksum_offload_enabled = 1;
7595 errmsg ("pci address must be non zero. ");
7599 /* Construct the API message */
7600 M (VIRTIO_PCI_CREATE, mp);
7602 mp->use_random_mac = random_mac;
7604 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7605 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7606 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7607 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7609 mp->features = clib_host_to_net_u64 (features);
7610 mp->gso_enabled = gso_enabled;
7611 mp->checksum_offload_enabled = checksum_offload_enabled;
7613 if (random_mac == 0)
7614 clib_memcpy (mp->mac_address, mac_address, 6);
7619 /* Wait for a reply... */
7625 api_virtio_pci_delete (vat_main_t * vam)
7627 unformat_input_t *i = vam->input;
7628 vl_api_virtio_pci_delete_t *mp;
7629 u32 sw_if_index = ~0;
7630 u8 sw_if_index_set = 0;
7633 /* Parse args required to build the message */
7634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7636 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7637 sw_if_index_set = 1;
7638 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7639 sw_if_index_set = 1;
7644 if (sw_if_index_set == 0)
7646 errmsg ("missing vpp interface name. ");
7650 /* Construct the API message */
7651 M (VIRTIO_PCI_DELETE, mp);
7653 mp->sw_if_index = htonl (sw_if_index);
7658 /* Wait for a reply... */
7664 api_bond_create (vat_main_t * vam)
7666 unformat_input_t *i = vam->input;
7667 vl_api_bond_create_t *mp;
7677 clib_memset (mac_address, 0, sizeof (mac_address));
7680 /* Parse args required to build the message */
7681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7683 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7685 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7686 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7688 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7691 else if (unformat (i, "numa-only"))
7693 else if (unformat (i, "id %u", &id))
7699 if (mode_is_set == 0)
7701 errmsg ("Missing bond mode. ");
7705 /* Construct the API message */
7706 M (BOND_CREATE, mp);
7708 mp->use_custom_mac = custom_mac;
7710 mp->mode = htonl (mode);
7711 mp->lb = htonl (lb);
7712 mp->id = htonl (id);
7713 mp->numa_only = numa_only;
7716 clib_memcpy (mp->mac_address, mac_address, 6);
7721 /* Wait for a reply... */
7727 api_bond_delete (vat_main_t * vam)
7729 unformat_input_t *i = vam->input;
7730 vl_api_bond_delete_t *mp;
7731 u32 sw_if_index = ~0;
7732 u8 sw_if_index_set = 0;
7735 /* Parse args required to build the message */
7736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7738 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7739 sw_if_index_set = 1;
7740 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7741 sw_if_index_set = 1;
7746 if (sw_if_index_set == 0)
7748 errmsg ("missing vpp interface name. ");
7752 /* Construct the API message */
7753 M (BOND_DELETE, mp);
7755 mp->sw_if_index = ntohl (sw_if_index);
7760 /* Wait for a reply... */
7766 api_bond_add_member (vat_main_t * vam)
7768 unformat_input_t *i = vam->input;
7769 vl_api_bond_add_member_t *mp;
7770 u32 bond_sw_if_index;
7774 u32 bond_sw_if_index_is_set = 0;
7776 u8 sw_if_index_is_set = 0;
7778 /* Parse args required to build the message */
7779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7781 if (unformat (i, "sw_if_index %d", &sw_if_index))
7782 sw_if_index_is_set = 1;
7783 else if (unformat (i, "bond %u", &bond_sw_if_index))
7784 bond_sw_if_index_is_set = 1;
7785 else if (unformat (i, "passive %d", &is_passive))
7787 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7793 if (bond_sw_if_index_is_set == 0)
7795 errmsg ("Missing bond sw_if_index. ");
7798 if (sw_if_index_is_set == 0)
7800 errmsg ("Missing member sw_if_index. ");
7804 /* Construct the API message */
7805 M (BOND_ADD_MEMBER, mp);
7807 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7808 mp->sw_if_index = ntohl (sw_if_index);
7809 mp->is_long_timeout = is_long_timeout;
7810 mp->is_passive = is_passive;
7815 /* Wait for a reply... */
7821 api_bond_detach_member (vat_main_t * vam)
7823 unformat_input_t *i = vam->input;
7824 vl_api_bond_detach_member_t *mp;
7825 u32 sw_if_index = ~0;
7826 u8 sw_if_index_set = 0;
7829 /* Parse args required to build the message */
7830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7832 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7833 sw_if_index_set = 1;
7834 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7835 sw_if_index_set = 1;
7840 if (sw_if_index_set == 0)
7842 errmsg ("missing vpp interface name. ");
7846 /* Construct the API message */
7847 M (BOND_DETACH_MEMBER, mp);
7849 mp->sw_if_index = ntohl (sw_if_index);
7854 /* Wait for a reply... */
7860 api_ip_table_add_del (vat_main_t * vam)
7862 unformat_input_t *i = vam->input;
7863 vl_api_ip_table_add_del_t *mp;
7869 /* Parse args required to build the message */
7870 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7872 if (unformat (i, "ipv6"))
7874 else if (unformat (i, "del"))
7876 else if (unformat (i, "add"))
7878 else if (unformat (i, "table %d", &table_id))
7882 clib_warning ("parse error '%U'", format_unformat_error, i);
7889 errmsg ("missing table-ID");
7893 /* Construct the API message */
7894 M (IP_TABLE_ADD_DEL, mp);
7896 mp->table.table_id = ntohl (table_id);
7897 mp->table.is_ip6 = is_ipv6;
7898 mp->is_add = is_add;
7903 /* Wait for a reply... */
7910 unformat_fib_path (unformat_input_t * input, va_list * args)
7912 vat_main_t *vam = va_arg (*args, vat_main_t *);
7913 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7914 u32 weight, preference;
7915 mpls_label_t out_label;
7917 clib_memset (path, 0, sizeof (*path));
7919 path->sw_if_index = ~0;
7923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7925 if (unformat (input, "%U %U",
7926 unformat_vl_api_ip4_address,
7927 &path->nh.address.ip4,
7928 api_unformat_sw_if_index, vam, &path->sw_if_index))
7930 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7932 else if (unformat (input, "%U %U",
7933 unformat_vl_api_ip6_address,
7934 &path->nh.address.ip6,
7935 api_unformat_sw_if_index, vam, &path->sw_if_index))
7937 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7939 else if (unformat (input, "weight %u", &weight))
7941 path->weight = weight;
7943 else if (unformat (input, "preference %u", &preference))
7945 path->preference = preference;
7947 else if (unformat (input, "%U next-hop-table %d",
7948 unformat_vl_api_ip4_address,
7949 &path->nh.address.ip4, &path->table_id))
7951 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7953 else if (unformat (input, "%U next-hop-table %d",
7954 unformat_vl_api_ip6_address,
7955 &path->nh.address.ip6, &path->table_id))
7957 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7959 else if (unformat (input, "%U",
7960 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7963 * the recursive next-hops are by default in the default table
7966 path->sw_if_index = ~0;
7967 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7969 else if (unformat (input, "%U",
7970 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7973 * the recursive next-hops are by default in the default table
7976 path->sw_if_index = ~0;
7977 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7979 else if (unformat (input, "resolve-via-host"))
7981 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7983 else if (unformat (input, "resolve-via-attached"))
7985 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7987 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7989 path->type = FIB_API_PATH_TYPE_LOCAL;
7990 path->sw_if_index = ~0;
7991 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7993 else if (unformat (input, "ip6-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_IP6;
7999 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
8001 else if (unformat (input, "via-label %d", &path->nh.via_label))
8003 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8004 path->sw_if_index = ~0;
8006 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8008 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8009 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8011 else if (unformat (input, "local"))
8013 path->type = FIB_API_PATH_TYPE_LOCAL;
8015 else if (unformat (input, "out-labels"))
8017 while (unformat (input, "%d", &out_label))
8019 path->label_stack[path->n_labels].label = out_label;
8020 path->label_stack[path->n_labels].is_uniform = 0;
8021 path->label_stack[path->n_labels].ttl = 64;
8025 else if (unformat (input, "via"))
8027 /* new path, back up and return */
8028 unformat_put_input (input);
8029 unformat_put_input (input);
8030 unformat_put_input (input);
8031 unformat_put_input (input);
8040 path->proto = ntohl (path->proto);
8041 path->type = ntohl (path->type);
8042 path->flags = ntohl (path->flags);
8043 path->table_id = ntohl (path->table_id);
8044 path->sw_if_index = ntohl (path->sw_if_index);
8050 api_ip_route_add_del (vat_main_t * vam)
8052 unformat_input_t *i = vam->input;
8053 vl_api_ip_route_add_del_t *mp;
8056 u8 is_multipath = 0;
8059 vl_api_prefix_t pfx = { };
8060 vl_api_fib_path_t paths[8];
8064 u32 random_add_del = 0;
8065 u32 *random_vector = 0;
8066 u32 random_seed = 0xdeaddabe;
8068 /* Parse args required to build the message */
8069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8071 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8073 else if (unformat (i, "del"))
8075 else if (unformat (i, "add"))
8077 else if (unformat (i, "vrf %d", &vrf_id))
8079 else if (unformat (i, "count %d", &count))
8081 else if (unformat (i, "random"))
8083 else if (unformat (i, "multipath"))
8085 else if (unformat (i, "seed %d", &random_seed))
8089 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8092 if (8 == path_count)
8094 errmsg ("max 8 paths");
8100 clib_warning ("parse error '%U'", format_unformat_error, i);
8107 errmsg ("specify a path; via ...");
8110 if (prefix_set == 0)
8112 errmsg ("missing prefix");
8116 /* Generate a pile of unique, random routes */
8119 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8120 u32 this_random_address;
8123 random_hash = hash_create (count, sizeof (uword));
8125 hash_set (random_hash, i->as_u32, 1);
8126 for (j = 0; j <= count; j++)
8130 this_random_address = random_u32 (&random_seed);
8131 this_random_address =
8132 clib_host_to_net_u32 (this_random_address);
8134 while (hash_get (random_hash, this_random_address));
8135 vec_add1 (random_vector, this_random_address);
8136 hash_set (random_hash, this_random_address, 1);
8138 hash_free (random_hash);
8139 set_ip4_address (&pfx.address, random_vector[0]);
8144 /* Turn on async mode */
8145 vam->async_mode = 1;
8146 vam->async_errors = 0;
8147 before = vat_time_now (vam);
8150 for (j = 0; j < count; j++)
8152 /* Construct the API message */
8153 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8155 mp->is_add = is_add;
8156 mp->is_multipath = is_multipath;
8158 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8159 mp->route.table_id = ntohl (vrf_id);
8160 mp->route.n_paths = path_count;
8162 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8165 set_ip4_address (&pfx.address, random_vector[j + 1]);
8167 increment_address (&pfx.address);
8170 /* If we receive SIGTERM, stop now... */
8175 /* When testing multiple add/del ops, use a control-ping to sync */
8178 vl_api_control_ping_t *mp_ping;
8182 /* Shut off async mode */
8183 vam->async_mode = 0;
8185 MPING (CONTROL_PING, mp_ping);
8188 timeout = vat_time_now (vam) + 1.0;
8189 while (vat_time_now (vam) < timeout)
8190 if (vam->result_ready == 1)
8195 if (vam->retval == -99)
8198 if (vam->async_errors > 0)
8200 errmsg ("%d asynchronous errors", vam->async_errors);
8203 vam->async_errors = 0;
8204 after = vat_time_now (vam);
8206 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8210 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8211 count, after - before, count / (after - before));
8217 /* Wait for a reply... */
8222 /* Return the good/bad news */
8223 return (vam->retval);
8227 api_ip_mroute_add_del (vat_main_t * vam)
8229 unformat_input_t *i = vam->input;
8230 u8 path_set = 0, prefix_set = 0, is_add = 1;
8231 vl_api_ip_mroute_add_del_t *mp;
8232 mfib_entry_flags_t eflags = 0;
8233 vl_api_mfib_path_t path;
8234 vl_api_mprefix_t pfx = { };
8238 /* Parse args required to build the message */
8239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8241 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8244 pfx.grp_address_length = htons (pfx.grp_address_length);
8246 else if (unformat (i, "del"))
8248 else if (unformat (i, "add"))
8250 else if (unformat (i, "vrf %d", &vrf_id))
8252 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8253 path.itf_flags = htonl (path.itf_flags);
8254 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8256 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8260 clib_warning ("parse error '%U'", format_unformat_error, i);
8265 if (prefix_set == 0)
8267 errmsg ("missing addresses\n");
8272 errmsg ("missing path\n");
8276 /* Construct the API message */
8277 M (IP_MROUTE_ADD_DEL, mp);
8279 mp->is_add = is_add;
8280 mp->is_multipath = 1;
8282 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8283 mp->route.table_id = htonl (vrf_id);
8284 mp->route.n_paths = 1;
8285 mp->route.entry_flags = htonl (eflags);
8287 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8291 /* Wait for a reply... */
8297 api_mpls_table_add_del (vat_main_t * vam)
8299 unformat_input_t *i = vam->input;
8300 vl_api_mpls_table_add_del_t *mp;
8305 /* Parse args required to build the message */
8306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8308 if (unformat (i, "table %d", &table_id))
8310 else if (unformat (i, "del"))
8312 else if (unformat (i, "add"))
8316 clib_warning ("parse error '%U'", format_unformat_error, i);
8323 errmsg ("missing table-ID");
8327 /* Construct the API message */
8328 M (MPLS_TABLE_ADD_DEL, mp);
8330 mp->mt_table.mt_table_id = ntohl (table_id);
8331 mp->mt_is_add = is_add;
8336 /* Wait for a reply... */
8343 api_mpls_route_add_del (vat_main_t * vam)
8345 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8346 mpls_label_t local_label = MPLS_LABEL_INVALID;
8347 unformat_input_t *i = vam->input;
8348 vl_api_mpls_route_add_del_t *mp;
8349 vl_api_fib_path_t paths[8];
8353 /* Parse args required to build the message */
8354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8356 if (unformat (i, "%d", &local_label))
8358 else if (unformat (i, "eos"))
8360 else if (unformat (i, "non-eos"))
8362 else if (unformat (i, "del"))
8364 else if (unformat (i, "add"))
8366 else if (unformat (i, "multipath"))
8368 else if (unformat (i, "count %d", &count))
8372 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8375 if (8 == path_count)
8377 errmsg ("max 8 paths");
8383 clib_warning ("parse error '%U'", format_unformat_error, i);
8390 errmsg ("specify a path; via ...");
8394 if (MPLS_LABEL_INVALID == local_label)
8396 errmsg ("missing label");
8402 /* Turn on async mode */
8403 vam->async_mode = 1;
8404 vam->async_errors = 0;
8405 before = vat_time_now (vam);
8408 for (j = 0; j < count; j++)
8410 /* Construct the API message */
8411 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8413 mp->mr_is_add = is_add;
8414 mp->mr_is_multipath = is_multipath;
8416 mp->mr_route.mr_label = local_label;
8417 mp->mr_route.mr_eos = is_eos;
8418 mp->mr_route.mr_table_id = 0;
8419 mp->mr_route.mr_n_paths = path_count;
8421 clib_memcpy (&mp->mr_route.mr_paths, paths,
8422 sizeof (paths[0]) * path_count);
8428 /* If we receive SIGTERM, stop now... */
8433 /* When testing multiple add/del ops, use a control-ping to sync */
8436 vl_api_control_ping_t *mp_ping;
8440 /* Shut off async mode */
8441 vam->async_mode = 0;
8443 MPING (CONTROL_PING, mp_ping);
8446 timeout = vat_time_now (vam) + 1.0;
8447 while (vat_time_now (vam) < timeout)
8448 if (vam->result_ready == 1)
8453 if (vam->retval == -99)
8456 if (vam->async_errors > 0)
8458 errmsg ("%d asynchronous errors", vam->async_errors);
8461 vam->async_errors = 0;
8462 after = vat_time_now (vam);
8464 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8468 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8469 count, after - before, count / (after - before));
8475 /* Wait for a reply... */
8480 /* Return the good/bad news */
8481 return (vam->retval);
8486 api_mpls_ip_bind_unbind (vat_main_t * vam)
8488 unformat_input_t *i = vam->input;
8489 vl_api_mpls_ip_bind_unbind_t *mp;
8490 u32 ip_table_id = 0;
8492 vl_api_prefix_t pfx;
8494 mpls_label_t local_label = MPLS_LABEL_INVALID;
8497 /* Parse args required to build the message */
8498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8500 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8502 else if (unformat (i, "%d", &local_label))
8504 else if (unformat (i, "table-id %d", &ip_table_id))
8506 else if (unformat (i, "unbind"))
8508 else if (unformat (i, "bind"))
8512 clib_warning ("parse error '%U'", format_unformat_error, i);
8519 errmsg ("IP prefix not set");
8523 if (MPLS_LABEL_INVALID == local_label)
8525 errmsg ("missing label");
8529 /* Construct the API message */
8530 M (MPLS_IP_BIND_UNBIND, mp);
8532 mp->mb_is_bind = is_bind;
8533 mp->mb_ip_table_id = ntohl (ip_table_id);
8534 mp->mb_mpls_table_id = 0;
8535 mp->mb_label = ntohl (local_label);
8536 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8541 /* Wait for a reply... */
8548 api_sr_mpls_policy_add (vat_main_t * vam)
8550 unformat_input_t *i = vam->input;
8551 vl_api_sr_mpls_policy_add_t *mp;
8557 u32 *segments = NULL;
8560 /* Parse args required to build the message */
8561 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8563 if (unformat (i, "bsid %d", &bsid))
8565 else if (unformat (i, "weight %d", &weight))
8567 else if (unformat (i, "spray"))
8569 else if (unformat (i, "next %d", &sid))
8572 vec_add1 (segments, htonl (sid));
8576 clib_warning ("parse error '%U'", format_unformat_error, i);
8583 errmsg ("bsid not set");
8587 if (n_segments == 0)
8589 errmsg ("no sid in segment stack");
8593 /* Construct the API message */
8594 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8596 mp->bsid = htonl (bsid);
8597 mp->weight = htonl (weight);
8598 mp->is_spray = type;
8599 mp->n_segments = n_segments;
8600 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8601 vec_free (segments);
8606 /* Wait for a reply... */
8612 api_sr_mpls_policy_del (vat_main_t * vam)
8614 unformat_input_t *i = vam->input;
8615 vl_api_sr_mpls_policy_del_t *mp;
8619 /* Parse args required to build the message */
8620 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8622 if (unformat (i, "bsid %d", &bsid))
8626 clib_warning ("parse error '%U'", format_unformat_error, i);
8633 errmsg ("bsid not set");
8637 /* Construct the API message */
8638 M (SR_MPLS_POLICY_DEL, mp);
8640 mp->bsid = htonl (bsid);
8645 /* Wait for a reply... */
8651 api_bier_table_add_del (vat_main_t * vam)
8653 unformat_input_t *i = vam->input;
8654 vl_api_bier_table_add_del_t *mp;
8656 u32 set = 0, sub_domain = 0, hdr_len = 3;
8657 mpls_label_t local_label = MPLS_LABEL_INVALID;
8660 /* Parse args required to build the message */
8661 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8663 if (unformat (i, "sub-domain %d", &sub_domain))
8665 else if (unformat (i, "set %d", &set))
8667 else if (unformat (i, "label %d", &local_label))
8669 else if (unformat (i, "hdr-len %d", &hdr_len))
8671 else if (unformat (i, "add"))
8673 else if (unformat (i, "del"))
8677 clib_warning ("parse error '%U'", format_unformat_error, i);
8682 if (MPLS_LABEL_INVALID == local_label)
8684 errmsg ("missing label\n");
8688 /* Construct the API message */
8689 M (BIER_TABLE_ADD_DEL, mp);
8691 mp->bt_is_add = is_add;
8692 mp->bt_label = ntohl (local_label);
8693 mp->bt_tbl_id.bt_set = set;
8694 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8695 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8700 /* Wait for a reply... */
8707 api_bier_route_add_del (vat_main_t * vam)
8709 unformat_input_t *i = vam->input;
8710 vl_api_bier_route_add_del_t *mp;
8712 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8713 ip4_address_t v4_next_hop_address;
8714 ip6_address_t v6_next_hop_address;
8715 u8 next_hop_set = 0;
8716 u8 next_hop_proto_is_ip4 = 1;
8717 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8720 /* Parse args required to build the message */
8721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8723 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8725 next_hop_proto_is_ip4 = 1;
8728 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8730 next_hop_proto_is_ip4 = 0;
8733 if (unformat (i, "sub-domain %d", &sub_domain))
8735 else if (unformat (i, "set %d", &set))
8737 else if (unformat (i, "hdr-len %d", &hdr_len))
8739 else if (unformat (i, "bp %d", &bp))
8741 else if (unformat (i, "add"))
8743 else if (unformat (i, "del"))
8745 else if (unformat (i, "out-label %d", &next_hop_out_label))
8749 clib_warning ("parse error '%U'", format_unformat_error, i);
8754 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8756 errmsg ("next hop / label set\n");
8761 errmsg ("bit=position not set\n");
8765 /* Construct the API message */
8766 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8768 mp->br_is_add = is_add;
8769 mp->br_route.br_tbl_id.bt_set = set;
8770 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8771 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8772 mp->br_route.br_bp = ntohs (bp);
8773 mp->br_route.br_n_paths = 1;
8774 mp->br_route.br_paths[0].n_labels = 1;
8775 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8776 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8777 FIB_API_PATH_NH_PROTO_IP4 :
8778 FIB_API_PATH_NH_PROTO_IP6);
8780 if (next_hop_proto_is_ip4)
8782 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8783 &v4_next_hop_address, sizeof (v4_next_hop_address));
8787 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8788 &v6_next_hop_address, sizeof (v6_next_hop_address));
8794 /* Wait for a reply... */
8801 api_mpls_tunnel_add_del (vat_main_t * vam)
8803 unformat_input_t *i = vam->input;
8804 vl_api_mpls_tunnel_add_del_t *mp;
8806 vl_api_fib_path_t paths[8];
8807 u32 sw_if_index = ~0;
8813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8815 if (unformat (i, "add"))
8819 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8821 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8823 else if (unformat (i, "l2-only"))
8827 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8830 if (8 == path_count)
8832 errmsg ("max 8 paths");
8838 clib_warning ("parse error '%U'", format_unformat_error, i);
8843 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8845 mp->mt_is_add = is_add;
8846 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8847 mp->mt_tunnel.mt_l2_only = l2_only;
8848 mp->mt_tunnel.mt_is_multicast = 0;
8849 mp->mt_tunnel.mt_n_paths = path_count;
8851 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8852 sizeof (paths[0]) * path_count);
8860 api_sw_interface_set_unnumbered (vat_main_t * vam)
8862 unformat_input_t *i = vam->input;
8863 vl_api_sw_interface_set_unnumbered_t *mp;
8865 u32 unnum_sw_index = ~0;
8867 u8 sw_if_index_set = 0;
8870 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8872 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8873 sw_if_index_set = 1;
8874 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8875 sw_if_index_set = 1;
8876 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8878 else if (unformat (i, "del"))
8882 clib_warning ("parse error '%U'", format_unformat_error, i);
8887 if (sw_if_index_set == 0)
8889 errmsg ("missing interface name or sw_if_index");
8893 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8895 mp->sw_if_index = ntohl (sw_if_index);
8896 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8897 mp->is_add = is_add;
8906 api_create_vlan_subif (vat_main_t * vam)
8908 unformat_input_t *i = vam->input;
8909 vl_api_create_vlan_subif_t *mp;
8911 u8 sw_if_index_set = 0;
8916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8918 if (unformat (i, "sw_if_index %d", &sw_if_index))
8919 sw_if_index_set = 1;
8921 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8922 sw_if_index_set = 1;
8923 else if (unformat (i, "vlan %d", &vlan_id))
8927 clib_warning ("parse error '%U'", format_unformat_error, i);
8932 if (sw_if_index_set == 0)
8934 errmsg ("missing interface name or sw_if_index");
8938 if (vlan_id_set == 0)
8940 errmsg ("missing vlan_id");
8943 M (CREATE_VLAN_SUBIF, mp);
8945 mp->sw_if_index = ntohl (sw_if_index);
8946 mp->vlan_id = ntohl (vlan_id);
8953 #define foreach_create_subif_bit \
8960 _(outer_vlan_id_any) \
8961 _(inner_vlan_id_any)
8963 #define foreach_create_subif_flag \
8968 _(4, "exact_match") \
8969 _(5, "default_sub") \
8970 _(6, "outer_vlan_id_any") \
8971 _(7, "inner_vlan_id_any")
8974 api_create_subif (vat_main_t * vam)
8976 unformat_input_t *i = vam->input;
8977 vl_api_create_subif_t *mp;
8979 u8 sw_if_index_set = 0;
8982 u32 __attribute__ ((unused)) no_tags = 0;
8983 u32 __attribute__ ((unused)) one_tag = 0;
8984 u32 __attribute__ ((unused)) two_tags = 0;
8985 u32 __attribute__ ((unused)) dot1ad = 0;
8986 u32 __attribute__ ((unused)) exact_match = 0;
8987 u32 __attribute__ ((unused)) default_sub = 0;
8988 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8989 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8991 u16 outer_vlan_id = 0;
8992 u16 inner_vlan_id = 0;
8995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8997 if (unformat (i, "sw_if_index %d", &sw_if_index))
8998 sw_if_index_set = 1;
9000 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9001 sw_if_index_set = 1;
9002 else if (unformat (i, "sub_id %d", &sub_id))
9004 else if (unformat (i, "outer_vlan_id %d", &tmp))
9005 outer_vlan_id = tmp;
9006 else if (unformat (i, "inner_vlan_id %d", &tmp))
9007 inner_vlan_id = tmp;
9009 #define _(a) else if (unformat (i, #a)) a = 1 ;
9010 foreach_create_subif_bit
9014 clib_warning ("parse error '%U'", format_unformat_error, i);
9019 if (sw_if_index_set == 0)
9021 errmsg ("missing interface name or sw_if_index");
9025 if (sub_id_set == 0)
9027 errmsg ("missing sub_id");
9030 M (CREATE_SUBIF, mp);
9032 mp->sw_if_index = ntohl (sw_if_index);
9033 mp->sub_id = ntohl (sub_id);
9035 #define _(a,b) mp->sub_if_flags |= (1 << a);
9036 foreach_create_subif_flag;
9039 mp->outer_vlan_id = ntohs (outer_vlan_id);
9040 mp->inner_vlan_id = ntohs (inner_vlan_id);
9048 api_ip_table_replace_begin (vat_main_t * vam)
9050 unformat_input_t *i = vam->input;
9051 vl_api_ip_table_replace_begin_t *mp;
9056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9058 if (unformat (i, "table %d", &table_id))
9060 else if (unformat (i, "ipv6"))
9064 clib_warning ("parse error '%U'", format_unformat_error, i);
9069 M (IP_TABLE_REPLACE_BEGIN, mp);
9071 mp->table.table_id = ntohl (table_id);
9072 mp->table.is_ip6 = is_ipv6;
9080 api_ip_table_flush (vat_main_t * vam)
9082 unformat_input_t *i = vam->input;
9083 vl_api_ip_table_flush_t *mp;
9088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9090 if (unformat (i, "table %d", &table_id))
9092 else if (unformat (i, "ipv6"))
9096 clib_warning ("parse error '%U'", format_unformat_error, i);
9101 M (IP_TABLE_FLUSH, mp);
9103 mp->table.table_id = ntohl (table_id);
9104 mp->table.is_ip6 = is_ipv6;
9112 api_ip_table_replace_end (vat_main_t * vam)
9114 unformat_input_t *i = vam->input;
9115 vl_api_ip_table_replace_end_t *mp;
9120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9122 if (unformat (i, "table %d", &table_id))
9124 else if (unformat (i, "ipv6"))
9128 clib_warning ("parse error '%U'", format_unformat_error, i);
9133 M (IP_TABLE_REPLACE_END, mp);
9135 mp->table.table_id = ntohl (table_id);
9136 mp->table.is_ip6 = is_ipv6;
9144 api_set_ip_flow_hash (vat_main_t * vam)
9146 unformat_input_t *i = vam->input;
9147 vl_api_set_ip_flow_hash_t *mp;
9159 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9161 if (unformat (i, "vrf %d", &vrf_id))
9163 else if (unformat (i, "ipv6"))
9165 else if (unformat (i, "src"))
9167 else if (unformat (i, "dst"))
9169 else if (unformat (i, "sport"))
9171 else if (unformat (i, "dport"))
9173 else if (unformat (i, "proto"))
9175 else if (unformat (i, "reverse"))
9180 clib_warning ("parse error '%U'", format_unformat_error, i);
9185 if (vrf_id_set == 0)
9187 errmsg ("missing vrf id");
9191 M (SET_IP_FLOW_HASH, mp);
9197 mp->reverse = reverse;
9198 mp->vrf_id = ntohl (vrf_id);
9199 mp->is_ipv6 = is_ipv6;
9207 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9209 unformat_input_t *i = vam->input;
9210 vl_api_sw_interface_ip6_enable_disable_t *mp;
9212 u8 sw_if_index_set = 0;
9216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9218 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9219 sw_if_index_set = 1;
9220 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9221 sw_if_index_set = 1;
9222 else if (unformat (i, "enable"))
9224 else if (unformat (i, "disable"))
9228 clib_warning ("parse error '%U'", format_unformat_error, i);
9233 if (sw_if_index_set == 0)
9235 errmsg ("missing interface name or sw_if_index");
9239 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9241 mp->sw_if_index = ntohl (sw_if_index);
9242 mp->enable = enable;
9251 api_l2_patch_add_del (vat_main_t * vam)
9253 unformat_input_t *i = vam->input;
9254 vl_api_l2_patch_add_del_t *mp;
9256 u8 rx_sw_if_index_set = 0;
9258 u8 tx_sw_if_index_set = 0;
9262 /* Parse args required to build the message */
9263 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9265 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9266 rx_sw_if_index_set = 1;
9267 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9268 tx_sw_if_index_set = 1;
9269 else if (unformat (i, "rx"))
9271 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9273 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9275 rx_sw_if_index_set = 1;
9280 else if (unformat (i, "tx"))
9282 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9284 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9286 tx_sw_if_index_set = 1;
9291 else if (unformat (i, "del"))
9297 if (rx_sw_if_index_set == 0)
9299 errmsg ("missing rx interface name or rx_sw_if_index");
9303 if (tx_sw_if_index_set == 0)
9305 errmsg ("missing tx interface name or tx_sw_if_index");
9309 M (L2_PATCH_ADD_DEL, mp);
9311 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9312 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9313 mp->is_add = is_add;
9321 u8 localsid_addr[16];
9330 api_sr_localsid_add_del (vat_main_t * vam)
9332 unformat_input_t *i = vam->input;
9333 vl_api_sr_localsid_add_del_t *mp;
9336 ip6_address_t localsid;
9340 u32 fib_table = ~(u32) 0;
9341 ip46_address_t nh_addr;
9342 clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
9344 bool nexthop_set = 0;
9348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9350 if (unformat (i, "del"))
9352 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9353 else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
9355 else if (unformat (i, "behavior %u", &behavior));
9356 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9357 else if (unformat (i, "fib-table %u", &fib_table));
9358 else if (unformat (i, "end.psp %u", &behavior));
9363 M (SR_LOCALSID_ADD_DEL, mp);
9365 clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
9369 clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
9371 mp->behavior = behavior;
9372 mp->sw_if_index = ntohl (sw_if_index);
9373 mp->fib_table = ntohl (fib_table);
9374 mp->end_psp = end_psp;
9375 mp->is_del = is_del;
9383 api_ioam_enable (vat_main_t * vam)
9385 unformat_input_t *input = vam->input;
9386 vl_api_ioam_enable_t *mp;
9388 int has_trace_option = 0;
9389 int has_pot_option = 0;
9390 int has_seqno_option = 0;
9391 int has_analyse_option = 0;
9394 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9396 if (unformat (input, "trace"))
9397 has_trace_option = 1;
9398 else if (unformat (input, "pot"))
9400 else if (unformat (input, "seqno"))
9401 has_seqno_option = 1;
9402 else if (unformat (input, "analyse"))
9403 has_analyse_option = 1;
9407 M (IOAM_ENABLE, mp);
9408 mp->id = htons (id);
9409 mp->seqno = has_seqno_option;
9410 mp->analyse = has_analyse_option;
9411 mp->pot_enable = has_pot_option;
9412 mp->trace_enable = has_trace_option;
9421 api_ioam_disable (vat_main_t * vam)
9423 vl_api_ioam_disable_t *mp;
9426 M (IOAM_DISABLE, mp);
9432 #define foreach_tcp_proto_field \
9436 #define foreach_udp_proto_field \
9440 #define foreach_ip4_proto_field \
9452 u16 src_port, dst_port;
9455 #if VPP_API_TEST_BUILTIN == 0
9457 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9459 u8 **maskp = va_arg (*args, u8 **);
9461 u8 found_something = 0;
9464 #define _(a) u8 a=0;
9465 foreach_tcp_proto_field;
9468 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9471 #define _(a) else if (unformat (input, #a)) a=1;
9472 foreach_tcp_proto_field
9478 #define _(a) found_something += a;
9479 foreach_tcp_proto_field;
9482 if (found_something == 0)
9485 vec_validate (mask, sizeof (*tcp) - 1);
9487 tcp = (tcp_header_t *) mask;
9489 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9490 foreach_tcp_proto_field;
9498 unformat_udp_mask (unformat_input_t * input, va_list * args)
9500 u8 **maskp = va_arg (*args, u8 **);
9502 u8 found_something = 0;
9505 #define _(a) u8 a=0;
9506 foreach_udp_proto_field;
9509 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9512 #define _(a) else if (unformat (input, #a)) a=1;
9513 foreach_udp_proto_field
9519 #define _(a) found_something += a;
9520 foreach_udp_proto_field;
9523 if (found_something == 0)
9526 vec_validate (mask, sizeof (*udp) - 1);
9528 udp = (udp_header_t *) mask;
9530 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9531 foreach_udp_proto_field;
9539 unformat_l4_mask (unformat_input_t * input, va_list * args)
9541 u8 **maskp = va_arg (*args, u8 **);
9542 u16 src_port = 0, dst_port = 0;
9543 tcpudp_header_t *tcpudp;
9545 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9547 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9549 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9551 else if (unformat (input, "src_port"))
9553 else if (unformat (input, "dst_port"))
9559 if (!src_port && !dst_port)
9563 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9565 tcpudp = (tcpudp_header_t *) mask;
9566 tcpudp->src_port = src_port;
9567 tcpudp->dst_port = dst_port;
9575 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9577 u8 **maskp = va_arg (*args, u8 **);
9579 u8 found_something = 0;
9582 #define _(a) u8 a=0;
9583 foreach_ip4_proto_field;
9589 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9591 if (unformat (input, "version"))
9593 else if (unformat (input, "hdr_length"))
9595 else if (unformat (input, "src"))
9597 else if (unformat (input, "dst"))
9599 else if (unformat (input, "proto"))
9602 #define _(a) else if (unformat (input, #a)) a=1;
9603 foreach_ip4_proto_field
9609 #define _(a) found_something += a;
9610 foreach_ip4_proto_field;
9613 if (found_something == 0)
9616 vec_validate (mask, sizeof (*ip) - 1);
9618 ip = (ip4_header_t *) mask;
9620 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9621 foreach_ip4_proto_field;
9624 ip->ip_version_and_header_length = 0;
9627 ip->ip_version_and_header_length |= 0xF0;
9630 ip->ip_version_and_header_length |= 0x0F;
9636 #define foreach_ip6_proto_field \
9644 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9646 u8 **maskp = va_arg (*args, u8 **);
9648 u8 found_something = 0;
9650 u32 ip_version_traffic_class_and_flow_label;
9652 #define _(a) u8 a=0;
9653 foreach_ip6_proto_field;
9656 u8 traffic_class = 0;
9659 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9661 if (unformat (input, "version"))
9663 else if (unformat (input, "traffic-class"))
9665 else if (unformat (input, "flow-label"))
9667 else if (unformat (input, "src"))
9669 else if (unformat (input, "dst"))
9671 else if (unformat (input, "proto"))
9674 #define _(a) else if (unformat (input, #a)) a=1;
9675 foreach_ip6_proto_field
9681 #define _(a) found_something += a;
9682 foreach_ip6_proto_field;
9685 if (found_something == 0)
9688 vec_validate (mask, sizeof (*ip) - 1);
9690 ip = (ip6_header_t *) mask;
9692 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9693 foreach_ip6_proto_field;
9696 ip_version_traffic_class_and_flow_label = 0;
9699 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9702 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9705 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9707 ip->ip_version_traffic_class_and_flow_label =
9708 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9715 unformat_l3_mask (unformat_input_t * input, va_list * args)
9717 u8 **maskp = va_arg (*args, u8 **);
9719 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9721 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9723 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9732 unformat_l2_mask (unformat_input_t * input, va_list * args)
9734 u8 **maskp = va_arg (*args, u8 **);
9749 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9751 if (unformat (input, "src"))
9753 else if (unformat (input, "dst"))
9755 else if (unformat (input, "proto"))
9757 else if (unformat (input, "tag1"))
9759 else if (unformat (input, "tag2"))
9761 else if (unformat (input, "ignore-tag1"))
9763 else if (unformat (input, "ignore-tag2"))
9765 else if (unformat (input, "cos1"))
9767 else if (unformat (input, "cos2"))
9769 else if (unformat (input, "dot1q"))
9771 else if (unformat (input, "dot1ad"))
9776 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9777 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9780 if (tag1 || ignore_tag1 || cos1 || dot1q)
9782 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9785 vec_validate (mask, len - 1);
9788 clib_memset (mask, 0xff, 6);
9791 clib_memset (mask + 6, 0xff, 6);
9795 /* inner vlan tag */
9804 mask[21] = mask[20] = 0xff;
9825 mask[16] = mask[17] = 0xff;
9835 mask[12] = mask[13] = 0xff;
9842 unformat_classify_mask (unformat_input_t * input, va_list * args)
9844 u8 **maskp = va_arg (*args, u8 **);
9845 u32 *skipp = va_arg (*args, u32 *);
9846 u32 *matchp = va_arg (*args, u32 *);
9854 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9856 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9858 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9860 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9862 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9876 if (mask || l2 || l3 || l4)
9880 /* "With a free Ethernet header in every package" */
9882 vec_validate (l2, 13);
9886 vec_append (mask, l3);
9891 vec_append (mask, l4);
9896 /* Scan forward looking for the first significant mask octet */
9897 for (i = 0; i < vec_len (mask); i++)
9901 /* compute (skip, match) params */
9902 *skipp = i / sizeof (u32x4);
9903 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9905 /* Pad mask to an even multiple of the vector size */
9906 while (vec_len (mask) % sizeof (u32x4))
9909 match = vec_len (mask) / sizeof (u32x4);
9911 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9913 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9914 if (*tmp || *(tmp + 1))
9919 clib_warning ("BUG: match 0");
9921 _vec_len (mask) = match * sizeof (u32x4);
9931 #endif /* VPP_API_TEST_BUILTIN */
9933 #define foreach_l2_next \
9935 _(ethernet, ETHERNET_INPUT) \
9940 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9942 u32 *miss_next_indexp = va_arg (*args, u32 *);
9947 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9951 if (unformat (input, "%d", &tmp))
9960 *miss_next_indexp = next_index;
9964 #define foreach_ip_next \
9970 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9972 u32 *miss_next_indexp = va_arg (*args, u32 *);
9977 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9981 if (unformat (input, "%d", &tmp))
9990 *miss_next_indexp = next_index;
9994 #define foreach_acl_next \
9998 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10000 u32 *miss_next_indexp = va_arg (*args, u32 *);
10001 u32 next_index = 0;
10005 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10009 if (unformat (input, "permit"))
10014 else if (unformat (input, "%d", &tmp))
10023 *miss_next_indexp = next_index;
10028 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10030 u32 *r = va_arg (*args, u32 *);
10032 if (unformat (input, "conform-color"))
10033 *r = POLICE_CONFORM;
10034 else if (unformat (input, "exceed-color"))
10035 *r = POLICE_EXCEED;
10043 api_classify_add_del_table (vat_main_t * vam)
10045 unformat_input_t *i = vam->input;
10046 vl_api_classify_add_del_table_t *mp;
10053 u32 table_index = ~0;
10054 u32 next_table_index = ~0;
10055 u32 miss_next_index = ~0;
10056 u32 memory_size = 32 << 20;
10058 u32 current_data_flag = 0;
10059 int current_data_offset = 0;
10062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10064 if (unformat (i, "del"))
10066 else if (unformat (i, "del-chain"))
10071 else if (unformat (i, "buckets %d", &nbuckets))
10073 else if (unformat (i, "memory_size %d", &memory_size))
10075 else if (unformat (i, "skip %d", &skip))
10077 else if (unformat (i, "match %d", &match))
10079 else if (unformat (i, "table %d", &table_index))
10081 else if (unformat (i, "mask %U", unformat_classify_mask,
10082 &mask, &skip, &match))
10084 else if (unformat (i, "next-table %d", &next_table_index))
10086 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10089 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10092 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10095 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10097 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10103 if (is_add && mask == 0)
10105 errmsg ("Mask required");
10109 if (is_add && skip == ~0)
10111 errmsg ("skip count required");
10115 if (is_add && match == ~0)
10117 errmsg ("match count required");
10121 if (!is_add && table_index == ~0)
10123 errmsg ("table index required for delete");
10127 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10129 mp->is_add = is_add;
10130 mp->del_chain = del_chain;
10131 mp->table_index = ntohl (table_index);
10132 mp->nbuckets = ntohl (nbuckets);
10133 mp->memory_size = ntohl (memory_size);
10134 mp->skip_n_vectors = ntohl (skip);
10135 mp->match_n_vectors = ntohl (match);
10136 mp->next_table_index = ntohl (next_table_index);
10137 mp->miss_next_index = ntohl (miss_next_index);
10138 mp->current_data_flag = ntohl (current_data_flag);
10139 mp->current_data_offset = ntohl (current_data_offset);
10140 mp->mask_len = ntohl (vec_len (mask));
10141 clib_memcpy (mp->mask, mask, vec_len (mask));
10150 #if VPP_API_TEST_BUILTIN == 0
10152 unformat_l4_match (unformat_input_t * input, va_list * args)
10154 u8 **matchp = va_arg (*args, u8 **);
10156 u8 *proto_header = 0;
10162 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10164 if (unformat (input, "src_port %d", &src_port))
10166 else if (unformat (input, "dst_port %d", &dst_port))
10172 h.src_port = clib_host_to_net_u16 (src_port);
10173 h.dst_port = clib_host_to_net_u16 (dst_port);
10174 vec_validate (proto_header, sizeof (h) - 1);
10175 memcpy (proto_header, &h, sizeof (h));
10177 *matchp = proto_header;
10183 unformat_ip4_match (unformat_input_t * input, va_list * args)
10185 u8 **matchp = va_arg (*args, u8 **);
10190 int hdr_length = 0;
10191 u32 hdr_length_val;
10192 int src = 0, dst = 0;
10193 ip4_address_t src_val, dst_val;
10200 int fragment_id = 0;
10201 u32 fragment_id_val;
10207 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10209 if (unformat (input, "version %d", &version_val))
10211 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10213 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10215 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10217 else if (unformat (input, "proto %d", &proto_val))
10219 else if (unformat (input, "tos %d", &tos_val))
10221 else if (unformat (input, "length %d", &length_val))
10223 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10225 else if (unformat (input, "ttl %d", &ttl_val))
10227 else if (unformat (input, "checksum %d", &checksum_val))
10233 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10234 + ttl + checksum == 0)
10238 * Aligned because we use the real comparison functions
10240 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10242 ip = (ip4_header_t *) match;
10244 /* These are realistically matched in practice */
10246 ip->src_address.as_u32 = src_val.as_u32;
10249 ip->dst_address.as_u32 = dst_val.as_u32;
10252 ip->protocol = proto_val;
10255 /* These are not, but they're included for completeness */
10257 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10260 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10266 ip->length = clib_host_to_net_u16 (length_val);
10272 ip->checksum = clib_host_to_net_u16 (checksum_val);
10279 unformat_ip6_match (unformat_input_t * input, va_list * args)
10281 u8 **matchp = va_arg (*args, u8 **);
10286 u8 traffic_class = 0;
10287 u32 traffic_class_val = 0;
10290 int src = 0, dst = 0;
10291 ip6_address_t src_val, dst_val;
10294 int payload_length = 0;
10295 u32 payload_length_val;
10298 u32 ip_version_traffic_class_and_flow_label;
10300 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10302 if (unformat (input, "version %d", &version_val))
10304 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10306 else if (unformat (input, "flow_label %d", &flow_label_val))
10308 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10310 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10312 else if (unformat (input, "proto %d", &proto_val))
10314 else if (unformat (input, "payload_length %d", &payload_length_val))
10315 payload_length = 1;
10316 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10322 if (version + traffic_class + flow_label + src + dst + proto +
10323 payload_length + hop_limit == 0)
10327 * Aligned because we use the real comparison functions
10329 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10331 ip = (ip6_header_t *) match;
10334 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10337 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10340 ip->protocol = proto_val;
10342 ip_version_traffic_class_and_flow_label = 0;
10345 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10348 ip_version_traffic_class_and_flow_label |=
10349 (traffic_class_val & 0xFF) << 20;
10352 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10354 ip->ip_version_traffic_class_and_flow_label =
10355 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10357 if (payload_length)
10358 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10361 ip->hop_limit = hop_limit_val;
10368 unformat_l3_match (unformat_input_t * input, va_list * args)
10370 u8 **matchp = va_arg (*args, u8 **);
10372 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10374 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10376 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10385 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10387 u8 *tagp = va_arg (*args, u8 *);
10390 if (unformat (input, "%d", &tag))
10392 tagp[0] = (tag >> 8) & 0x0F;
10393 tagp[1] = tag & 0xFF;
10401 unformat_l2_match (unformat_input_t * input, va_list * args)
10403 u8 **matchp = va_arg (*args, u8 **);
10416 u8 ignore_tag1 = 0;
10417 u8 ignore_tag2 = 0;
10423 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10425 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10428 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10430 else if (unformat (input, "proto %U",
10431 unformat_ethernet_type_host_byte_order, &proto_val))
10433 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10435 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10437 else if (unformat (input, "ignore-tag1"))
10439 else if (unformat (input, "ignore-tag2"))
10441 else if (unformat (input, "cos1 %d", &cos1_val))
10443 else if (unformat (input, "cos2 %d", &cos2_val))
10448 if ((src + dst + proto + tag1 + tag2 +
10449 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10452 if (tag1 || ignore_tag1 || cos1)
10454 if (tag2 || ignore_tag2 || cos2)
10457 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10460 clib_memcpy (match, dst_val, 6);
10463 clib_memcpy (match + 6, src_val, 6);
10467 /* inner vlan tag */
10468 match[19] = tag2_val[1];
10469 match[18] = tag2_val[0];
10471 match[18] |= (cos2_val & 0x7) << 5;
10474 match[21] = proto_val & 0xff;
10475 match[20] = proto_val >> 8;
10479 match[15] = tag1_val[1];
10480 match[14] = tag1_val[0];
10483 match[14] |= (cos1_val & 0x7) << 5;
10489 match[15] = tag1_val[1];
10490 match[14] = tag1_val[0];
10493 match[17] = proto_val & 0xff;
10494 match[16] = proto_val >> 8;
10497 match[14] |= (cos1_val & 0x7) << 5;
10503 match[18] |= (cos2_val & 0x7) << 5;
10505 match[14] |= (cos1_val & 0x7) << 5;
10508 match[13] = proto_val & 0xff;
10509 match[12] = proto_val >> 8;
10517 unformat_qos_source (unformat_input_t * input, va_list * args)
10519 int *qs = va_arg (*args, int *);
10521 if (unformat (input, "ip"))
10522 *qs = QOS_SOURCE_IP;
10523 else if (unformat (input, "mpls"))
10524 *qs = QOS_SOURCE_MPLS;
10525 else if (unformat (input, "ext"))
10526 *qs = QOS_SOURCE_EXT;
10527 else if (unformat (input, "vlan"))
10528 *qs = QOS_SOURCE_VLAN;
10537 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10539 u8 **matchp = va_arg (*args, u8 **);
10540 u32 skip_n_vectors = va_arg (*args, u32);
10541 u32 match_n_vectors = va_arg (*args, u32);
10548 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10550 if (unformat (input, "hex %U", unformat_hex_string, &match))
10552 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10554 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10556 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10570 if (match || l2 || l3 || l4)
10572 if (l2 || l3 || l4)
10574 /* "Win a free Ethernet header in every packet" */
10576 vec_validate_aligned (l2, 13, sizeof (u32x4));
10580 vec_append_aligned (match, l3, sizeof (u32x4));
10585 vec_append_aligned (match, l4, sizeof (u32x4));
10590 /* Make sure the vector is big enough even if key is all 0's */
10591 vec_validate_aligned
10592 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10595 /* Set size, include skipped vectors */
10596 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10607 api_classify_add_del_session (vat_main_t * vam)
10609 unformat_input_t *i = vam->input;
10610 vl_api_classify_add_del_session_t *mp;
10612 u32 table_index = ~0;
10613 u32 hit_next_index = ~0;
10614 u32 opaque_index = ~0;
10617 u32 skip_n_vectors = 0;
10618 u32 match_n_vectors = 0;
10624 * Warning: you have to supply skip_n and match_n
10625 * because the API client cant simply look at the classify
10629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10631 if (unformat (i, "del"))
10633 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10636 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10639 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10642 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10644 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10646 else if (unformat (i, "opaque-index %d", &opaque_index))
10648 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10650 else if (unformat (i, "match_n %d", &match_n_vectors))
10652 else if (unformat (i, "match %U", api_unformat_classify_match,
10653 &match, skip_n_vectors, match_n_vectors))
10655 else if (unformat (i, "advance %d", &advance))
10657 else if (unformat (i, "table-index %d", &table_index))
10659 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10661 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10663 else if (unformat (i, "action %d", &action))
10665 else if (unformat (i, "metadata %d", &metadata))
10671 if (table_index == ~0)
10673 errmsg ("Table index required");
10677 if (is_add && match == 0)
10679 errmsg ("Match value required");
10683 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10685 mp->is_add = is_add;
10686 mp->table_index = ntohl (table_index);
10687 mp->hit_next_index = ntohl (hit_next_index);
10688 mp->opaque_index = ntohl (opaque_index);
10689 mp->advance = ntohl (advance);
10690 mp->action = action;
10691 mp->metadata = ntohl (metadata);
10692 mp->match_len = ntohl (vec_len (match));
10693 clib_memcpy (mp->match, match, vec_len (match));
10702 api_classify_set_interface_ip_table (vat_main_t * vam)
10704 unformat_input_t *i = vam->input;
10705 vl_api_classify_set_interface_ip_table_t *mp;
10707 int sw_if_index_set;
10708 u32 table_index = ~0;
10712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10714 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10715 sw_if_index_set = 1;
10716 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10717 sw_if_index_set = 1;
10718 else if (unformat (i, "table %d", &table_index))
10722 clib_warning ("parse error '%U'", format_unformat_error, i);
10727 if (sw_if_index_set == 0)
10729 errmsg ("missing interface name or sw_if_index");
10734 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10736 mp->sw_if_index = ntohl (sw_if_index);
10737 mp->table_index = ntohl (table_index);
10738 mp->is_ipv6 = is_ipv6;
10746 api_classify_set_interface_l2_tables (vat_main_t * vam)
10748 unformat_input_t *i = vam->input;
10749 vl_api_classify_set_interface_l2_tables_t *mp;
10751 int sw_if_index_set;
10752 u32 ip4_table_index = ~0;
10753 u32 ip6_table_index = ~0;
10754 u32 other_table_index = ~0;
10758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10760 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10761 sw_if_index_set = 1;
10762 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10763 sw_if_index_set = 1;
10764 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10766 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10768 else if (unformat (i, "other-table %d", &other_table_index))
10770 else if (unformat (i, "is-input %d", &is_input))
10774 clib_warning ("parse error '%U'", format_unformat_error, i);
10779 if (sw_if_index_set == 0)
10781 errmsg ("missing interface name or sw_if_index");
10786 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10788 mp->sw_if_index = ntohl (sw_if_index);
10789 mp->ip4_table_index = ntohl (ip4_table_index);
10790 mp->ip6_table_index = ntohl (ip6_table_index);
10791 mp->other_table_index = ntohl (other_table_index);
10792 mp->is_input = (u8) is_input;
10800 api_set_ipfix_exporter (vat_main_t * vam)
10802 unformat_input_t *i = vam->input;
10803 vl_api_set_ipfix_exporter_t *mp;
10804 ip4_address_t collector_address;
10805 u8 collector_address_set = 0;
10806 u32 collector_port = ~0;
10807 ip4_address_t src_address;
10808 u8 src_address_set = 0;
10811 u32 template_interval = ~0;
10812 u8 udp_checksum = 0;
10815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10817 if (unformat (i, "collector_address %U", unformat_ip4_address,
10818 &collector_address))
10819 collector_address_set = 1;
10820 else if (unformat (i, "collector_port %d", &collector_port))
10822 else if (unformat (i, "src_address %U", unformat_ip4_address,
10824 src_address_set = 1;
10825 else if (unformat (i, "vrf_id %d", &vrf_id))
10827 else if (unformat (i, "path_mtu %d", &path_mtu))
10829 else if (unformat (i, "template_interval %d", &template_interval))
10831 else if (unformat (i, "udp_checksum"))
10837 if (collector_address_set == 0)
10839 errmsg ("collector_address required");
10843 if (src_address_set == 0)
10845 errmsg ("src_address required");
10849 M (SET_IPFIX_EXPORTER, mp);
10851 memcpy (mp->collector_address.un.ip4, collector_address.data,
10852 sizeof (collector_address.data));
10853 mp->collector_port = htons ((u16) collector_port);
10854 memcpy (mp->src_address.un.ip4, src_address.data,
10855 sizeof (src_address.data));
10856 mp->vrf_id = htonl (vrf_id);
10857 mp->path_mtu = htonl (path_mtu);
10858 mp->template_interval = htonl (template_interval);
10859 mp->udp_checksum = udp_checksum;
10867 api_set_ipfix_classify_stream (vat_main_t * vam)
10869 unformat_input_t *i = vam->input;
10870 vl_api_set_ipfix_classify_stream_t *mp;
10872 u32 src_port = UDP_DST_PORT_ipfix;
10875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10877 if (unformat (i, "domain %d", &domain_id))
10879 else if (unformat (i, "src_port %d", &src_port))
10883 errmsg ("unknown input `%U'", format_unformat_error, i);
10888 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10890 mp->domain_id = htonl (domain_id);
10891 mp->src_port = htons ((u16) src_port);
10899 api_ipfix_classify_table_add_del (vat_main_t * vam)
10901 unformat_input_t *i = vam->input;
10902 vl_api_ipfix_classify_table_add_del_t *mp;
10904 u32 classify_table_index = ~0;
10906 u8 transport_protocol = 255;
10909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10911 if (unformat (i, "add"))
10913 else if (unformat (i, "del"))
10915 else if (unformat (i, "table %d", &classify_table_index))
10917 else if (unformat (i, "ip4"))
10919 else if (unformat (i, "ip6"))
10921 else if (unformat (i, "tcp"))
10922 transport_protocol = 6;
10923 else if (unformat (i, "udp"))
10924 transport_protocol = 17;
10927 errmsg ("unknown input `%U'", format_unformat_error, i);
10934 errmsg ("expecting: add|del");
10937 if (classify_table_index == ~0)
10939 errmsg ("classifier table not specified");
10942 if (ip_version == 0)
10944 errmsg ("IP version not specified");
10948 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10950 mp->is_add = is_add;
10951 mp->table_id = htonl (classify_table_index);
10952 mp->ip_version = ip_version;
10953 mp->transport_protocol = transport_protocol;
10961 api_get_node_index (vat_main_t * vam)
10963 unformat_input_t *i = vam->input;
10964 vl_api_get_node_index_t *mp;
10968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10970 if (unformat (i, "node %s", &name))
10977 errmsg ("node name required");
10980 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10982 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10986 M (GET_NODE_INDEX, mp);
10987 clib_memcpy (mp->node_name, name, vec_len (name));
10996 api_get_next_index (vat_main_t * vam)
10998 unformat_input_t *i = vam->input;
10999 vl_api_get_next_index_t *mp;
11000 u8 *node_name = 0, *next_node_name = 0;
11003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11005 if (unformat (i, "node-name %s", &node_name))
11007 else if (unformat (i, "next-node-name %s", &next_node_name))
11011 if (node_name == 0)
11013 errmsg ("node name required");
11016 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11018 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11022 if (next_node_name == 0)
11024 errmsg ("next node name required");
11027 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11029 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11033 M (GET_NEXT_INDEX, mp);
11034 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11035 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11036 vec_free (node_name);
11037 vec_free (next_node_name);
11045 api_add_node_next (vat_main_t * vam)
11047 unformat_input_t *i = vam->input;
11048 vl_api_add_node_next_t *mp;
11053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11055 if (unformat (i, "node %s", &name))
11057 else if (unformat (i, "next %s", &next))
11064 errmsg ("node name required");
11067 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11069 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11074 errmsg ("next node required");
11077 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11079 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11083 M (ADD_NODE_NEXT, mp);
11084 clib_memcpy (mp->node_name, name, vec_len (name));
11085 clib_memcpy (mp->next_name, next, vec_len (next));
11095 api_l2tpv3_create_tunnel (vat_main_t * vam)
11097 unformat_input_t *i = vam->input;
11098 ip6_address_t client_address, our_address;
11099 int client_address_set = 0;
11100 int our_address_set = 0;
11101 u32 local_session_id = 0;
11102 u32 remote_session_id = 0;
11103 u64 local_cookie = 0;
11104 u64 remote_cookie = 0;
11105 u8 l2_sublayer_present = 0;
11106 vl_api_l2tpv3_create_tunnel_t *mp;
11109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11111 if (unformat (i, "client_address %U", unformat_ip6_address,
11113 client_address_set = 1;
11114 else if (unformat (i, "our_address %U", unformat_ip6_address,
11116 our_address_set = 1;
11117 else if (unformat (i, "local_session_id %d", &local_session_id))
11119 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11121 else if (unformat (i, "local_cookie %lld", &local_cookie))
11123 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11125 else if (unformat (i, "l2-sublayer-present"))
11126 l2_sublayer_present = 1;
11131 if (client_address_set == 0)
11133 errmsg ("client_address required");
11137 if (our_address_set == 0)
11139 errmsg ("our_address required");
11143 M (L2TPV3_CREATE_TUNNEL, mp);
11145 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11146 sizeof (ip6_address_t));
11148 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11149 sizeof (ip6_address_t));
11151 mp->local_session_id = ntohl (local_session_id);
11152 mp->remote_session_id = ntohl (remote_session_id);
11153 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11154 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11155 mp->l2_sublayer_present = l2_sublayer_present;
11163 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11165 unformat_input_t *i = vam->input;
11167 u8 sw_if_index_set = 0;
11168 u64 new_local_cookie = 0;
11169 u64 new_remote_cookie = 0;
11170 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11175 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11176 sw_if_index_set = 1;
11177 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11178 sw_if_index_set = 1;
11179 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11181 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11187 if (sw_if_index_set == 0)
11189 errmsg ("missing interface name or sw_if_index");
11193 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11195 mp->sw_if_index = ntohl (sw_if_index);
11196 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11197 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11205 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11207 unformat_input_t *i = vam->input;
11208 vl_api_l2tpv3_interface_enable_disable_t *mp;
11210 u8 sw_if_index_set = 0;
11211 u8 enable_disable = 1;
11214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11217 sw_if_index_set = 1;
11218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11219 sw_if_index_set = 1;
11220 else if (unformat (i, "enable"))
11221 enable_disable = 1;
11222 else if (unformat (i, "disable"))
11223 enable_disable = 0;
11228 if (sw_if_index_set == 0)
11230 errmsg ("missing interface name or sw_if_index");
11234 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11236 mp->sw_if_index = ntohl (sw_if_index);
11237 mp->enable_disable = enable_disable;
11245 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11247 unformat_input_t *i = vam->input;
11248 vl_api_l2tpv3_set_lookup_key_t *mp;
11252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11254 if (unformat (i, "lookup_v6_src"))
11255 key = L2T_LOOKUP_SRC_ADDRESS;
11256 else if (unformat (i, "lookup_v6_dst"))
11257 key = L2T_LOOKUP_DST_ADDRESS;
11258 else if (unformat (i, "lookup_session_id"))
11259 key = L2T_LOOKUP_SESSION_ID;
11264 if (key == (u8) ~ 0)
11266 errmsg ("l2tp session lookup key unset");
11270 M (L2TPV3_SET_LOOKUP_KEY, mp);
11279 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11280 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11282 vat_main_t *vam = &vat_main;
11284 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11285 format_ip6_address, mp->our_address,
11286 format_ip6_address, mp->client_address,
11287 clib_net_to_host_u32 (mp->sw_if_index));
11290 " local cookies %016llx %016llx remote cookie %016llx",
11291 clib_net_to_host_u64 (mp->local_cookie[0]),
11292 clib_net_to_host_u64 (mp->local_cookie[1]),
11293 clib_net_to_host_u64 (mp->remote_cookie));
11295 print (vam->ofp, " local session-id %d remote session-id %d",
11296 clib_net_to_host_u32 (mp->local_session_id),
11297 clib_net_to_host_u32 (mp->remote_session_id));
11299 print (vam->ofp, " l2 specific sublayer %s\n",
11300 mp->l2_sublayer_present ? "preset" : "absent");
11304 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11305 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11307 vat_main_t *vam = &vat_main;
11308 vat_json_node_t *node = NULL;
11309 struct in6_addr addr;
11311 if (VAT_JSON_ARRAY != vam->json_tree.type)
11313 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11314 vat_json_init_array (&vam->json_tree);
11316 node = vat_json_array_add (&vam->json_tree);
11318 vat_json_init_object (node);
11320 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11321 vat_json_object_add_ip6 (node, "our_address", addr);
11322 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11323 vat_json_object_add_ip6 (node, "client_address", addr);
11325 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11326 vat_json_init_array (lc);
11327 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11328 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11329 vat_json_object_add_uint (node, "remote_cookie",
11330 clib_net_to_host_u64 (mp->remote_cookie));
11332 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11333 vat_json_object_add_uint (node, "local_session_id",
11334 clib_net_to_host_u32 (mp->local_session_id));
11335 vat_json_object_add_uint (node, "remote_session_id",
11336 clib_net_to_host_u32 (mp->remote_session_id));
11337 vat_json_object_add_string_copy (node, "l2_sublayer",
11338 mp->l2_sublayer_present ? (u8 *) "present"
11339 : (u8 *) "absent");
11343 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11345 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11346 vl_api_control_ping_t *mp_ping;
11349 /* Get list of l2tpv3-tunnel interfaces */
11350 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11353 /* Use a control ping for synchronization */
11354 MPING (CONTROL_PING, mp_ping);
11362 static void vl_api_sw_interface_tap_v2_details_t_handler
11363 (vl_api_sw_interface_tap_v2_details_t * mp)
11365 vat_main_t *vam = &vat_main;
11368 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11369 mp->host_ip4_prefix.len);
11371 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11372 mp->host_ip6_prefix.len);
11375 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11376 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11377 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11378 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11379 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11385 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11386 (vl_api_sw_interface_tap_v2_details_t * mp)
11388 vat_main_t *vam = &vat_main;
11389 vat_json_node_t *node = NULL;
11391 if (VAT_JSON_ARRAY != vam->json_tree.type)
11393 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11394 vat_json_init_array (&vam->json_tree);
11396 node = vat_json_array_add (&vam->json_tree);
11398 vat_json_init_object (node);
11399 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11400 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11401 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11402 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11403 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11404 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11405 vat_json_object_add_string_copy (node, "host_mac_addr",
11406 format (0, "%U", format_ethernet_address,
11407 &mp->host_mac_addr));
11408 vat_json_object_add_string_copy (node, "host_namespace",
11409 mp->host_namespace);
11410 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11411 vat_json_object_add_string_copy (node, "host_ip4_addr",
11412 format (0, "%U/%d", format_ip4_address,
11413 mp->host_ip4_prefix.address,
11414 mp->host_ip4_prefix.len));
11415 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11416 format (0, "%U/%d", format_ip6_address,
11417 mp->host_ip6_prefix.address,
11418 mp->host_ip6_prefix.len));
11423 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11425 vl_api_sw_interface_tap_v2_dump_t *mp;
11426 vl_api_control_ping_t *mp_ping;
11430 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11431 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11432 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11435 /* Get list of tap interfaces */
11436 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11439 /* Use a control ping for synchronization */
11440 MPING (CONTROL_PING, mp_ping);
11447 static void vl_api_sw_interface_virtio_pci_details_t_handler
11448 (vl_api_sw_interface_virtio_pci_details_t * mp)
11450 vat_main_t *vam = &vat_main;
11465 addr.domain = ntohs (mp->pci_addr.domain);
11466 addr.bus = mp->pci_addr.bus;
11467 addr.slot = mp->pci_addr.slot;
11468 addr.function = mp->pci_addr.function;
11470 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11471 addr.slot, addr.function);
11474 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11475 pci_addr, ntohl (mp->sw_if_index),
11476 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11477 format_ethernet_address, mp->mac_addr,
11478 clib_net_to_host_u64 (mp->features));
11479 vec_free (pci_addr);
11482 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11483 (vl_api_sw_interface_virtio_pci_details_t * mp)
11485 vat_main_t *vam = &vat_main;
11486 vat_json_node_t *node = NULL;
11487 vlib_pci_addr_t pci_addr;
11489 if (VAT_JSON_ARRAY != vam->json_tree.type)
11491 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11492 vat_json_init_array (&vam->json_tree);
11494 node = vat_json_array_add (&vam->json_tree);
11496 pci_addr.domain = ntohs (mp->pci_addr.domain);
11497 pci_addr.bus = mp->pci_addr.bus;
11498 pci_addr.slot = mp->pci_addr.slot;
11499 pci_addr.function = mp->pci_addr.function;
11501 vat_json_init_object (node);
11502 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11503 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11504 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11505 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11506 vat_json_object_add_uint (node, "features",
11507 clib_net_to_host_u64 (mp->features));
11508 vat_json_object_add_string_copy (node, "mac_addr",
11509 format (0, "%U", format_ethernet_address,
11514 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11516 vl_api_sw_interface_virtio_pci_dump_t *mp;
11517 vl_api_control_ping_t *mp_ping;
11521 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11522 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11523 "mac_addr", "features");
11525 /* Get list of tap interfaces */
11526 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11529 /* Use a control ping for synchronization */
11530 MPING (CONTROL_PING, mp_ping);
11538 api_vxlan_offload_rx (vat_main_t * vam)
11540 unformat_input_t *line_input = vam->input;
11541 vl_api_vxlan_offload_rx_t *mp;
11542 u32 hw_if_index = ~0, rx_if_index = ~0;
11546 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11548 if (unformat (line_input, "del"))
11550 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11553 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11555 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11558 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11562 errmsg ("parse error '%U'", format_unformat_error, line_input);
11567 if (hw_if_index == ~0)
11569 errmsg ("no hw interface");
11573 if (rx_if_index == ~0)
11575 errmsg ("no rx tunnel");
11579 M (VXLAN_OFFLOAD_RX, mp);
11581 mp->hw_if_index = ntohl (hw_if_index);
11582 mp->sw_if_index = ntohl (rx_if_index);
11583 mp->enable = is_add;
11590 static uword unformat_vxlan_decap_next
11591 (unformat_input_t * input, va_list * args)
11593 u32 *result = va_arg (*args, u32 *);
11596 if (unformat (input, "l2"))
11597 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11598 else if (unformat (input, "%d", &tmp))
11606 api_vxlan_add_del_tunnel (vat_main_t * vam)
11608 unformat_input_t *line_input = vam->input;
11609 vl_api_vxlan_add_del_tunnel_t *mp;
11610 ip46_address_t src, dst;
11612 u8 ipv4_set = 0, ipv6_set = 0;
11617 u32 mcast_sw_if_index = ~0;
11618 u32 encap_vrf_id = 0;
11619 u32 decap_next_index = ~0;
11623 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11624 clib_memset (&src, 0, sizeof src);
11625 clib_memset (&dst, 0, sizeof dst);
11627 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11629 if (unformat (line_input, "del"))
11631 else if (unformat (line_input, "instance %d", &instance))
11634 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11640 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11646 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11652 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11657 else if (unformat (line_input, "group %U %U",
11658 unformat_ip4_address, &dst.ip4,
11659 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11661 grp_set = dst_set = 1;
11664 else if (unformat (line_input, "group %U",
11665 unformat_ip4_address, &dst.ip4))
11667 grp_set = dst_set = 1;
11670 else if (unformat (line_input, "group %U %U",
11671 unformat_ip6_address, &dst.ip6,
11672 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11674 grp_set = dst_set = 1;
11677 else if (unformat (line_input, "group %U",
11678 unformat_ip6_address, &dst.ip6))
11680 grp_set = dst_set = 1;
11684 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11686 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11688 else if (unformat (line_input, "decap-next %U",
11689 unformat_vxlan_decap_next, &decap_next_index))
11691 else if (unformat (line_input, "vni %d", &vni))
11695 errmsg ("parse error '%U'", format_unformat_error, line_input);
11702 errmsg ("tunnel src address not specified");
11707 errmsg ("tunnel dst address not specified");
11711 if (grp_set && !ip46_address_is_multicast (&dst))
11713 errmsg ("tunnel group address not multicast");
11716 if (grp_set && mcast_sw_if_index == ~0)
11718 errmsg ("tunnel nonexistent multicast device");
11721 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11723 errmsg ("tunnel dst address must be unicast");
11728 if (ipv4_set && ipv6_set)
11730 errmsg ("both IPv4 and IPv6 addresses specified");
11734 if ((vni == 0) || (vni >> 24))
11736 errmsg ("vni not specified or out of range");
11740 M (VXLAN_ADD_DEL_TUNNEL, mp);
11744 clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
11745 clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11749 clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
11750 clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11752 mp->src_address.af = ipv6_set;
11753 mp->dst_address.af = ipv6_set;
11755 mp->instance = htonl (instance);
11756 mp->encap_vrf_id = ntohl (encap_vrf_id);
11757 mp->decap_next_index = ntohl (decap_next_index);
11758 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11759 mp->vni = ntohl (vni);
11760 mp->is_add = is_add;
11767 static void vl_api_vxlan_tunnel_details_t_handler
11768 (vl_api_vxlan_tunnel_details_t * mp)
11770 vat_main_t *vam = &vat_main;
11771 ip46_address_t src =
11772 to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
11773 ip46_address_t dst =
11774 to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
11776 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11777 ntohl (mp->sw_if_index),
11778 ntohl (mp->instance),
11779 format_ip46_address, &src, IP46_TYPE_ANY,
11780 format_ip46_address, &dst, IP46_TYPE_ANY,
11781 ntohl (mp->encap_vrf_id),
11782 ntohl (mp->decap_next_index), ntohl (mp->vni),
11783 ntohl (mp->mcast_sw_if_index));
11786 static void vl_api_vxlan_tunnel_details_t_handler_json
11787 (vl_api_vxlan_tunnel_details_t * mp)
11789 vat_main_t *vam = &vat_main;
11790 vat_json_node_t *node = NULL;
11792 if (VAT_JSON_ARRAY != vam->json_tree.type)
11794 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11795 vat_json_init_array (&vam->json_tree);
11797 node = vat_json_array_add (&vam->json_tree);
11799 vat_json_init_object (node);
11800 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11802 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11804 if (mp->src_address.af)
11806 struct in6_addr ip6;
11808 clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
11809 vat_json_object_add_ip6 (node, "src_address", ip6);
11810 clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
11811 vat_json_object_add_ip6 (node, "dst_address", ip6);
11815 struct in_addr ip4;
11817 clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
11818 vat_json_object_add_ip4 (node, "src_address", ip4);
11819 clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
11820 vat_json_object_add_ip4 (node, "dst_address", ip4);
11822 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11823 vat_json_object_add_uint (node, "decap_next_index",
11824 ntohl (mp->decap_next_index));
11825 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11826 vat_json_object_add_uint (node, "mcast_sw_if_index",
11827 ntohl (mp->mcast_sw_if_index));
11831 api_vxlan_tunnel_dump (vat_main_t * vam)
11833 unformat_input_t *i = vam->input;
11834 vl_api_vxlan_tunnel_dump_t *mp;
11835 vl_api_control_ping_t *mp_ping;
11837 u8 sw_if_index_set = 0;
11840 /* Parse args required to build the message */
11841 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11843 if (unformat (i, "sw_if_index %d", &sw_if_index))
11844 sw_if_index_set = 1;
11849 if (sw_if_index_set == 0)
11854 if (!vam->json_output)
11856 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11857 "sw_if_index", "instance", "src_address", "dst_address",
11858 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11861 /* Get list of vxlan-tunnel interfaces */
11862 M (VXLAN_TUNNEL_DUMP, mp);
11864 mp->sw_if_index = htonl (sw_if_index);
11868 /* Use a control ping for synchronization */
11869 MPING (CONTROL_PING, mp_ping);
11876 static uword unformat_geneve_decap_next
11877 (unformat_input_t * input, va_list * args)
11879 u32 *result = va_arg (*args, u32 *);
11882 if (unformat (input, "l2"))
11883 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11884 else if (unformat (input, "%d", &tmp))
11892 api_geneve_add_del_tunnel (vat_main_t * vam)
11894 unformat_input_t *line_input = vam->input;
11895 vl_api_geneve_add_del_tunnel_t *mp;
11896 ip46_address_t src, dst;
11898 u8 ipv4_set = 0, ipv6_set = 0;
11902 u32 mcast_sw_if_index = ~0;
11903 u32 encap_vrf_id = 0;
11904 u32 decap_next_index = ~0;
11908 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11909 clib_memset (&src, 0, sizeof src);
11910 clib_memset (&dst, 0, sizeof dst);
11912 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11914 if (unformat (line_input, "del"))
11917 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11923 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11929 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11935 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11940 else if (unformat (line_input, "group %U %U",
11941 unformat_ip4_address, &dst.ip4,
11942 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11944 grp_set = dst_set = 1;
11947 else if (unformat (line_input, "group %U",
11948 unformat_ip4_address, &dst.ip4))
11950 grp_set = dst_set = 1;
11953 else if (unformat (line_input, "group %U %U",
11954 unformat_ip6_address, &dst.ip6,
11955 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11957 grp_set = dst_set = 1;
11960 else if (unformat (line_input, "group %U",
11961 unformat_ip6_address, &dst.ip6))
11963 grp_set = dst_set = 1;
11967 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11969 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11971 else if (unformat (line_input, "decap-next %U",
11972 unformat_geneve_decap_next, &decap_next_index))
11974 else if (unformat (line_input, "vni %d", &vni))
11978 errmsg ("parse error '%U'", format_unformat_error, line_input);
11985 errmsg ("tunnel src address not specified");
11990 errmsg ("tunnel dst address not specified");
11994 if (grp_set && !ip46_address_is_multicast (&dst))
11996 errmsg ("tunnel group address not multicast");
11999 if (grp_set && mcast_sw_if_index == ~0)
12001 errmsg ("tunnel nonexistent multicast device");
12004 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12006 errmsg ("tunnel dst address must be unicast");
12011 if (ipv4_set && ipv6_set)
12013 errmsg ("both IPv4 and IPv6 addresses specified");
12017 if ((vni == 0) || (vni >> 24))
12019 errmsg ("vni not specified or out of range");
12023 M (GENEVE_ADD_DEL_TUNNEL, mp);
12027 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12028 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12032 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12033 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12035 mp->encap_vrf_id = ntohl (encap_vrf_id);
12036 mp->decap_next_index = ntohl (decap_next_index);
12037 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12038 mp->vni = ntohl (vni);
12039 mp->is_add = is_add;
12046 static void vl_api_geneve_tunnel_details_t_handler
12047 (vl_api_geneve_tunnel_details_t * mp)
12049 vat_main_t *vam = &vat_main;
12050 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12051 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12053 if (mp->src_address.af == ADDRESS_IP6)
12055 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12056 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12060 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12061 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12064 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12065 ntohl (mp->sw_if_index),
12066 format_ip46_address, &src, IP46_TYPE_ANY,
12067 format_ip46_address, &dst, IP46_TYPE_ANY,
12068 ntohl (mp->encap_vrf_id),
12069 ntohl (mp->decap_next_index), ntohl (mp->vni),
12070 ntohl (mp->mcast_sw_if_index));
12073 static void vl_api_geneve_tunnel_details_t_handler_json
12074 (vl_api_geneve_tunnel_details_t * mp)
12076 vat_main_t *vam = &vat_main;
12077 vat_json_node_t *node = NULL;
12080 if (VAT_JSON_ARRAY != vam->json_tree.type)
12082 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12083 vat_json_init_array (&vam->json_tree);
12085 node = vat_json_array_add (&vam->json_tree);
12087 vat_json_init_object (node);
12088 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12089 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12092 struct in6_addr ip6;
12094 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12095 vat_json_object_add_ip6 (node, "src_address", ip6);
12096 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12097 vat_json_object_add_ip6 (node, "dst_address", ip6);
12101 struct in_addr ip4;
12103 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12104 vat_json_object_add_ip4 (node, "src_address", ip4);
12105 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12106 vat_json_object_add_ip4 (node, "dst_address", ip4);
12108 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12109 vat_json_object_add_uint (node, "decap_next_index",
12110 ntohl (mp->decap_next_index));
12111 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12112 vat_json_object_add_uint (node, "mcast_sw_if_index",
12113 ntohl (mp->mcast_sw_if_index));
12117 api_geneve_tunnel_dump (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_geneve_tunnel_dump_t *mp;
12121 vl_api_control_ping_t *mp_ping;
12123 u8 sw_if_index_set = 0;
12126 /* Parse args required to build the message */
12127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12129 if (unformat (i, "sw_if_index %d", &sw_if_index))
12130 sw_if_index_set = 1;
12135 if (sw_if_index_set == 0)
12140 if (!vam->json_output)
12142 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12143 "sw_if_index", "local_address", "remote_address",
12144 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12147 /* Get list of geneve-tunnel interfaces */
12148 M (GENEVE_TUNNEL_DUMP, mp);
12150 mp->sw_if_index = htonl (sw_if_index);
12154 /* Use a control ping for synchronization */
12155 M (CONTROL_PING, mp_ping);
12163 api_gre_tunnel_add_del (vat_main_t * vam)
12165 unformat_input_t *line_input = vam->input;
12166 vl_api_address_t src = { }, dst =
12169 vl_api_gre_tunnel_add_del_t *mp;
12170 vl_api_gre_tunnel_type_t t_type;
12174 u32 outer_table_id = 0;
12175 u32 session_id = 0;
12179 t_type = GRE_API_TUNNEL_TYPE_L3;
12181 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12183 if (unformat (line_input, "del"))
12185 else if (unformat (line_input, "instance %d", &instance))
12187 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12191 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12195 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12197 else if (unformat (line_input, "teb"))
12198 t_type = GRE_API_TUNNEL_TYPE_TEB;
12199 else if (unformat (line_input, "erspan %d", &session_id))
12200 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12203 errmsg ("parse error '%U'", format_unformat_error, line_input);
12210 errmsg ("tunnel src address not specified");
12215 errmsg ("tunnel dst address not specified");
12219 M (GRE_TUNNEL_ADD_DEL, mp);
12221 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12222 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12224 mp->tunnel.instance = htonl (instance);
12225 mp->tunnel.outer_table_id = htonl (outer_table_id);
12226 mp->is_add = is_add;
12227 mp->tunnel.session_id = htons ((u16) session_id);
12228 mp->tunnel.type = htonl (t_type);
12235 static void vl_api_gre_tunnel_details_t_handler
12236 (vl_api_gre_tunnel_details_t * mp)
12238 vat_main_t *vam = &vat_main;
12240 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12241 ntohl (mp->tunnel.sw_if_index),
12242 ntohl (mp->tunnel.instance),
12243 format_vl_api_address, &mp->tunnel.src,
12244 format_vl_api_address, &mp->tunnel.dst,
12245 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12246 ntohl (mp->tunnel.session_id));
12249 static void vl_api_gre_tunnel_details_t_handler_json
12250 (vl_api_gre_tunnel_details_t * mp)
12252 vat_main_t *vam = &vat_main;
12253 vat_json_node_t *node = NULL;
12255 if (VAT_JSON_ARRAY != vam->json_tree.type)
12257 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12258 vat_json_init_array (&vam->json_tree);
12260 node = vat_json_array_add (&vam->json_tree);
12262 vat_json_init_object (node);
12263 vat_json_object_add_uint (node, "sw_if_index",
12264 ntohl (mp->tunnel.sw_if_index));
12265 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12267 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12268 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12269 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12270 vat_json_object_add_uint (node, "outer_table_id",
12271 ntohl (mp->tunnel.outer_table_id));
12272 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12276 api_gre_tunnel_dump (vat_main_t * vam)
12278 unformat_input_t *i = vam->input;
12279 vl_api_gre_tunnel_dump_t *mp;
12280 vl_api_control_ping_t *mp_ping;
12282 u8 sw_if_index_set = 0;
12285 /* Parse args required to build the message */
12286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12288 if (unformat (i, "sw_if_index %d", &sw_if_index))
12289 sw_if_index_set = 1;
12294 if (sw_if_index_set == 0)
12299 if (!vam->json_output)
12301 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12302 "sw_if_index", "instance", "src_address", "dst_address",
12303 "tunnel_type", "outer_fib_id", "session_id");
12306 /* Get list of gre-tunnel interfaces */
12307 M (GRE_TUNNEL_DUMP, mp);
12309 mp->sw_if_index = htonl (sw_if_index);
12313 /* Use a control ping for synchronization */
12314 MPING (CONTROL_PING, mp_ping);
12322 api_l2_fib_clear_table (vat_main_t * vam)
12324 // unformat_input_t * i = vam->input;
12325 vl_api_l2_fib_clear_table_t *mp;
12328 M (L2_FIB_CLEAR_TABLE, mp);
12336 api_l2_interface_efp_filter (vat_main_t * vam)
12338 unformat_input_t *i = vam->input;
12339 vl_api_l2_interface_efp_filter_t *mp;
12342 u8 sw_if_index_set = 0;
12345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12347 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12348 sw_if_index_set = 1;
12349 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12350 sw_if_index_set = 1;
12351 else if (unformat (i, "enable"))
12353 else if (unformat (i, "disable"))
12357 clib_warning ("parse error '%U'", format_unformat_error, i);
12362 if (sw_if_index_set == 0)
12364 errmsg ("missing sw_if_index");
12368 M (L2_INTERFACE_EFP_FILTER, mp);
12370 mp->sw_if_index = ntohl (sw_if_index);
12371 mp->enable_disable = enable;
12378 #define foreach_vtr_op \
12379 _("disable", L2_VTR_DISABLED) \
12380 _("push-1", L2_VTR_PUSH_1) \
12381 _("push-2", L2_VTR_PUSH_2) \
12382 _("pop-1", L2_VTR_POP_1) \
12383 _("pop-2", L2_VTR_POP_2) \
12384 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12385 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12386 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12387 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12390 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12392 unformat_input_t *i = vam->input;
12393 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12395 u8 sw_if_index_set = 0;
12398 u32 push_dot1q = 1;
12403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12405 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12406 sw_if_index_set = 1;
12407 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12408 sw_if_index_set = 1;
12409 else if (unformat (i, "vtr_op %d", &vtr_op))
12411 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12414 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12416 else if (unformat (i, "tag1 %d", &tag1))
12418 else if (unformat (i, "tag2 %d", &tag2))
12422 clib_warning ("parse error '%U'", format_unformat_error, i);
12427 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12429 errmsg ("missing vtr operation or sw_if_index");
12433 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12434 mp->sw_if_index = ntohl (sw_if_index);
12435 mp->vtr_op = ntohl (vtr_op);
12436 mp->push_dot1q = ntohl (push_dot1q);
12437 mp->tag1 = ntohl (tag1);
12438 mp->tag2 = ntohl (tag2);
12446 api_create_vhost_user_if (vat_main_t * vam)
12448 unformat_input_t *i = vam->input;
12449 vl_api_create_vhost_user_if_t *mp;
12452 u8 file_name_set = 0;
12453 u32 custom_dev_instance = ~0;
12455 u8 use_custom_mac = 0;
12456 u8 disable_mrg_rxbuf = 0;
12457 u8 disable_indirect_desc = 0;
12460 u8 enable_packed = 0;
12463 /* Shut up coverity */
12464 clib_memset (hwaddr, 0, sizeof (hwaddr));
12466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12468 if (unformat (i, "socket %s", &file_name))
12472 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12474 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12475 use_custom_mac = 1;
12476 else if (unformat (i, "server"))
12478 else if (unformat (i, "disable_mrg_rxbuf"))
12479 disable_mrg_rxbuf = 1;
12480 else if (unformat (i, "disable_indirect_desc"))
12481 disable_indirect_desc = 1;
12482 else if (unformat (i, "gso"))
12484 else if (unformat (i, "packed"))
12486 else if (unformat (i, "tag %s", &tag))
12492 if (file_name_set == 0)
12494 errmsg ("missing socket file name");
12498 if (vec_len (file_name) > 255)
12500 errmsg ("socket file name too long");
12503 vec_add1 (file_name, 0);
12505 M (CREATE_VHOST_USER_IF, mp);
12507 mp->is_server = is_server;
12508 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12509 mp->disable_indirect_desc = disable_indirect_desc;
12510 mp->enable_gso = enable_gso;
12511 mp->enable_packed = enable_packed;
12512 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12513 vec_free (file_name);
12514 if (custom_dev_instance != ~0)
12517 mp->custom_dev_instance = ntohl (custom_dev_instance);
12520 mp->use_custom_mac = use_custom_mac;
12521 clib_memcpy (mp->mac_address, hwaddr, 6);
12523 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12532 api_modify_vhost_user_if (vat_main_t * vam)
12534 unformat_input_t *i = vam->input;
12535 vl_api_modify_vhost_user_if_t *mp;
12538 u8 file_name_set = 0;
12539 u32 custom_dev_instance = ~0;
12540 u8 sw_if_index_set = 0;
12541 u32 sw_if_index = (u32) ~ 0;
12543 u8 enable_packed = 0;
12546 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12548 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12549 sw_if_index_set = 1;
12550 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12551 sw_if_index_set = 1;
12552 else if (unformat (i, "socket %s", &file_name))
12556 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12558 else if (unformat (i, "server"))
12560 else if (unformat (i, "gso"))
12562 else if (unformat (i, "packed"))
12568 if (sw_if_index_set == 0)
12570 errmsg ("missing sw_if_index or interface name");
12574 if (file_name_set == 0)
12576 errmsg ("missing socket file name");
12580 if (vec_len (file_name) > 255)
12582 errmsg ("socket file name too long");
12585 vec_add1 (file_name, 0);
12587 M (MODIFY_VHOST_USER_IF, mp);
12589 mp->sw_if_index = ntohl (sw_if_index);
12590 mp->is_server = is_server;
12591 mp->enable_gso = enable_gso;
12592 mp->enable_packed = enable_packed;
12593 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12594 vec_free (file_name);
12595 if (custom_dev_instance != ~0)
12598 mp->custom_dev_instance = ntohl (custom_dev_instance);
12607 api_delete_vhost_user_if (vat_main_t * vam)
12609 unformat_input_t *i = vam->input;
12610 vl_api_delete_vhost_user_if_t *mp;
12611 u32 sw_if_index = ~0;
12612 u8 sw_if_index_set = 0;
12615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12617 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12618 sw_if_index_set = 1;
12619 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12620 sw_if_index_set = 1;
12625 if (sw_if_index_set == 0)
12627 errmsg ("missing sw_if_index or interface name");
12632 M (DELETE_VHOST_USER_IF, mp);
12634 mp->sw_if_index = ntohl (sw_if_index);
12641 static void vl_api_sw_interface_vhost_user_details_t_handler
12642 (vl_api_sw_interface_vhost_user_details_t * mp)
12644 vat_main_t *vam = &vat_main;
12648 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12649 clib_net_to_host_u32
12650 (mp->features_last_32) <<
12653 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12654 (char *) mp->interface_name,
12655 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12656 features, mp->is_server,
12657 ntohl (mp->num_regions), (char *) mp->sock_filename);
12658 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12661 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12662 (vl_api_sw_interface_vhost_user_details_t * mp)
12664 vat_main_t *vam = &vat_main;
12665 vat_json_node_t *node = NULL;
12667 if (VAT_JSON_ARRAY != vam->json_tree.type)
12669 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12670 vat_json_init_array (&vam->json_tree);
12672 node = vat_json_array_add (&vam->json_tree);
12674 vat_json_init_object (node);
12675 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12676 vat_json_object_add_string_copy (node, "interface_name",
12677 mp->interface_name);
12678 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12679 ntohl (mp->virtio_net_hdr_sz));
12680 vat_json_object_add_uint (node, "features_first_32",
12681 clib_net_to_host_u32 (mp->features_first_32));
12682 vat_json_object_add_uint (node, "features_last_32",
12683 clib_net_to_host_u32 (mp->features_last_32));
12684 vat_json_object_add_uint (node, "is_server", mp->is_server);
12685 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12686 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12687 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12691 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12693 unformat_input_t *i = vam->input;
12694 vl_api_sw_interface_vhost_user_dump_t *mp;
12695 vl_api_control_ping_t *mp_ping;
12697 u32 sw_if_index = ~0;
12699 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12701 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12703 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12710 "Interface name idx hdr_sz features server regions filename");
12712 /* Get list of vhost-user interfaces */
12713 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12714 mp->sw_if_index = ntohl (sw_if_index);
12717 /* Use a control ping for synchronization */
12718 MPING (CONTROL_PING, mp_ping);
12726 api_show_version (vat_main_t * vam)
12728 vl_api_show_version_t *mp;
12731 M (SHOW_VERSION, mp);
12740 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12742 unformat_input_t *line_input = vam->input;
12743 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12744 ip46_address_t local, remote;
12749 u32 mcast_sw_if_index = ~0;
12750 u32 encap_vrf_id = 0;
12751 u32 decap_vrf_id = 0;
12757 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12759 if (unformat (line_input, "del"))
12761 else if (unformat (line_input, "local %U",
12762 unformat_ip46_address, &local))
12766 else if (unformat (line_input, "remote %U",
12767 unformat_ip46_address, &remote))
12771 else if (unformat (line_input, "group %U %U",
12772 unformat_ip46_address, &remote,
12773 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12775 grp_set = remote_set = 1;
12777 else if (unformat (line_input, "group %U",
12778 unformat_ip46_address, &remote))
12780 grp_set = remote_set = 1;
12783 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12785 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12787 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12789 else if (unformat (line_input, "vni %d", &vni))
12791 else if (unformat (line_input, "next-ip4"))
12793 else if (unformat (line_input, "next-ip6"))
12795 else if (unformat (line_input, "next-ethernet"))
12797 else if (unformat (line_input, "next-nsh"))
12801 errmsg ("parse error '%U'", format_unformat_error, line_input);
12806 if (local_set == 0)
12808 errmsg ("tunnel local address not specified");
12811 if (remote_set == 0)
12813 errmsg ("tunnel remote address not specified");
12816 if (grp_set && mcast_sw_if_index == ~0)
12818 errmsg ("tunnel nonexistent multicast device");
12821 if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
12823 errmsg ("both IPv4 and IPv6 addresses specified");
12829 errmsg ("vni not specified");
12833 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12835 ip_address_encode (&local,
12836 ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
12837 IP46_TYPE_IP6, &mp->local);
12838 ip_address_encode (&remote,
12839 ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
12840 IP46_TYPE_IP6, &mp->remote);
12842 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12843 mp->encap_vrf_id = ntohl (encap_vrf_id);
12844 mp->decap_vrf_id = ntohl (decap_vrf_id);
12845 mp->protocol = protocol;
12846 mp->vni = ntohl (vni);
12847 mp->is_add = is_add;
12854 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12855 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12857 vat_main_t *vam = &vat_main;
12858 ip46_address_t local, remote;
12860 ip_address_decode (&mp->local, &local);
12861 ip_address_decode (&mp->remote, &remote);
12863 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12864 ntohl (mp->sw_if_index),
12865 format_ip46_address, &local, IP46_TYPE_ANY,
12866 format_ip46_address, &remote, IP46_TYPE_ANY,
12867 ntohl (mp->vni), mp->protocol,
12868 ntohl (mp->mcast_sw_if_index),
12869 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12873 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12874 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12876 vat_main_t *vam = &vat_main;
12877 vat_json_node_t *node = NULL;
12878 struct in_addr ip4;
12879 struct in6_addr ip6;
12880 ip46_address_t local, remote;
12882 ip_address_decode (&mp->local, &local);
12883 ip_address_decode (&mp->remote, &remote);
12885 if (VAT_JSON_ARRAY != vam->json_tree.type)
12887 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12888 vat_json_init_array (&vam->json_tree);
12890 node = vat_json_array_add (&vam->json_tree);
12892 vat_json_init_object (node);
12893 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12894 if (ip46_address_is_ip4 (&local))
12896 clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
12897 vat_json_object_add_ip4 (node, "local", ip4);
12898 clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
12899 vat_json_object_add_ip4 (node, "remote", ip4);
12903 clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
12904 vat_json_object_add_ip6 (node, "local", ip6);
12905 clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
12906 vat_json_object_add_ip6 (node, "remote", ip6);
12908 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12909 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12910 vat_json_object_add_uint (node, "mcast_sw_if_index",
12911 ntohl (mp->mcast_sw_if_index));
12912 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12913 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12914 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12918 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12920 unformat_input_t *i = vam->input;
12921 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12922 vl_api_control_ping_t *mp_ping;
12924 u8 sw_if_index_set = 0;
12927 /* Parse args required to build the message */
12928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12930 if (unformat (i, "sw_if_index %d", &sw_if_index))
12931 sw_if_index_set = 1;
12936 if (sw_if_index_set == 0)
12941 if (!vam->json_output)
12943 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12944 "sw_if_index", "local", "remote", "vni",
12945 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12948 /* Get list of vxlan-tunnel interfaces */
12949 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12951 mp->sw_if_index = htonl (sw_if_index);
12955 /* Use a control ping for synchronization */
12956 MPING (CONTROL_PING, mp_ping);
12963 static void vl_api_l2_fib_table_details_t_handler
12964 (vl_api_l2_fib_table_details_t * mp)
12966 vat_main_t *vam = &vat_main;
12968 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12970 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12971 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12975 static void vl_api_l2_fib_table_details_t_handler_json
12976 (vl_api_l2_fib_table_details_t * mp)
12978 vat_main_t *vam = &vat_main;
12979 vat_json_node_t *node = NULL;
12981 if (VAT_JSON_ARRAY != vam->json_tree.type)
12983 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12984 vat_json_init_array (&vam->json_tree);
12986 node = vat_json_array_add (&vam->json_tree);
12988 vat_json_init_object (node);
12989 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12990 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12991 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12992 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12993 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12994 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12998 api_l2_fib_table_dump (vat_main_t * vam)
13000 unformat_input_t *i = vam->input;
13001 vl_api_l2_fib_table_dump_t *mp;
13002 vl_api_control_ping_t *mp_ping;
13007 /* Parse args required to build the message */
13008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13010 if (unformat (i, "bd_id %d", &bd_id))
13016 if (bd_id_set == 0)
13018 errmsg ("missing bridge domain");
13022 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13024 /* Get list of l2 fib entries */
13025 M (L2_FIB_TABLE_DUMP, mp);
13027 mp->bd_id = ntohl (bd_id);
13030 /* Use a control ping for synchronization */
13031 MPING (CONTROL_PING, mp_ping);
13040 api_interface_name_renumber (vat_main_t * vam)
13042 unformat_input_t *line_input = vam->input;
13043 vl_api_interface_name_renumber_t *mp;
13044 u32 sw_if_index = ~0;
13045 u32 new_show_dev_instance = ~0;
13048 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13050 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13053 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13055 else if (unformat (line_input, "new_show_dev_instance %d",
13056 &new_show_dev_instance))
13062 if (sw_if_index == ~0)
13064 errmsg ("missing interface name or sw_if_index");
13068 if (new_show_dev_instance == ~0)
13070 errmsg ("missing new_show_dev_instance");
13074 M (INTERFACE_NAME_RENUMBER, mp);
13076 mp->sw_if_index = ntohl (sw_if_index);
13077 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13085 api_want_l2_macs_events (vat_main_t * vam)
13087 unformat_input_t *line_input = vam->input;
13088 vl_api_want_l2_macs_events_t *mp;
13089 u8 enable_disable = 1;
13090 u32 scan_delay = 0;
13091 u32 max_macs_in_event = 0;
13092 u32 learn_limit = 0;
13095 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13097 if (unformat (line_input, "learn-limit %d", &learn_limit))
13099 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13101 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13103 else if (unformat (line_input, "disable"))
13104 enable_disable = 0;
13109 M (WANT_L2_MACS_EVENTS, mp);
13110 mp->enable_disable = enable_disable;
13111 mp->pid = htonl (getpid ());
13112 mp->learn_limit = htonl (learn_limit);
13113 mp->scan_delay = (u8) scan_delay;
13114 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13121 api_input_acl_set_interface (vat_main_t * vam)
13123 unformat_input_t *i = vam->input;
13124 vl_api_input_acl_set_interface_t *mp;
13126 int sw_if_index_set;
13127 u32 ip4_table_index = ~0;
13128 u32 ip6_table_index = ~0;
13129 u32 l2_table_index = ~0;
13133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13135 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13136 sw_if_index_set = 1;
13137 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13138 sw_if_index_set = 1;
13139 else if (unformat (i, "del"))
13141 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13143 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13145 else if (unformat (i, "l2-table %d", &l2_table_index))
13149 clib_warning ("parse error '%U'", format_unformat_error, i);
13154 if (sw_if_index_set == 0)
13156 errmsg ("missing interface name or sw_if_index");
13160 M (INPUT_ACL_SET_INTERFACE, mp);
13162 mp->sw_if_index = ntohl (sw_if_index);
13163 mp->ip4_table_index = ntohl (ip4_table_index);
13164 mp->ip6_table_index = ntohl (ip6_table_index);
13165 mp->l2_table_index = ntohl (l2_table_index);
13166 mp->is_add = is_add;
13174 api_output_acl_set_interface (vat_main_t * vam)
13176 unformat_input_t *i = vam->input;
13177 vl_api_output_acl_set_interface_t *mp;
13179 int sw_if_index_set;
13180 u32 ip4_table_index = ~0;
13181 u32 ip6_table_index = ~0;
13182 u32 l2_table_index = ~0;
13186 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13188 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13189 sw_if_index_set = 1;
13190 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13191 sw_if_index_set = 1;
13192 else if (unformat (i, "del"))
13194 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13196 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13198 else if (unformat (i, "l2-table %d", &l2_table_index))
13202 clib_warning ("parse error '%U'", format_unformat_error, i);
13207 if (sw_if_index_set == 0)
13209 errmsg ("missing interface name or sw_if_index");
13213 M (OUTPUT_ACL_SET_INTERFACE, mp);
13215 mp->sw_if_index = ntohl (sw_if_index);
13216 mp->ip4_table_index = ntohl (ip4_table_index);
13217 mp->ip6_table_index = ntohl (ip6_table_index);
13218 mp->l2_table_index = ntohl (l2_table_index);
13219 mp->is_add = is_add;
13227 api_ip_address_dump (vat_main_t * vam)
13229 unformat_input_t *i = vam->input;
13230 vl_api_ip_address_dump_t *mp;
13231 vl_api_control_ping_t *mp_ping;
13232 u32 sw_if_index = ~0;
13233 u8 sw_if_index_set = 0;
13238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13240 if (unformat (i, "sw_if_index %d", &sw_if_index))
13241 sw_if_index_set = 1;
13243 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13244 sw_if_index_set = 1;
13245 else if (unformat (i, "ipv4"))
13247 else if (unformat (i, "ipv6"))
13253 if (ipv4_set && ipv6_set)
13255 errmsg ("ipv4 and ipv6 flags cannot be both set");
13259 if ((!ipv4_set) && (!ipv6_set))
13261 errmsg ("no ipv4 nor ipv6 flag set");
13265 if (sw_if_index_set == 0)
13267 errmsg ("missing interface name or sw_if_index");
13271 vam->current_sw_if_index = sw_if_index;
13272 vam->is_ipv6 = ipv6_set;
13274 M (IP_ADDRESS_DUMP, mp);
13275 mp->sw_if_index = ntohl (sw_if_index);
13276 mp->is_ipv6 = ipv6_set;
13279 /* Use a control ping for synchronization */
13280 MPING (CONTROL_PING, mp_ping);
13288 api_ip_dump (vat_main_t * vam)
13290 vl_api_ip_dump_t *mp;
13291 vl_api_control_ping_t *mp_ping;
13292 unformat_input_t *in = vam->input;
13299 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13301 if (unformat (in, "ipv4"))
13303 else if (unformat (in, "ipv6"))
13309 if (ipv4_set && ipv6_set)
13311 errmsg ("ipv4 and ipv6 flags cannot be both set");
13315 if ((!ipv4_set) && (!ipv6_set))
13317 errmsg ("no ipv4 nor ipv6 flag set");
13321 is_ipv6 = ipv6_set;
13322 vam->is_ipv6 = is_ipv6;
13324 /* free old data */
13325 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13327 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13329 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13332 mp->is_ipv6 = ipv6_set;
13335 /* Use a control ping for synchronization */
13336 MPING (CONTROL_PING, mp_ping);
13344 api_ipsec_spd_add_del (vat_main_t * vam)
13346 unformat_input_t *i = vam->input;
13347 vl_api_ipsec_spd_add_del_t *mp;
13352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13354 if (unformat (i, "spd_id %d", &spd_id))
13356 else if (unformat (i, "del"))
13360 clib_warning ("parse error '%U'", format_unformat_error, i);
13366 errmsg ("spd_id must be set");
13370 M (IPSEC_SPD_ADD_DEL, mp);
13372 mp->spd_id = ntohl (spd_id);
13373 mp->is_add = is_add;
13381 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13383 unformat_input_t *i = vam->input;
13384 vl_api_ipsec_interface_add_del_spd_t *mp;
13386 u8 sw_if_index_set = 0;
13387 u32 spd_id = (u32) ~ 0;
13391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13393 if (unformat (i, "del"))
13395 else if (unformat (i, "spd_id %d", &spd_id))
13398 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13399 sw_if_index_set = 1;
13400 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13401 sw_if_index_set = 1;
13404 clib_warning ("parse error '%U'", format_unformat_error, i);
13410 if (spd_id == (u32) ~ 0)
13412 errmsg ("spd_id must be set");
13416 if (sw_if_index_set == 0)
13418 errmsg ("missing interface name or sw_if_index");
13422 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13424 mp->spd_id = ntohl (spd_id);
13425 mp->sw_if_index = ntohl (sw_if_index);
13426 mp->is_add = is_add;
13434 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13436 unformat_input_t *i = vam->input;
13437 vl_api_ipsec_spd_entry_add_del_t *mp;
13438 u8 is_add = 1, is_outbound = 0;
13439 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13441 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13442 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13443 vl_api_address_t laddr_start = { }, laddr_stop =
13452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13454 if (unformat (i, "del"))
13456 if (unformat (i, "outbound"))
13458 if (unformat (i, "inbound"))
13460 else if (unformat (i, "spd_id %d", &spd_id))
13462 else if (unformat (i, "sa_id %d", &sa_id))
13464 else if (unformat (i, "priority %d", &priority))
13466 else if (unformat (i, "protocol %d", &protocol))
13468 else if (unformat (i, "lport_start %d", &lport_start))
13470 else if (unformat (i, "lport_stop %d", &lport_stop))
13472 else if (unformat (i, "rport_start %d", &rport_start))
13474 else if (unformat (i, "rport_stop %d", &rport_stop))
13476 else if (unformat (i, "laddr_start %U",
13477 unformat_vl_api_address, &laddr_start))
13479 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13482 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13485 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13489 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13491 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13493 clib_warning ("unsupported action: 'resolve'");
13499 clib_warning ("parse error '%U'", format_unformat_error, i);
13505 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13507 mp->is_add = is_add;
13509 mp->entry.spd_id = ntohl (spd_id);
13510 mp->entry.priority = ntohl (priority);
13511 mp->entry.is_outbound = is_outbound;
13513 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13514 sizeof (vl_api_address_t));
13515 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13516 sizeof (vl_api_address_t));
13517 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13518 sizeof (vl_api_address_t));
13519 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13520 sizeof (vl_api_address_t));
13522 mp->entry.protocol = (u8) protocol;
13523 mp->entry.local_port_start = ntohs ((u16) lport_start);
13524 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13525 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13526 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13527 mp->entry.policy = (u8) policy;
13528 mp->entry.sa_id = ntohl (sa_id);
13536 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13538 unformat_input_t *i = vam->input;
13539 vl_api_ipsec_sad_entry_add_del_t *mp;
13540 u32 sad_id = 0, spi = 0;
13541 u8 *ck = 0, *ik = 0;
13544 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13545 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13546 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13547 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13548 vl_api_address_t tun_src, tun_dst;
13551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13553 if (unformat (i, "del"))
13555 else if (unformat (i, "sad_id %d", &sad_id))
13557 else if (unformat (i, "spi %d", &spi))
13559 else if (unformat (i, "esp"))
13560 protocol = IPSEC_API_PROTO_ESP;
13562 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13564 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13565 if (ADDRESS_IP6 == tun_src.af)
13566 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13569 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13571 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13572 if (ADDRESS_IP6 == tun_src.af)
13573 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13576 if (unformat (i, "crypto_alg %U",
13577 unformat_ipsec_api_crypto_alg, &crypto_alg))
13579 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13581 else if (unformat (i, "integ_alg %U",
13582 unformat_ipsec_api_integ_alg, &integ_alg))
13584 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13588 clib_warning ("parse error '%U'", format_unformat_error, i);
13594 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13596 mp->is_add = is_add;
13597 mp->entry.sad_id = ntohl (sad_id);
13598 mp->entry.protocol = protocol;
13599 mp->entry.spi = ntohl (spi);
13600 mp->entry.flags = flags;
13602 mp->entry.crypto_algorithm = crypto_alg;
13603 mp->entry.integrity_algorithm = integ_alg;
13604 mp->entry.crypto_key.length = vec_len (ck);
13605 mp->entry.integrity_key.length = vec_len (ik);
13607 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13608 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13610 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13611 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13614 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13616 clib_memcpy (mp->entry.integrity_key.data, ik,
13617 mp->entry.integrity_key.length);
13619 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13621 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13622 sizeof (mp->entry.tunnel_src));
13623 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13624 sizeof (mp->entry.tunnel_dst));
13633 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13635 unformat_input_t *i = vam->input;
13636 vl_api_ipsec_tunnel_if_add_del_t *mp;
13637 u32 local_spi = 0, remote_spi = 0;
13638 u32 crypto_alg = 0, integ_alg = 0;
13639 u8 *lck = NULL, *rck = NULL;
13640 u8 *lik = NULL, *rik = NULL;
13641 vl_api_address_t local_ip = { 0 };
13642 vl_api_address_t remote_ip = { 0 };
13646 u8 anti_replay = 0;
13652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13654 if (unformat (i, "del"))
13656 else if (unformat (i, "esn"))
13658 else if (unformat (i, "anti-replay"))
13660 else if (unformat (i, "count %d", &count))
13662 else if (unformat (i, "local_spi %d", &local_spi))
13664 else if (unformat (i, "remote_spi %d", &remote_spi))
13667 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13670 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13672 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13675 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13677 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13679 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13683 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13685 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13687 errmsg ("unsupported crypto-alg: '%U'\n",
13688 format_ipsec_crypto_alg, crypto_alg);
13694 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13696 if (integ_alg >= IPSEC_INTEG_N_ALG)
13698 errmsg ("unsupported integ-alg: '%U'\n",
13699 format_ipsec_integ_alg, integ_alg);
13703 else if (unformat (i, "instance %u", &instance))
13707 errmsg ("parse error '%U'\n", format_unformat_error, i);
13714 /* Turn on async mode */
13715 vam->async_mode = 1;
13716 vam->async_errors = 0;
13717 before = vat_time_now (vam);
13720 for (jj = 0; jj < count; jj++)
13722 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13724 mp->is_add = is_add;
13726 mp->anti_replay = anti_replay;
13729 increment_address (&remote_ip);
13731 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13732 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13734 mp->local_spi = htonl (local_spi + jj);
13735 mp->remote_spi = htonl (remote_spi + jj);
13736 mp->crypto_alg = (u8) crypto_alg;
13738 mp->local_crypto_key_len = 0;
13741 mp->local_crypto_key_len = vec_len (lck);
13742 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13743 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13744 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13747 mp->remote_crypto_key_len = 0;
13750 mp->remote_crypto_key_len = vec_len (rck);
13751 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13752 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13753 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13756 mp->integ_alg = (u8) integ_alg;
13758 mp->local_integ_key_len = 0;
13761 mp->local_integ_key_len = vec_len (lik);
13762 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13763 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13764 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13767 mp->remote_integ_key_len = 0;
13770 mp->remote_integ_key_len = vec_len (rik);
13771 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13772 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13773 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13778 mp->renumber = renumber;
13779 mp->show_instance = ntohl (instance);
13784 /* When testing multiple add/del ops, use a control-ping to sync */
13787 vl_api_control_ping_t *mp_ping;
13791 /* Shut off async mode */
13792 vam->async_mode = 0;
13794 MPING (CONTROL_PING, mp_ping);
13797 timeout = vat_time_now (vam) + 1.0;
13798 while (vat_time_now (vam) < timeout)
13799 if (vam->result_ready == 1)
13804 if (vam->retval == -99)
13805 errmsg ("timeout");
13807 if (vam->async_errors > 0)
13809 errmsg ("%d asynchronous errors", vam->async_errors);
13812 vam->async_errors = 0;
13813 after = vat_time_now (vam);
13815 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13819 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13820 count, after - before, count / (after - before));
13824 /* Wait for a reply... */
13833 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13835 vat_main_t *vam = &vat_main;
13837 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13838 "crypto_key %U integ_alg %u integ_key %U flags %x "
13839 "tunnel_src_addr %U tunnel_dst_addr %U "
13840 "salt %u seq_outbound %lu last_seq_inbound %lu "
13841 "replay_window %lu stat_index %u\n",
13842 ntohl (mp->entry.sad_id),
13843 ntohl (mp->sw_if_index),
13844 ntohl (mp->entry.spi),
13845 ntohl (mp->entry.protocol),
13846 ntohl (mp->entry.crypto_algorithm),
13847 format_hex_bytes, mp->entry.crypto_key.data,
13848 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13849 format_hex_bytes, mp->entry.integrity_key.data,
13850 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13851 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13852 &mp->entry.tunnel_dst, ntohl (mp->salt),
13853 clib_net_to_host_u64 (mp->seq_outbound),
13854 clib_net_to_host_u64 (mp->last_seq_inbound),
13855 clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
13858 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13859 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13861 static void vl_api_ipsec_sa_details_t_handler_json
13862 (vl_api_ipsec_sa_details_t * mp)
13864 vat_main_t *vam = &vat_main;
13865 vat_json_node_t *node = NULL;
13866 vl_api_ipsec_sad_flags_t flags;
13868 if (VAT_JSON_ARRAY != vam->json_tree.type)
13870 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13871 vat_json_init_array (&vam->json_tree);
13873 node = vat_json_array_add (&vam->json_tree);
13875 vat_json_init_object (node);
13876 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13877 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13878 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13879 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13880 vat_json_object_add_uint (node, "crypto_alg",
13881 ntohl (mp->entry.crypto_algorithm));
13882 vat_json_object_add_uint (node, "integ_alg",
13883 ntohl (mp->entry.integrity_algorithm));
13884 flags = ntohl (mp->entry.flags);
13885 vat_json_object_add_uint (node, "use_esn",
13886 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13887 vat_json_object_add_uint (node, "use_anti_replay",
13888 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13889 vat_json_object_add_uint (node, "is_tunnel",
13890 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13891 vat_json_object_add_uint (node, "is_tunnel_ip6",
13892 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13893 vat_json_object_add_uint (node, "udp_encap",
13894 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13895 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13896 mp->entry.crypto_key.length);
13897 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13898 mp->entry.integrity_key.length);
13899 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13900 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13901 vat_json_object_add_uint (node, "replay_window",
13902 clib_net_to_host_u64 (mp->replay_window));
13903 vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
13907 api_ipsec_sa_dump (vat_main_t * vam)
13909 unformat_input_t *i = vam->input;
13910 vl_api_ipsec_sa_dump_t *mp;
13911 vl_api_control_ping_t *mp_ping;
13915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13917 if (unformat (i, "sa_id %d", &sa_id))
13921 clib_warning ("parse error '%U'", format_unformat_error, i);
13926 M (IPSEC_SA_DUMP, mp);
13928 mp->sa_id = ntohl (sa_id);
13932 /* Use a control ping for synchronization */
13933 M (CONTROL_PING, mp_ping);
13941 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13943 unformat_input_t *i = vam->input;
13944 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13945 u32 sw_if_index = ~0;
13947 u8 is_outbound = (u8) ~ 0;
13950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13952 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13954 else if (unformat (i, "sa_id %d", &sa_id))
13956 else if (unformat (i, "outbound"))
13958 else if (unformat (i, "inbound"))
13962 clib_warning ("parse error '%U'", format_unformat_error, i);
13967 if (sw_if_index == ~0)
13969 errmsg ("interface must be specified");
13975 errmsg ("SA ID must be specified");
13979 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13981 mp->sw_if_index = htonl (sw_if_index);
13982 mp->sa_id = htonl (sa_id);
13983 mp->is_outbound = is_outbound;
13992 api_get_first_msg_id (vat_main_t * vam)
13994 vl_api_get_first_msg_id_t *mp;
13995 unformat_input_t *i = vam->input;
14000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14002 if (unformat (i, "client %s", &name))
14010 errmsg ("missing client name");
14013 vec_add1 (name, 0);
14015 if (vec_len (name) > 63)
14017 errmsg ("client name too long");
14021 M (GET_FIRST_MSG_ID, mp);
14022 clib_memcpy (mp->name, name, vec_len (name));
14029 api_cop_interface_enable_disable (vat_main_t * vam)
14031 unformat_input_t *line_input = vam->input;
14032 vl_api_cop_interface_enable_disable_t *mp;
14033 u32 sw_if_index = ~0;
14034 u8 enable_disable = 1;
14037 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14039 if (unformat (line_input, "disable"))
14040 enable_disable = 0;
14041 if (unformat (line_input, "enable"))
14042 enable_disable = 1;
14043 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14044 vam, &sw_if_index))
14046 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14052 if (sw_if_index == ~0)
14054 errmsg ("missing interface name or sw_if_index");
14058 /* Construct the API message */
14059 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14060 mp->sw_if_index = ntohl (sw_if_index);
14061 mp->enable_disable = enable_disable;
14065 /* Wait for the reply */
14071 api_cop_whitelist_enable_disable (vat_main_t * vam)
14073 unformat_input_t *line_input = vam->input;
14074 vl_api_cop_whitelist_enable_disable_t *mp;
14075 u32 sw_if_index = ~0;
14076 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14080 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14082 if (unformat (line_input, "ip4"))
14084 else if (unformat (line_input, "ip6"))
14086 else if (unformat (line_input, "default"))
14088 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14089 vam, &sw_if_index))
14091 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14093 else if (unformat (line_input, "fib-id %d", &fib_id))
14099 if (sw_if_index == ~0)
14101 errmsg ("missing interface name or sw_if_index");
14105 /* Construct the API message */
14106 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14107 mp->sw_if_index = ntohl (sw_if_index);
14108 mp->fib_id = ntohl (fib_id);
14111 mp->default_cop = default_cop;
14115 /* Wait for the reply */
14121 api_get_node_graph (vat_main_t * vam)
14123 vl_api_get_node_graph_t *mp;
14126 M (GET_NODE_GRAPH, mp);
14130 /* Wait for the reply */
14136 /** Used for parsing LISP eids */
14137 typedef CLIB_PACKED(struct{
14141 lisp_nsh_api_t nsh;
14143 u32 len; /**< prefix length if IP */
14144 u8 type; /**< type of eid */
14149 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14151 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14153 clib_memset (a, 0, sizeof (a[0]));
14155 if (unformat (input, "%U/%d", unformat_ip46_address, a->addr.ip, &a->len))
14157 a->type = 0; /* ip prefix type */
14159 else if (unformat (input, "%U", unformat_ethernet_address, a->addr.mac))
14161 a->type = 1; /* mac type */
14163 else if (unformat (input, "%U", unformat_nsh_address, a->addr.nsh))
14165 a->type = 2; /* NSH type */
14166 a->addr.nsh.spi = clib_host_to_net_u32 (a->addr.nsh.spi);
14175 if (ip46_address_is_ip4 (&a->addr.ip))
14176 return a->len > 32 ? 1 : 0;
14178 return a->len > 128 ? 1 : 0;
14185 lisp_eid_put_vat (vl_api_eid_t * eid, const lisp_eid_vat_t * vat_eid)
14187 eid->type = vat_eid->type;
14190 case EID_TYPE_API_PREFIX:
14191 if (ip46_address_is_ip4 (&vat_eid->addr.ip))
14193 clib_memcpy (&eid->address.prefix.address.un.ip4,
14194 &vat_eid->addr.ip.ip4, 4);
14195 eid->address.prefix.address.af = ADDRESS_IP4;
14196 eid->address.prefix.len = vat_eid->len;
14200 clib_memcpy (&eid->address.prefix.address.un.ip6,
14201 &vat_eid->addr.ip.ip6, 16);
14202 eid->address.prefix.address.af = ADDRESS_IP6;
14203 eid->address.prefix.len = vat_eid->len;
14206 case EID_TYPE_API_MAC:
14207 clib_memcpy (&eid->address.mac, &vat_eid->addr.mac,
14208 sizeof (eid->address.mac));
14210 case EID_TYPE_API_NSH:
14211 clib_memcpy (&eid->address.nsh, &vat_eid->addr.nsh,
14212 sizeof (eid->address.nsh));
14221 api_one_add_del_locator_set (vat_main_t * vam)
14223 unformat_input_t *input = vam->input;
14224 vl_api_one_add_del_locator_set_t *mp;
14226 u8 *locator_set_name = NULL;
14227 u8 locator_set_name_set = 0;
14228 vl_api_local_locator_t locator, *locators = 0;
14229 u32 sw_if_index, priority, weight;
14233 /* Parse args required to build the message */
14234 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14236 if (unformat (input, "del"))
14240 else if (unformat (input, "locator-set %s", &locator_set_name))
14242 locator_set_name_set = 1;
14244 else if (unformat (input, "sw_if_index %u p %u w %u",
14245 &sw_if_index, &priority, &weight))
14247 locator.sw_if_index = htonl (sw_if_index);
14248 locator.priority = priority;
14249 locator.weight = weight;
14250 vec_add1 (locators, locator);
14254 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14255 &sw_if_index, &priority, &weight))
14257 locator.sw_if_index = htonl (sw_if_index);
14258 locator.priority = priority;
14259 locator.weight = weight;
14260 vec_add1 (locators, locator);
14266 if (locator_set_name_set == 0)
14268 errmsg ("missing locator-set name");
14269 vec_free (locators);
14273 if (vec_len (locator_set_name) > 64)
14275 errmsg ("locator-set name too long");
14276 vec_free (locator_set_name);
14277 vec_free (locators);
14280 vec_add1 (locator_set_name, 0);
14282 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14284 /* Construct the API message */
14285 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14287 mp->is_add = is_add;
14288 clib_memcpy (mp->locator_set_name, locator_set_name,
14289 vec_len (locator_set_name));
14290 vec_free (locator_set_name);
14292 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14294 clib_memcpy (mp->locators, locators, data_len);
14295 vec_free (locators);
14300 /* Wait for a reply... */
14305 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14308 api_one_add_del_locator (vat_main_t * vam)
14310 unformat_input_t *input = vam->input;
14311 vl_api_one_add_del_locator_t *mp;
14312 u32 tmp_if_index = ~0;
14313 u32 sw_if_index = ~0;
14314 u8 sw_if_index_set = 0;
14315 u8 sw_if_index_if_name_set = 0;
14317 u8 priority_set = 0;
14321 u8 *locator_set_name = NULL;
14322 u8 locator_set_name_set = 0;
14325 /* Parse args required to build the message */
14326 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14328 if (unformat (input, "del"))
14332 else if (unformat (input, "locator-set %s", &locator_set_name))
14334 locator_set_name_set = 1;
14336 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14339 sw_if_index_if_name_set = 1;
14340 sw_if_index = tmp_if_index;
14342 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14344 sw_if_index_set = 1;
14345 sw_if_index = tmp_if_index;
14347 else if (unformat (input, "p %d", &priority))
14351 else if (unformat (input, "w %d", &weight))
14359 if (locator_set_name_set == 0)
14361 errmsg ("missing locator-set name");
14365 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14367 errmsg ("missing sw_if_index");
14368 vec_free (locator_set_name);
14372 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14374 errmsg ("cannot use both params interface name and sw_if_index");
14375 vec_free (locator_set_name);
14379 if (priority_set == 0)
14381 errmsg ("missing locator-set priority");
14382 vec_free (locator_set_name);
14386 if (weight_set == 0)
14388 errmsg ("missing locator-set weight");
14389 vec_free (locator_set_name);
14393 if (vec_len (locator_set_name) > 64)
14395 errmsg ("locator-set name too long");
14396 vec_free (locator_set_name);
14399 vec_add1 (locator_set_name, 0);
14401 /* Construct the API message */
14402 M (ONE_ADD_DEL_LOCATOR, mp);
14404 mp->is_add = is_add;
14405 mp->sw_if_index = ntohl (sw_if_index);
14406 mp->priority = priority;
14407 mp->weight = weight;
14408 clib_memcpy (mp->locator_set_name, locator_set_name,
14409 vec_len (locator_set_name));
14410 vec_free (locator_set_name);
14415 /* Wait for a reply... */
14420 #define api_lisp_add_del_locator api_one_add_del_locator
14423 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14425 u32 *key_id = va_arg (*args, u32 *);
14428 if (unformat (input, "%s", &s))
14430 if (!strcmp ((char *) s, "sha1"))
14431 key_id[0] = HMAC_SHA_1_96;
14432 else if (!strcmp ((char *) s, "sha256"))
14433 key_id[0] = HMAC_SHA_256_128;
14436 clib_warning ("invalid key_id: '%s'", s);
14437 key_id[0] = HMAC_NO_KEY;
14448 api_one_add_del_local_eid (vat_main_t * vam)
14450 unformat_input_t *input = vam->input;
14451 vl_api_one_add_del_local_eid_t *mp;
14454 lisp_eid_vat_t _eid, *eid = &_eid;
14455 u8 *locator_set_name = 0;
14456 u8 locator_set_name_set = 0;
14462 /* Parse args required to build the message */
14463 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14465 if (unformat (input, "del"))
14469 else if (unformat (input, "vni %d", &vni))
14473 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14477 else if (unformat (input, "locator-set %s", &locator_set_name))
14479 locator_set_name_set = 1;
14481 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14483 else if (unformat (input, "secret-key %_%v%_", &key))
14489 if (locator_set_name_set == 0)
14491 errmsg ("missing locator-set name");
14497 errmsg ("EID address not set!");
14498 vec_free (locator_set_name);
14502 if (key && (0 == key_id))
14504 errmsg ("invalid key_id!");
14508 if (vec_len (key) > 64)
14510 errmsg ("key too long");
14515 if (vec_len (locator_set_name) > 64)
14517 errmsg ("locator-set name too long");
14518 vec_free (locator_set_name);
14521 vec_add1 (locator_set_name, 0);
14523 /* Construct the API message */
14524 M (ONE_ADD_DEL_LOCAL_EID, mp);
14526 mp->is_add = is_add;
14527 lisp_eid_put_vat (&mp->eid, eid);
14528 mp->vni = clib_host_to_net_u32 (vni);
14529 mp->key.id = key_id;
14530 clib_memcpy (mp->locator_set_name, locator_set_name,
14531 vec_len (locator_set_name));
14532 clib_memcpy (mp->key.key, key, vec_len (key));
14534 vec_free (locator_set_name);
14540 /* Wait for a reply... */
14545 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14548 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14550 u32 dp_table = 0, vni = 0;;
14551 unformat_input_t *input = vam->input;
14552 vl_api_gpe_add_del_fwd_entry_t *mp;
14554 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14555 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14556 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14557 u32 action = ~0, w;
14558 ip4_address_t rmt_rloc4, lcl_rloc4;
14559 ip6_address_t rmt_rloc6, lcl_rloc6;
14560 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14563 clib_memset (&rloc, 0, sizeof (rloc));
14565 /* Parse args required to build the message */
14566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14568 if (unformat (input, "del"))
14570 else if (unformat (input, "add"))
14572 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14576 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14580 else if (unformat (input, "vrf %d", &dp_table))
14582 else if (unformat (input, "bd %d", &dp_table))
14584 else if (unformat (input, "vni %d", &vni))
14586 else if (unformat (input, "w %d", &w))
14590 errmsg ("No RLOC configured for setting priority/weight!");
14593 curr_rloc->weight = w;
14595 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14596 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14599 clib_memcpy (&rloc.addr.un.ip4, &lcl_rloc4, sizeof (lcl_rloc4));
14601 vec_add1 (lcl_locs, rloc);
14603 clib_memcpy (&rloc.addr.un.ip4, &rmt_rloc4, sizeof (rmt_rloc4));
14604 vec_add1 (rmt_locs, rloc);
14605 /* weight saved in rmt loc */
14606 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14608 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14609 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14612 clib_memcpy (&rloc.addr.un.ip6, &lcl_rloc6, sizeof (lcl_rloc6));
14614 vec_add1 (lcl_locs, rloc);
14616 clib_memcpy (&rloc.addr.un.ip6, &rmt_rloc6, sizeof (rmt_rloc6));
14617 vec_add1 (rmt_locs, rloc);
14618 /* weight saved in rmt loc */
14619 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14621 else if (unformat (input, "action %d", &action))
14627 clib_warning ("parse error '%U'", format_unformat_error, input);
14634 errmsg ("remote eid addresses not set");
14638 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14640 errmsg ("eid types don't match");
14644 if (0 == rmt_locs && (u32) ~ 0 == action)
14646 errmsg ("action not set for negative mapping");
14650 /* Construct the API message */
14651 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14652 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14654 mp->is_add = is_add;
14655 lisp_eid_put_vat (&mp->rmt_eid, rmt_eid);
14656 lisp_eid_put_vat (&mp->lcl_eid, lcl_eid);
14657 mp->dp_table = clib_host_to_net_u32 (dp_table);
14658 mp->vni = clib_host_to_net_u32 (vni);
14659 mp->action = action;
14661 if (0 != rmt_locs && 0 != lcl_locs)
14663 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14664 clib_memcpy (mp->locs, lcl_locs,
14665 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14667 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14668 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14669 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14671 vec_free (lcl_locs);
14672 vec_free (rmt_locs);
14677 /* Wait for a reply... */
14683 api_one_add_del_map_server (vat_main_t * vam)
14685 unformat_input_t *input = vam->input;
14686 vl_api_one_add_del_map_server_t *mp;
14690 ip4_address_t ipv4;
14691 ip6_address_t ipv6;
14694 /* Parse args required to build the message */
14695 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14697 if (unformat (input, "del"))
14701 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14705 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14713 if (ipv4_set && ipv6_set)
14715 errmsg ("both eid v4 and v6 addresses set");
14719 if (!ipv4_set && !ipv6_set)
14721 errmsg ("eid addresses not set");
14725 /* Construct the API message */
14726 M (ONE_ADD_DEL_MAP_SERVER, mp);
14728 mp->is_add = is_add;
14731 mp->ip_address.af = 1;
14732 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14736 mp->ip_address.af = 0;
14737 clib_memcpy (mp->ip_address.un.ip4, &ipv4, sizeof (ipv4));
14743 /* Wait for a reply... */
14748 #define api_lisp_add_del_map_server api_one_add_del_map_server
14751 api_one_add_del_map_resolver (vat_main_t * vam)
14753 unformat_input_t *input = vam->input;
14754 vl_api_one_add_del_map_resolver_t *mp;
14758 ip4_address_t ipv4;
14759 ip6_address_t ipv6;
14762 /* Parse args required to build the message */
14763 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14765 if (unformat (input, "del"))
14769 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14773 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14781 if (ipv4_set && ipv6_set)
14783 errmsg ("both eid v4 and v6 addresses set");
14787 if (!ipv4_set && !ipv6_set)
14789 errmsg ("eid addresses not set");
14793 /* Construct the API message */
14794 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14796 mp->is_add = is_add;
14799 mp->ip_address.af = 1;
14800 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14804 mp->ip_address.af = 0;
14805 clib_memcpy (mp->ip_address.un.ip6, &ipv4, sizeof (ipv4));
14811 /* Wait for a reply... */
14816 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14819 api_lisp_gpe_enable_disable (vat_main_t * vam)
14821 unformat_input_t *input = vam->input;
14822 vl_api_gpe_enable_disable_t *mp;
14827 /* Parse args required to build the message */
14828 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14830 if (unformat (input, "enable"))
14835 else if (unformat (input, "disable"))
14846 errmsg ("Value not set");
14850 /* Construct the API message */
14851 M (GPE_ENABLE_DISABLE, mp);
14853 mp->is_enable = is_enable;
14858 /* Wait for a reply... */
14864 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14866 unformat_input_t *input = vam->input;
14867 vl_api_one_rloc_probe_enable_disable_t *mp;
14872 /* Parse args required to build the message */
14873 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14875 if (unformat (input, "enable"))
14880 else if (unformat (input, "disable"))
14888 errmsg ("Value not set");
14892 /* Construct the API message */
14893 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14895 mp->is_enable = is_enable;
14900 /* Wait for a reply... */
14905 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14908 api_one_map_register_enable_disable (vat_main_t * vam)
14910 unformat_input_t *input = vam->input;
14911 vl_api_one_map_register_enable_disable_t *mp;
14916 /* Parse args required to build the message */
14917 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14919 if (unformat (input, "enable"))
14924 else if (unformat (input, "disable"))
14932 errmsg ("Value not set");
14936 /* Construct the API message */
14937 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14939 mp->is_enable = is_enable;
14944 /* Wait for a reply... */
14949 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14952 api_one_enable_disable (vat_main_t * vam)
14954 unformat_input_t *input = vam->input;
14955 vl_api_one_enable_disable_t *mp;
14960 /* Parse args required to build the message */
14961 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14963 if (unformat (input, "enable"))
14968 else if (unformat (input, "disable"))
14978 errmsg ("Value not set");
14982 /* Construct the API message */
14983 M (ONE_ENABLE_DISABLE, mp);
14985 mp->is_enable = is_enable;
14990 /* Wait for a reply... */
14995 #define api_lisp_enable_disable api_one_enable_disable
14998 api_one_enable_disable_xtr_mode (vat_main_t * vam)
15000 unformat_input_t *input = vam->input;
15001 vl_api_one_enable_disable_xtr_mode_t *mp;
15006 /* Parse args required to build the message */
15007 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15009 if (unformat (input, "enable"))
15014 else if (unformat (input, "disable"))
15024 errmsg ("Value not set");
15028 /* Construct the API message */
15029 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15031 mp->is_enable = is_enable;
15036 /* Wait for a reply... */
15042 api_one_show_xtr_mode (vat_main_t * vam)
15044 vl_api_one_show_xtr_mode_t *mp;
15047 /* Construct the API message */
15048 M (ONE_SHOW_XTR_MODE, mp);
15053 /* Wait for a reply... */
15059 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15061 unformat_input_t *input = vam->input;
15062 vl_api_one_enable_disable_pitr_mode_t *mp;
15067 /* Parse args required to build the message */
15068 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15070 if (unformat (input, "enable"))
15075 else if (unformat (input, "disable"))
15085 errmsg ("Value not set");
15089 /* Construct the API message */
15090 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15092 mp->is_enable = is_enable;
15097 /* Wait for a reply... */
15103 api_one_show_pitr_mode (vat_main_t * vam)
15105 vl_api_one_show_pitr_mode_t *mp;
15108 /* Construct the API message */
15109 M (ONE_SHOW_PITR_MODE, mp);
15114 /* Wait for a reply... */
15120 api_one_enable_disable_petr_mode (vat_main_t * vam)
15122 unformat_input_t *input = vam->input;
15123 vl_api_one_enable_disable_petr_mode_t *mp;
15128 /* Parse args required to build the message */
15129 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15131 if (unformat (input, "enable"))
15136 else if (unformat (input, "disable"))
15146 errmsg ("Value not set");
15150 /* Construct the API message */
15151 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15153 mp->is_enable = is_enable;
15158 /* Wait for a reply... */
15164 api_one_show_petr_mode (vat_main_t * vam)
15166 vl_api_one_show_petr_mode_t *mp;
15169 /* Construct the API message */
15170 M (ONE_SHOW_PETR_MODE, mp);
15175 /* Wait for a reply... */
15181 api_show_one_map_register_state (vat_main_t * vam)
15183 vl_api_show_one_map_register_state_t *mp;
15186 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15191 /* wait for reply */
15196 #define api_show_lisp_map_register_state api_show_one_map_register_state
15199 api_show_one_rloc_probe_state (vat_main_t * vam)
15201 vl_api_show_one_rloc_probe_state_t *mp;
15204 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15209 /* wait for reply */
15214 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15217 api_one_add_del_ndp_entry (vat_main_t * vam)
15219 vl_api_one_add_del_ndp_entry_t *mp;
15220 unformat_input_t *input = vam->input;
15225 u8 mac[6] = { 0, };
15226 u8 ip6[16] = { 0, };
15230 /* Parse args required to build the message */
15231 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15233 if (unformat (input, "del"))
15235 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15237 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15239 else if (unformat (input, "bd %d", &bd))
15243 errmsg ("parse error '%U'", format_unformat_error, input);
15248 if (!bd_set || !ip_set || (!mac_set && is_add))
15250 errmsg ("Missing BD, IP or MAC!");
15254 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15255 mp->is_add = is_add;
15256 clib_memcpy (&mp->entry.mac, mac, 6);
15257 mp->bd = clib_host_to_net_u32 (bd);
15258 clib_memcpy (&mp->entry.ip6, ip6, sizeof (mp->entry.ip6));
15263 /* wait for reply */
15269 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15271 vl_api_one_add_del_l2_arp_entry_t *mp;
15272 unformat_input_t *input = vam->input;
15277 u8 mac[6] = { 0, };
15278 u32 ip4 = 0, bd = ~0;
15281 /* Parse args required to build the message */
15282 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15284 if (unformat (input, "del"))
15286 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15288 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15290 else if (unformat (input, "bd %d", &bd))
15294 errmsg ("parse error '%U'", format_unformat_error, input);
15299 if (!bd_set || !ip_set || (!mac_set && is_add))
15301 errmsg ("Missing BD, IP or MAC!");
15305 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15306 mp->is_add = is_add;
15307 clib_memcpy (&mp->entry.mac, mac, 6);
15308 mp->bd = clib_host_to_net_u32 (bd);
15309 clib_memcpy (mp->entry.ip4, &ip4, sizeof (mp->entry.ip4));
15314 /* wait for reply */
15320 api_one_ndp_bd_get (vat_main_t * vam)
15322 vl_api_one_ndp_bd_get_t *mp;
15325 M (ONE_NDP_BD_GET, mp);
15330 /* wait for reply */
15336 api_one_ndp_entries_get (vat_main_t * vam)
15338 vl_api_one_ndp_entries_get_t *mp;
15339 unformat_input_t *input = vam->input;
15344 /* Parse args required to build the message */
15345 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15347 if (unformat (input, "bd %d", &bd))
15351 errmsg ("parse error '%U'", format_unformat_error, input);
15358 errmsg ("Expected bridge domain!");
15362 M (ONE_NDP_ENTRIES_GET, mp);
15363 mp->bd = clib_host_to_net_u32 (bd);
15368 /* wait for reply */
15374 api_one_l2_arp_bd_get (vat_main_t * vam)
15376 vl_api_one_l2_arp_bd_get_t *mp;
15379 M (ONE_L2_ARP_BD_GET, mp);
15384 /* wait for reply */
15390 api_one_l2_arp_entries_get (vat_main_t * vam)
15392 vl_api_one_l2_arp_entries_get_t *mp;
15393 unformat_input_t *input = vam->input;
15398 /* Parse args required to build the message */
15399 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15401 if (unformat (input, "bd %d", &bd))
15405 errmsg ("parse error '%U'", format_unformat_error, input);
15412 errmsg ("Expected bridge domain!");
15416 M (ONE_L2_ARP_ENTRIES_GET, mp);
15417 mp->bd = clib_host_to_net_u32 (bd);
15422 /* wait for reply */
15428 api_one_stats_enable_disable (vat_main_t * vam)
15430 vl_api_one_stats_enable_disable_t *mp;
15431 unformat_input_t *input = vam->input;
15436 /* Parse args required to build the message */
15437 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15439 if (unformat (input, "enable"))
15444 else if (unformat (input, "disable"))
15454 errmsg ("Value not set");
15458 M (ONE_STATS_ENABLE_DISABLE, mp);
15459 mp->is_enable = is_enable;
15464 /* wait for reply */
15470 api_show_one_stats_enable_disable (vat_main_t * vam)
15472 vl_api_show_one_stats_enable_disable_t *mp;
15475 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15480 /* wait for reply */
15486 api_show_one_map_request_mode (vat_main_t * vam)
15488 vl_api_show_one_map_request_mode_t *mp;
15491 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15496 /* wait for reply */
15501 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15504 api_one_map_request_mode (vat_main_t * vam)
15506 unformat_input_t *input = vam->input;
15507 vl_api_one_map_request_mode_t *mp;
15511 /* Parse args required to build the message */
15512 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15514 if (unformat (input, "dst-only"))
15516 else if (unformat (input, "src-dst"))
15520 errmsg ("parse error '%U'", format_unformat_error, input);
15525 M (ONE_MAP_REQUEST_MODE, mp);
15532 /* wait for reply */
15537 #define api_lisp_map_request_mode api_one_map_request_mode
15540 * Enable/disable ONE proxy ITR.
15542 * @param vam vpp API test context
15543 * @return return code
15546 api_one_pitr_set_locator_set (vat_main_t * vam)
15548 u8 ls_name_set = 0;
15549 unformat_input_t *input = vam->input;
15550 vl_api_one_pitr_set_locator_set_t *mp;
15555 /* Parse args required to build the message */
15556 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15558 if (unformat (input, "del"))
15560 else if (unformat (input, "locator-set %s", &ls_name))
15564 errmsg ("parse error '%U'", format_unformat_error, input);
15571 errmsg ("locator-set name not set!");
15575 M (ONE_PITR_SET_LOCATOR_SET, mp);
15577 mp->is_add = is_add;
15578 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15579 vec_free (ls_name);
15584 /* wait for reply */
15589 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15592 api_one_nsh_set_locator_set (vat_main_t * vam)
15594 u8 ls_name_set = 0;
15595 unformat_input_t *input = vam->input;
15596 vl_api_one_nsh_set_locator_set_t *mp;
15601 /* Parse args required to build the message */
15602 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15604 if (unformat (input, "del"))
15606 else if (unformat (input, "ls %s", &ls_name))
15610 errmsg ("parse error '%U'", format_unformat_error, input);
15615 if (!ls_name_set && is_add)
15617 errmsg ("locator-set name not set!");
15621 M (ONE_NSH_SET_LOCATOR_SET, mp);
15623 mp->is_add = is_add;
15624 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15625 vec_free (ls_name);
15630 /* wait for reply */
15636 api_show_one_pitr (vat_main_t * vam)
15638 vl_api_show_one_pitr_t *mp;
15641 if (!vam->json_output)
15643 print (vam->ofp, "%=20s", "lisp status:");
15646 M (SHOW_ONE_PITR, mp);
15650 /* Wait for a reply... */
15655 #define api_show_lisp_pitr api_show_one_pitr
15658 api_one_use_petr (vat_main_t * vam)
15660 unformat_input_t *input = vam->input;
15661 vl_api_one_use_petr_t *mp;
15666 clib_memset (&ip, 0, sizeof (ip));
15668 /* Parse args required to build the message */
15669 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15671 if (unformat (input, "disable"))
15674 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15677 ip_addr_version (&ip) = AF_IP4;
15680 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15683 ip_addr_version (&ip) = AF_IP6;
15687 errmsg ("parse error '%U'", format_unformat_error, input);
15692 M (ONE_USE_PETR, mp);
15694 mp->is_add = is_add;
15697 mp->ip_address.af = ip_addr_version (&ip) == AF_IP4 ? 0 : 1;
15698 if (mp->ip_address.af)
15699 clib_memcpy (mp->ip_address.un.ip6, &ip, 16);
15701 clib_memcpy (mp->ip_address.un.ip4, &ip, 4);
15707 /* wait for reply */
15712 #define api_lisp_use_petr api_one_use_petr
15715 api_show_one_nsh_mapping (vat_main_t * vam)
15717 vl_api_show_one_use_petr_t *mp;
15720 if (!vam->json_output)
15722 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15725 M (SHOW_ONE_NSH_MAPPING, mp);
15729 /* Wait for a reply... */
15735 api_show_one_use_petr (vat_main_t * vam)
15737 vl_api_show_one_use_petr_t *mp;
15740 if (!vam->json_output)
15742 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15745 M (SHOW_ONE_USE_PETR, mp);
15749 /* Wait for a reply... */
15754 #define api_show_lisp_use_petr api_show_one_use_petr
15757 * Add/delete mapping between vni and vrf
15760 api_one_eid_table_add_del_map (vat_main_t * vam)
15762 unformat_input_t *input = vam->input;
15763 vl_api_one_eid_table_add_del_map_t *mp;
15764 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15765 u32 vni, vrf, bd_index;
15768 /* Parse args required to build the message */
15769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15771 if (unformat (input, "del"))
15773 else if (unformat (input, "vrf %d", &vrf))
15775 else if (unformat (input, "bd_index %d", &bd_index))
15777 else if (unformat (input, "vni %d", &vni))
15783 if (!vni_set || (!vrf_set && !bd_index_set))
15785 errmsg ("missing arguments!");
15789 if (vrf_set && bd_index_set)
15791 errmsg ("error: both vrf and bd entered!");
15795 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15797 mp->is_add = is_add;
15798 mp->vni = htonl (vni);
15799 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15800 mp->is_l2 = bd_index_set;
15805 /* wait for reply */
15810 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15813 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15815 u32 *action = va_arg (*args, u32 *);
15818 if (unformat (input, "%s", &s))
15820 if (!strcmp ((char *) s, "no-action"))
15822 else if (!strcmp ((char *) s, "natively-forward"))
15824 else if (!strcmp ((char *) s, "send-map-request"))
15826 else if (!strcmp ((char *) s, "drop"))
15830 clib_warning ("invalid action: '%s'", s);
15842 * Add/del remote mapping to/from ONE control plane
15844 * @param vam vpp API test context
15845 * @return return code
15848 api_one_add_del_remote_mapping (vat_main_t * vam)
15850 unformat_input_t *input = vam->input;
15851 vl_api_one_add_del_remote_mapping_t *mp;
15853 lisp_eid_vat_t _eid, *eid = &_eid;
15854 lisp_eid_vat_t _seid, *seid = &_seid;
15855 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15856 u32 action = ~0, p, w, data_len;
15857 ip4_address_t rloc4;
15858 ip6_address_t rloc6;
15859 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15862 clib_memset (&rloc, 0, sizeof (rloc));
15864 /* Parse args required to build the message */
15865 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15867 if (unformat (input, "del-all"))
15871 else if (unformat (input, "del"))
15875 else if (unformat (input, "add"))
15879 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15883 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15887 else if (unformat (input, "vni %d", &vni))
15891 else if (unformat (input, "p %d w %d", &p, &w))
15895 errmsg ("No RLOC configured for setting priority/weight!");
15898 curr_rloc->priority = p;
15899 curr_rloc->weight = w;
15901 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15903 rloc.ip_address.af = 0;
15904 clib_memcpy (&rloc.ip_address.un.ip6, &rloc6, sizeof (rloc6));
15905 vec_add1 (rlocs, rloc);
15906 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15908 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15910 rloc.ip_address.af = 1;
15911 clib_memcpy (&rloc.ip_address.un.ip4, &rloc4, sizeof (rloc4));
15912 vec_add1 (rlocs, rloc);
15913 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15915 else if (unformat (input, "action %U",
15916 unformat_negative_mapping_action, &action))
15922 clib_warning ("parse error '%U'", format_unformat_error, input);
15929 errmsg ("missing params!");
15933 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15935 errmsg ("no action set for negative map-reply!");
15939 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15941 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15942 mp->is_add = is_add;
15943 mp->vni = htonl (vni);
15944 mp->action = (u8) action;
15945 mp->is_src_dst = seid_set;
15946 mp->del_all = del_all;
15947 lisp_eid_put_vat (&mp->deid, eid);
15948 lisp_eid_put_vat (&mp->seid, seid);
15950 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15951 clib_memcpy (mp->rlocs, rlocs, data_len);
15957 /* Wait for a reply... */
15962 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15965 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15966 * forwarding entries in data-plane accordingly.
15968 * @param vam vpp API test context
15969 * @return return code
15972 api_one_add_del_adjacency (vat_main_t * vam)
15974 unformat_input_t *input = vam->input;
15975 vl_api_one_add_del_adjacency_t *mp;
15979 lisp_eid_vat_t leid, reid;
15981 leid.type = reid.type = (u8) ~ 0;
15983 /* Parse args required to build the message */
15984 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15986 if (unformat (input, "del"))
15990 else if (unformat (input, "add"))
15994 else if (unformat (input, "reid %U/%d", unformat_ip46_address,
15995 &reid.addr.ip, &reid.len))
15997 reid.type = 0; /* ipv4 */
15999 else if (unformat (input, "reid %U", unformat_ethernet_address,
16002 reid.type = 1; /* mac */
16004 else if (unformat (input, "leid %U/%d", unformat_ip46_address,
16005 &leid.addr.ip, &leid.len))
16007 leid.type = 0; /* ipv4 */
16009 else if (unformat (input, "leid %U", unformat_ethernet_address,
16012 leid.type = 1; /* mac */
16014 else if (unformat (input, "vni %d", &vni))
16020 errmsg ("parse error '%U'", format_unformat_error, input);
16025 if ((u8) ~ 0 == reid.type)
16027 errmsg ("missing params!");
16031 if (leid.type != reid.type)
16033 errmsg ("remote and local EIDs are of different types!");
16037 M (ONE_ADD_DEL_ADJACENCY, mp);
16038 mp->is_add = is_add;
16039 mp->vni = htonl (vni);
16040 lisp_eid_put_vat (&mp->leid, &leid);
16041 lisp_eid_put_vat (&mp->reid, &reid);
16046 /* Wait for a reply... */
16051 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16054 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16056 u32 *mode = va_arg (*args, u32 *);
16058 if (unformat (input, "lisp"))
16060 else if (unformat (input, "vxlan"))
16069 api_gpe_get_encap_mode (vat_main_t * vam)
16071 vl_api_gpe_get_encap_mode_t *mp;
16074 /* Construct the API message */
16075 M (GPE_GET_ENCAP_MODE, mp);
16080 /* Wait for a reply... */
16086 api_gpe_set_encap_mode (vat_main_t * vam)
16088 unformat_input_t *input = vam->input;
16089 vl_api_gpe_set_encap_mode_t *mp;
16093 /* Parse args required to build the message */
16094 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16096 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16102 /* Construct the API message */
16103 M (GPE_SET_ENCAP_MODE, mp);
16105 mp->is_vxlan = mode;
16110 /* Wait for a reply... */
16116 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16118 unformat_input_t *input = vam->input;
16119 vl_api_gpe_add_del_iface_t *mp;
16120 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16121 u32 dp_table = 0, vni = 0;
16124 /* Parse args required to build the message */
16125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16127 if (unformat (input, "up"))
16132 else if (unformat (input, "down"))
16137 else if (unformat (input, "table_id %d", &dp_table))
16141 else if (unformat (input, "bd_id %d", &dp_table))
16146 else if (unformat (input, "vni %d", &vni))
16154 if (action_set == 0)
16156 errmsg ("Action not set");
16159 if (dp_table_set == 0 || vni_set == 0)
16161 errmsg ("vni and dp_table must be set");
16165 /* Construct the API message */
16166 M (GPE_ADD_DEL_IFACE, mp);
16168 mp->is_add = is_add;
16169 mp->dp_table = clib_host_to_net_u32 (dp_table);
16171 mp->vni = clib_host_to_net_u32 (vni);
16176 /* Wait for a reply... */
16182 api_one_map_register_fallback_threshold (vat_main_t * vam)
16184 unformat_input_t *input = vam->input;
16185 vl_api_one_map_register_fallback_threshold_t *mp;
16190 /* Parse args required to build the message */
16191 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16193 if (unformat (input, "%u", &value))
16197 clib_warning ("parse error '%U'", format_unformat_error, input);
16204 errmsg ("fallback threshold value is missing!");
16208 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16209 mp->value = clib_host_to_net_u32 (value);
16214 /* Wait for a reply... */
16220 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16222 vl_api_show_one_map_register_fallback_threshold_t *mp;
16225 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16230 /* Wait for a reply... */
16236 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16238 u32 *proto = va_arg (*args, u32 *);
16240 if (unformat (input, "udp"))
16242 else if (unformat (input, "api"))
16251 api_one_set_transport_protocol (vat_main_t * vam)
16253 unformat_input_t *input = vam->input;
16254 vl_api_one_set_transport_protocol_t *mp;
16259 /* Parse args required to build the message */
16260 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16262 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16266 clib_warning ("parse error '%U'", format_unformat_error, input);
16273 errmsg ("Transport protocol missing!");
16277 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16278 mp->protocol = (u8) protocol;
16283 /* Wait for a reply... */
16289 api_one_get_transport_protocol (vat_main_t * vam)
16291 vl_api_one_get_transport_protocol_t *mp;
16294 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16299 /* Wait for a reply... */
16305 api_one_map_register_set_ttl (vat_main_t * vam)
16307 unformat_input_t *input = vam->input;
16308 vl_api_one_map_register_set_ttl_t *mp;
16313 /* Parse args required to build the message */
16314 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16316 if (unformat (input, "%u", &ttl))
16320 clib_warning ("parse error '%U'", format_unformat_error, input);
16327 errmsg ("TTL value missing!");
16331 M (ONE_MAP_REGISTER_SET_TTL, mp);
16332 mp->ttl = clib_host_to_net_u32 (ttl);
16337 /* Wait for a reply... */
16343 api_show_one_map_register_ttl (vat_main_t * vam)
16345 vl_api_show_one_map_register_ttl_t *mp;
16348 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16353 /* Wait for a reply... */
16359 * Add/del map request itr rlocs from ONE control plane and updates
16361 * @param vam vpp API test context
16362 * @return return code
16365 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16367 unformat_input_t *input = vam->input;
16368 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16369 u8 *locator_set_name = 0;
16370 u8 locator_set_name_set = 0;
16374 /* Parse args required to build the message */
16375 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16377 if (unformat (input, "del"))
16381 else if (unformat (input, "%_%v%_", &locator_set_name))
16383 locator_set_name_set = 1;
16387 clib_warning ("parse error '%U'", format_unformat_error, input);
16392 if (is_add && !locator_set_name_set)
16394 errmsg ("itr-rloc is not set!");
16398 if (is_add && vec_len (locator_set_name) > 64)
16400 errmsg ("itr-rloc locator-set name too long");
16401 vec_free (locator_set_name);
16405 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16406 mp->is_add = is_add;
16409 clib_memcpy (mp->locator_set_name, locator_set_name,
16410 vec_len (locator_set_name));
16414 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16416 vec_free (locator_set_name);
16421 /* Wait for a reply... */
16426 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16429 api_one_locator_dump (vat_main_t * vam)
16431 unformat_input_t *input = vam->input;
16432 vl_api_one_locator_dump_t *mp;
16433 vl_api_control_ping_t *mp_ping;
16434 u8 is_index_set = 0, is_name_set = 0;
16439 /* Parse args required to build the message */
16440 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16442 if (unformat (input, "ls_name %_%v%_", &ls_name))
16446 else if (unformat (input, "ls_index %d", &ls_index))
16452 errmsg ("parse error '%U'", format_unformat_error, input);
16457 if (!is_index_set && !is_name_set)
16459 errmsg ("error: expected one of index or name!");
16463 if (is_index_set && is_name_set)
16465 errmsg ("error: only one param expected!");
16469 if (vec_len (ls_name) > 62)
16471 errmsg ("error: locator set name too long!");
16475 if (!vam->json_output)
16477 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16480 M (ONE_LOCATOR_DUMP, mp);
16481 mp->is_index_set = is_index_set;
16484 mp->ls_index = clib_host_to_net_u32 (ls_index);
16487 vec_add1 (ls_name, 0);
16488 strncpy ((char *) mp->ls_name, (char *) ls_name,
16489 sizeof (mp->ls_name) - 1);
16495 /* Use a control ping for synchronization */
16496 MPING (CONTROL_PING, mp_ping);
16499 /* Wait for a reply... */
16504 #define api_lisp_locator_dump api_one_locator_dump
16507 api_one_locator_set_dump (vat_main_t * vam)
16509 vl_api_one_locator_set_dump_t *mp;
16510 vl_api_control_ping_t *mp_ping;
16511 unformat_input_t *input = vam->input;
16515 /* Parse args required to build the message */
16516 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16518 if (unformat (input, "local"))
16522 else if (unformat (input, "remote"))
16528 errmsg ("parse error '%U'", format_unformat_error, input);
16533 if (!vam->json_output)
16535 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16538 M (ONE_LOCATOR_SET_DUMP, mp);
16540 mp->filter = filter;
16545 /* Use a control ping for synchronization */
16546 MPING (CONTROL_PING, mp_ping);
16549 /* Wait for a reply... */
16554 #define api_lisp_locator_set_dump api_one_locator_set_dump
16557 api_one_eid_table_map_dump (vat_main_t * vam)
16561 unformat_input_t *input = vam->input;
16562 vl_api_one_eid_table_map_dump_t *mp;
16563 vl_api_control_ping_t *mp_ping;
16566 /* Parse args required to build the message */
16567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16569 if (unformat (input, "l2"))
16574 else if (unformat (input, "l3"))
16581 errmsg ("parse error '%U'", format_unformat_error, input);
16588 errmsg ("expected one of 'l2' or 'l3' parameter!");
16592 if (!vam->json_output)
16594 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16597 M (ONE_EID_TABLE_MAP_DUMP, mp);
16603 /* Use a control ping for synchronization */
16604 MPING (CONTROL_PING, mp_ping);
16607 /* Wait for a reply... */
16612 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16615 api_one_eid_table_vni_dump (vat_main_t * vam)
16617 vl_api_one_eid_table_vni_dump_t *mp;
16618 vl_api_control_ping_t *mp_ping;
16621 if (!vam->json_output)
16623 print (vam->ofp, "VNI");
16626 M (ONE_EID_TABLE_VNI_DUMP, mp);
16631 /* Use a control ping for synchronization */
16632 MPING (CONTROL_PING, mp_ping);
16635 /* Wait for a reply... */
16640 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16643 api_one_eid_table_dump (vat_main_t * vam)
16645 unformat_input_t *i = vam->input;
16646 vl_api_one_eid_table_dump_t *mp;
16647 vl_api_control_ping_t *mp_ping;
16651 lisp_eid_vat_t eid;
16654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16657 (i, "eid %U/%d", unformat_ip46_address, &eid.addr.ip, &eid.len))
16663 if (unformat (i, "eid %U", unformat_ethernet_address, &eid.addr.mac))
16668 else if (unformat (i, "eid %U", unformat_nsh_address, &eid.addr.nsh))
16673 else if (unformat (i, "vni %d", &t))
16677 else if (unformat (i, "local"))
16681 else if (unformat (i, "remote"))
16687 errmsg ("parse error '%U'", format_unformat_error, i);
16692 if (!vam->json_output)
16694 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16695 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16698 M (ONE_EID_TABLE_DUMP, mp);
16700 mp->filter = filter;
16704 mp->vni = htonl (vni);
16705 lisp_eid_put_vat (&mp->eid, &eid);
16711 /* Use a control ping for synchronization */
16712 MPING (CONTROL_PING, mp_ping);
16715 /* Wait for a reply... */
16720 #define api_lisp_eid_table_dump api_one_eid_table_dump
16723 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16725 unformat_input_t *i = vam->input;
16726 vl_api_gpe_fwd_entries_get_t *mp;
16731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16733 if (unformat (i, "vni %d", &vni))
16739 errmsg ("parse error '%U'", format_unformat_error, i);
16746 errmsg ("vni not set!");
16750 if (!vam->json_output)
16752 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16756 M (GPE_FWD_ENTRIES_GET, mp);
16757 mp->vni = clib_host_to_net_u32 (vni);
16762 /* Wait for a reply... */
16767 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16768 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16769 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16770 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16771 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16772 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16773 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16774 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16777 api_one_adjacencies_get (vat_main_t * vam)
16779 unformat_input_t *i = vam->input;
16780 vl_api_one_adjacencies_get_t *mp;
16785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16787 if (unformat (i, "vni %d", &vni))
16793 errmsg ("parse error '%U'", format_unformat_error, i);
16800 errmsg ("vni not set!");
16804 if (!vam->json_output)
16806 print (vam->ofp, "%s %40s", "leid", "reid");
16809 M (ONE_ADJACENCIES_GET, mp);
16810 mp->vni = clib_host_to_net_u32 (vni);
16815 /* Wait for a reply... */
16820 #define api_lisp_adjacencies_get api_one_adjacencies_get
16823 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16825 unformat_input_t *i = vam->input;
16826 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16828 u8 ip_family_set = 0, is_ip4 = 1;
16830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16832 if (unformat (i, "ip4"))
16837 else if (unformat (i, "ip6"))
16844 errmsg ("parse error '%U'", format_unformat_error, i);
16849 if (!ip_family_set)
16851 errmsg ("ip family not set!");
16855 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16856 mp->is_ip4 = is_ip4;
16861 /* Wait for a reply... */
16867 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16869 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16872 if (!vam->json_output)
16874 print (vam->ofp, "VNIs");
16877 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16882 /* Wait for a reply... */
16888 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16890 unformat_input_t *i = vam->input;
16891 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16893 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16894 struct in_addr ip4;
16895 struct in6_addr ip6;
16896 u32 table_id = 0, nh_sw_if_index = ~0;
16898 clib_memset (&ip4, 0, sizeof (ip4));
16899 clib_memset (&ip6, 0, sizeof (ip6));
16901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16903 if (unformat (i, "del"))
16905 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16906 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16911 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16912 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16917 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16921 nh_sw_if_index = ~0;
16923 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16927 nh_sw_if_index = ~0;
16929 else if (unformat (i, "table %d", &table_id))
16933 errmsg ("parse error '%U'", format_unformat_error, i);
16940 errmsg ("nh addr not set!");
16944 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16945 mp->is_add = is_add;
16946 mp->table_id = clib_host_to_net_u32 (table_id);
16947 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16948 mp->nh_addr.af = is_ip4 ? 0 : 1;
16950 clib_memcpy (mp->nh_addr.un.ip4, &ip4, sizeof (ip4));
16952 clib_memcpy (mp->nh_addr.un.ip6, &ip6, sizeof (ip6));
16957 /* Wait for a reply... */
16963 api_one_map_server_dump (vat_main_t * vam)
16965 vl_api_one_map_server_dump_t *mp;
16966 vl_api_control_ping_t *mp_ping;
16969 if (!vam->json_output)
16971 print (vam->ofp, "%=20s", "Map server");
16974 M (ONE_MAP_SERVER_DUMP, mp);
16978 /* Use a control ping for synchronization */
16979 MPING (CONTROL_PING, mp_ping);
16982 /* Wait for a reply... */
16987 #define api_lisp_map_server_dump api_one_map_server_dump
16990 api_one_map_resolver_dump (vat_main_t * vam)
16992 vl_api_one_map_resolver_dump_t *mp;
16993 vl_api_control_ping_t *mp_ping;
16996 if (!vam->json_output)
16998 print (vam->ofp, "%=20s", "Map resolver");
17001 M (ONE_MAP_RESOLVER_DUMP, mp);
17005 /* Use a control ping for synchronization */
17006 MPING (CONTROL_PING, mp_ping);
17009 /* Wait for a reply... */
17014 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17017 api_one_stats_flush (vat_main_t * vam)
17019 vl_api_one_stats_flush_t *mp;
17022 M (ONE_STATS_FLUSH, mp);
17029 api_one_stats_dump (vat_main_t * vam)
17031 vl_api_one_stats_dump_t *mp;
17032 vl_api_control_ping_t *mp_ping;
17035 M (ONE_STATS_DUMP, mp);
17039 /* Use a control ping for synchronization */
17040 MPING (CONTROL_PING, mp_ping);
17043 /* Wait for a reply... */
17049 api_show_one_status (vat_main_t * vam)
17051 vl_api_show_one_status_t *mp;
17054 if (!vam->json_output)
17056 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17059 M (SHOW_ONE_STATUS, mp);
17062 /* Wait for a reply... */
17067 #define api_show_lisp_status api_show_one_status
17070 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17072 vl_api_gpe_fwd_entry_path_dump_t *mp;
17073 vl_api_control_ping_t *mp_ping;
17074 unformat_input_t *i = vam->input;
17075 u32 fwd_entry_index = ~0;
17078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17080 if (unformat (i, "index %d", &fwd_entry_index))
17086 if (~0 == fwd_entry_index)
17088 errmsg ("no index specified!");
17092 if (!vam->json_output)
17094 print (vam->ofp, "first line");
17097 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17101 /* Use a control ping for synchronization */
17102 MPING (CONTROL_PING, mp_ping);
17105 /* Wait for a reply... */
17111 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17113 vl_api_one_get_map_request_itr_rlocs_t *mp;
17116 if (!vam->json_output)
17118 print (vam->ofp, "%=20s", "itr-rlocs:");
17121 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17124 /* Wait for a reply... */
17129 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17132 api_af_packet_create (vat_main_t * vam)
17134 unformat_input_t *i = vam->input;
17135 vl_api_af_packet_create_t *mp;
17136 u8 *host_if_name = 0;
17138 u8 random_hw_addr = 1;
17141 clib_memset (hw_addr, 0, sizeof (hw_addr));
17143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17145 if (unformat (i, "name %s", &host_if_name))
17146 vec_add1 (host_if_name, 0);
17147 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17148 random_hw_addr = 0;
17153 if (!vec_len (host_if_name))
17155 errmsg ("host-interface name must be specified");
17159 if (vec_len (host_if_name) > 64)
17161 errmsg ("host-interface name too long");
17165 M (AF_PACKET_CREATE, mp);
17167 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17168 clib_memcpy (mp->hw_addr, hw_addr, 6);
17169 mp->use_random_hw_addr = random_hw_addr;
17170 vec_free (host_if_name);
17178 fprintf (vam->ofp ? vam->ofp : stderr,
17179 " new sw_if_index = %d\n", vam->sw_if_index);
17186 api_af_packet_delete (vat_main_t * vam)
17188 unformat_input_t *i = vam->input;
17189 vl_api_af_packet_delete_t *mp;
17190 u8 *host_if_name = 0;
17193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17195 if (unformat (i, "name %s", &host_if_name))
17196 vec_add1 (host_if_name, 0);
17201 if (!vec_len (host_if_name))
17203 errmsg ("host-interface name must be specified");
17207 if (vec_len (host_if_name) > 64)
17209 errmsg ("host-interface name too long");
17213 M (AF_PACKET_DELETE, mp);
17215 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17216 vec_free (host_if_name);
17223 static void vl_api_af_packet_details_t_handler
17224 (vl_api_af_packet_details_t * mp)
17226 vat_main_t *vam = &vat_main;
17228 print (vam->ofp, "%-16s %d",
17229 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17232 static void vl_api_af_packet_details_t_handler_json
17233 (vl_api_af_packet_details_t * mp)
17235 vat_main_t *vam = &vat_main;
17236 vat_json_node_t *node = NULL;
17238 if (VAT_JSON_ARRAY != vam->json_tree.type)
17240 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17241 vat_json_init_array (&vam->json_tree);
17243 node = vat_json_array_add (&vam->json_tree);
17245 vat_json_init_object (node);
17246 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17247 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17251 api_af_packet_dump (vat_main_t * vam)
17253 vl_api_af_packet_dump_t *mp;
17254 vl_api_control_ping_t *mp_ping;
17257 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17258 /* Get list of tap interfaces */
17259 M (AF_PACKET_DUMP, mp);
17262 /* Use a control ping for synchronization */
17263 MPING (CONTROL_PING, mp_ping);
17271 api_policer_add_del (vat_main_t * vam)
17273 unformat_input_t *i = vam->input;
17274 vl_api_policer_add_del_t *mp;
17284 u8 color_aware = 0;
17285 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17288 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17289 conform_action.dscp = 0;
17290 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17291 exceed_action.dscp = 0;
17292 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17293 violate_action.dscp = 0;
17295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17297 if (unformat (i, "del"))
17299 else if (unformat (i, "name %s", &name))
17300 vec_add1 (name, 0);
17301 else if (unformat (i, "cir %u", &cir))
17303 else if (unformat (i, "eir %u", &eir))
17305 else if (unformat (i, "cb %u", &cb))
17307 else if (unformat (i, "eb %u", &eb))
17309 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17312 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17315 else if (unformat (i, "type %U", unformat_policer_type, &type))
17317 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17320 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17323 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17326 else if (unformat (i, "color-aware"))
17332 if (!vec_len (name))
17334 errmsg ("policer name must be specified");
17338 if (vec_len (name) > 64)
17340 errmsg ("policer name too long");
17344 M (POLICER_ADD_DEL, mp);
17346 clib_memcpy (mp->name, name, vec_len (name));
17348 mp->is_add = is_add;
17349 mp->cir = ntohl (cir);
17350 mp->eir = ntohl (eir);
17351 mp->cb = clib_net_to_host_u64 (cb);
17352 mp->eb = clib_net_to_host_u64 (eb);
17353 mp->rate_type = rate_type;
17354 mp->round_type = round_type;
17356 mp->conform_action.type = conform_action.action_type;
17357 mp->conform_action.dscp = conform_action.dscp;
17358 mp->exceed_action.type = exceed_action.action_type;
17359 mp->exceed_action.dscp = exceed_action.dscp;
17360 mp->violate_action.type = violate_action.action_type;
17361 mp->violate_action.dscp = violate_action.dscp;
17362 mp->color_aware = color_aware;
17370 api_policer_dump (vat_main_t * vam)
17372 unformat_input_t *i = vam->input;
17373 vl_api_policer_dump_t *mp;
17374 vl_api_control_ping_t *mp_ping;
17375 u8 *match_name = 0;
17376 u8 match_name_valid = 0;
17379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17381 if (unformat (i, "name %s", &match_name))
17383 vec_add1 (match_name, 0);
17384 match_name_valid = 1;
17390 M (POLICER_DUMP, mp);
17391 mp->match_name_valid = match_name_valid;
17392 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17393 vec_free (match_name);
17397 /* Use a control ping for synchronization */
17398 MPING (CONTROL_PING, mp_ping);
17401 /* Wait for a reply... */
17407 api_policer_classify_set_interface (vat_main_t * vam)
17409 unformat_input_t *i = vam->input;
17410 vl_api_policer_classify_set_interface_t *mp;
17412 int sw_if_index_set;
17413 u32 ip4_table_index = ~0;
17414 u32 ip6_table_index = ~0;
17415 u32 l2_table_index = ~0;
17419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17422 sw_if_index_set = 1;
17423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17424 sw_if_index_set = 1;
17425 else if (unformat (i, "del"))
17427 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17429 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17431 else if (unformat (i, "l2-table %d", &l2_table_index))
17435 clib_warning ("parse error '%U'", format_unformat_error, i);
17440 if (sw_if_index_set == 0)
17442 errmsg ("missing interface name or sw_if_index");
17446 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17448 mp->sw_if_index = ntohl (sw_if_index);
17449 mp->ip4_table_index = ntohl (ip4_table_index);
17450 mp->ip6_table_index = ntohl (ip6_table_index);
17451 mp->l2_table_index = ntohl (l2_table_index);
17452 mp->is_add = is_add;
17460 api_policer_classify_dump (vat_main_t * vam)
17462 unformat_input_t *i = vam->input;
17463 vl_api_policer_classify_dump_t *mp;
17464 vl_api_control_ping_t *mp_ping;
17465 u8 type = POLICER_CLASSIFY_N_TABLES;
17468 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17472 errmsg ("classify table type must be specified");
17476 if (!vam->json_output)
17478 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17481 M (POLICER_CLASSIFY_DUMP, mp);
17486 /* Use a control ping for synchronization */
17487 MPING (CONTROL_PING, mp_ping);
17490 /* Wait for a reply... */
17496 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17498 vl_api_fib_path_nh_proto_t proto =
17499 va_arg (*args, vl_api_fib_path_nh_proto_t);
17503 case FIB_API_PATH_NH_PROTO_IP4:
17504 s = format (s, "ip4");
17506 case FIB_API_PATH_NH_PROTO_IP6:
17507 s = format (s, "ip6");
17509 case FIB_API_PATH_NH_PROTO_MPLS:
17510 s = format (s, "mpls");
17512 case FIB_API_PATH_NH_PROTO_BIER:
17513 s = format (s, "bier");
17515 case FIB_API_PATH_NH_PROTO_ETHERNET:
17516 s = format (s, "ethernet");
17524 format_vl_api_ip_address_union (u8 * s, va_list * args)
17526 vl_api_address_family_t af = va_arg (*args, int);
17527 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17532 s = format (s, "%U", format_ip4_address, u->ip4);
17535 s = format (s, "%U", format_ip6_address, u->ip6);
17542 format_vl_api_fib_path_type (u8 * s, va_list * args)
17544 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17548 case FIB_API_PATH_TYPE_NORMAL:
17549 s = format (s, "normal");
17551 case FIB_API_PATH_TYPE_LOCAL:
17552 s = format (s, "local");
17554 case FIB_API_PATH_TYPE_DROP:
17555 s = format (s, "drop");
17557 case FIB_API_PATH_TYPE_UDP_ENCAP:
17558 s = format (s, "udp-encap");
17560 case FIB_API_PATH_TYPE_BIER_IMP:
17561 s = format (s, "bier-imp");
17563 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17564 s = format (s, "unreach");
17566 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17567 s = format (s, "prohibit");
17569 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17570 s = format (s, "src-lookup");
17572 case FIB_API_PATH_TYPE_DVR:
17573 s = format (s, "dvr");
17575 case FIB_API_PATH_TYPE_INTERFACE_RX:
17576 s = format (s, "interface-rx");
17578 case FIB_API_PATH_TYPE_CLASSIFY:
17579 s = format (s, "classify");
17587 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17590 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17591 ntohl (fp->weight), ntohl (fp->sw_if_index),
17592 format_vl_api_fib_path_type, fp->type,
17593 format_fib_api_path_nh_proto, fp->proto,
17594 format_vl_api_ip_address_union, &fp->nh.address);
17598 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17599 vl_api_fib_path_t * fp)
17601 struct in_addr ip4;
17602 struct in6_addr ip6;
17604 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17605 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17606 vat_json_object_add_uint (node, "type", fp->type);
17607 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17608 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17610 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17611 vat_json_object_add_ip4 (node, "next_hop", ip4);
17613 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
17615 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17616 vat_json_object_add_ip6 (node, "next_hop", ip6);
17621 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17623 vat_main_t *vam = &vat_main;
17624 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17625 vl_api_fib_path_t *fp;
17628 print (vam->ofp, "sw_if_index %d via:",
17629 ntohl (mp->mt_tunnel.mt_sw_if_index));
17630 fp = mp->mt_tunnel.mt_paths;
17631 for (i = 0; i < count; i++)
17633 vl_api_fib_path_print (vam, fp);
17637 print (vam->ofp, "");
17640 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17641 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17644 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17646 vat_main_t *vam = &vat_main;
17647 vat_json_node_t *node = NULL;
17648 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17649 vl_api_fib_path_t *fp;
17652 if (VAT_JSON_ARRAY != vam->json_tree.type)
17654 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17655 vat_json_init_array (&vam->json_tree);
17657 node = vat_json_array_add (&vam->json_tree);
17659 vat_json_init_object (node);
17660 vat_json_object_add_uint (node, "sw_if_index",
17661 ntohl (mp->mt_tunnel.mt_sw_if_index));
17663 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17665 fp = mp->mt_tunnel.mt_paths;
17666 for (i = 0; i < count; i++)
17668 vl_api_mpls_fib_path_json_print (node, fp);
17674 api_mpls_tunnel_dump (vat_main_t * vam)
17676 vl_api_mpls_tunnel_dump_t *mp;
17677 vl_api_control_ping_t *mp_ping;
17680 M (MPLS_TUNNEL_DUMP, mp);
17684 /* Use a control ping for synchronization */
17685 MPING (CONTROL_PING, mp_ping);
17692 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17693 #define vl_api_mpls_table_details_t_print vl_noop_handler
17697 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17699 vat_main_t *vam = &vat_main;
17701 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17704 static void vl_api_mpls_table_details_t_handler_json
17705 (vl_api_mpls_table_details_t * mp)
17707 vat_main_t *vam = &vat_main;
17708 vat_json_node_t *node = NULL;
17710 if (VAT_JSON_ARRAY != vam->json_tree.type)
17712 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17713 vat_json_init_array (&vam->json_tree);
17715 node = vat_json_array_add (&vam->json_tree);
17717 vat_json_init_object (node);
17718 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17722 api_mpls_table_dump (vat_main_t * vam)
17724 vl_api_mpls_table_dump_t *mp;
17725 vl_api_control_ping_t *mp_ping;
17728 M (MPLS_TABLE_DUMP, mp);
17731 /* Use a control ping for synchronization */
17732 MPING (CONTROL_PING, mp_ping);
17739 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17740 #define vl_api_mpls_route_details_t_print vl_noop_handler
17743 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17745 vat_main_t *vam = &vat_main;
17746 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17747 vl_api_fib_path_t *fp;
17751 "table-id %d, label %u, ess_bit %u",
17752 ntohl (mp->mr_route.mr_table_id),
17753 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17754 fp = mp->mr_route.mr_paths;
17755 for (i = 0; i < count; i++)
17757 vl_api_fib_path_print (vam, fp);
17762 static void vl_api_mpls_route_details_t_handler_json
17763 (vl_api_mpls_route_details_t * mp)
17765 vat_main_t *vam = &vat_main;
17766 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17767 vat_json_node_t *node = NULL;
17768 vl_api_fib_path_t *fp;
17771 if (VAT_JSON_ARRAY != vam->json_tree.type)
17773 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17774 vat_json_init_array (&vam->json_tree);
17776 node = vat_json_array_add (&vam->json_tree);
17778 vat_json_init_object (node);
17779 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17780 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17781 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17782 vat_json_object_add_uint (node, "path_count", count);
17783 fp = mp->mr_route.mr_paths;
17784 for (i = 0; i < count; i++)
17786 vl_api_mpls_fib_path_json_print (node, fp);
17792 api_mpls_route_dump (vat_main_t * vam)
17794 unformat_input_t *input = vam->input;
17795 vl_api_mpls_route_dump_t *mp;
17796 vl_api_control_ping_t *mp_ping;
17800 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17802 if (unformat (input, "table_id %d", &table_id))
17807 if (table_id == ~0)
17809 errmsg ("missing table id");
17813 M (MPLS_ROUTE_DUMP, mp);
17815 mp->table.mt_table_id = ntohl (table_id);
17818 /* Use a control ping for synchronization */
17819 MPING (CONTROL_PING, mp_ping);
17826 #define vl_api_ip_table_details_t_endian vl_noop_handler
17827 #define vl_api_ip_table_details_t_print vl_noop_handler
17830 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17832 vat_main_t *vam = &vat_main;
17835 "%s; table-id %d, prefix %U/%d",
17836 mp->table.name, ntohl (mp->table.table_id));
17840 static void vl_api_ip_table_details_t_handler_json
17841 (vl_api_ip_table_details_t * mp)
17843 vat_main_t *vam = &vat_main;
17844 vat_json_node_t *node = NULL;
17846 if (VAT_JSON_ARRAY != vam->json_tree.type)
17848 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17849 vat_json_init_array (&vam->json_tree);
17851 node = vat_json_array_add (&vam->json_tree);
17853 vat_json_init_object (node);
17854 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17858 api_ip_table_dump (vat_main_t * vam)
17860 vl_api_ip_table_dump_t *mp;
17861 vl_api_control_ping_t *mp_ping;
17864 M (IP_TABLE_DUMP, mp);
17867 /* Use a control ping for synchronization */
17868 MPING (CONTROL_PING, mp_ping);
17876 api_ip_mtable_dump (vat_main_t * vam)
17878 vl_api_ip_mtable_dump_t *mp;
17879 vl_api_control_ping_t *mp_ping;
17882 M (IP_MTABLE_DUMP, mp);
17885 /* Use a control ping for synchronization */
17886 MPING (CONTROL_PING, mp_ping);
17894 api_ip_mroute_dump (vat_main_t * vam)
17896 unformat_input_t *input = vam->input;
17897 vl_api_control_ping_t *mp_ping;
17898 vl_api_ip_mroute_dump_t *mp;
17903 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17905 if (unformat (input, "table_id %d", &table_id))
17907 else if (unformat (input, "ip6"))
17909 else if (unformat (input, "ip4"))
17914 if (table_id == ~0)
17916 errmsg ("missing table id");
17920 M (IP_MROUTE_DUMP, mp);
17921 mp->table.table_id = table_id;
17922 mp->table.is_ip6 = is_ip6;
17925 /* Use a control ping for synchronization */
17926 MPING (CONTROL_PING, mp_ping);
17933 #define vl_api_ip_route_details_t_endian vl_noop_handler
17934 #define vl_api_ip_route_details_t_print vl_noop_handler
17937 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17939 vat_main_t *vam = &vat_main;
17940 u8 count = mp->route.n_paths;
17941 vl_api_fib_path_t *fp;
17945 "table-id %d, prefix %U/%d",
17946 ntohl (mp->route.table_id),
17947 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17948 for (i = 0; i < count; i++)
17950 fp = &mp->route.paths[i];
17952 vl_api_fib_path_print (vam, fp);
17957 static void vl_api_ip_route_details_t_handler_json
17958 (vl_api_ip_route_details_t * mp)
17960 vat_main_t *vam = &vat_main;
17961 u8 count = mp->route.n_paths;
17962 vat_json_node_t *node = NULL;
17963 struct in_addr ip4;
17964 struct in6_addr ip6;
17965 vl_api_fib_path_t *fp;
17968 if (VAT_JSON_ARRAY != vam->json_tree.type)
17970 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17971 vat_json_init_array (&vam->json_tree);
17973 node = vat_json_array_add (&vam->json_tree);
17975 vat_json_init_object (node);
17976 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
17977 if (ADDRESS_IP6 == mp->route.prefix.address.af)
17979 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
17980 vat_json_object_add_ip6 (node, "prefix", ip6);
17984 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
17985 vat_json_object_add_ip4 (node, "prefix", ip4);
17987 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
17988 vat_json_object_add_uint (node, "path_count", count);
17989 for (i = 0; i < count; i++)
17991 fp = &mp->route.paths[i];
17992 vl_api_mpls_fib_path_json_print (node, fp);
17997 api_ip_route_dump (vat_main_t * vam)
17999 unformat_input_t *input = vam->input;
18000 vl_api_ip_route_dump_t *mp;
18001 vl_api_control_ping_t *mp_ping;
18007 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18009 if (unformat (input, "table_id %d", &table_id))
18011 else if (unformat (input, "ip6"))
18013 else if (unformat (input, "ip4"))
18018 if (table_id == ~0)
18020 errmsg ("missing table id");
18024 M (IP_ROUTE_DUMP, mp);
18026 mp->table.table_id = table_id;
18027 mp->table.is_ip6 = is_ip6;
18031 /* Use a control ping for synchronization */
18032 MPING (CONTROL_PING, mp_ping);
18040 api_classify_table_ids (vat_main_t * vam)
18042 vl_api_classify_table_ids_t *mp;
18045 /* Construct the API message */
18046 M (CLASSIFY_TABLE_IDS, mp);
18055 api_classify_table_by_interface (vat_main_t * vam)
18057 unformat_input_t *input = vam->input;
18058 vl_api_classify_table_by_interface_t *mp;
18060 u32 sw_if_index = ~0;
18062 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18064 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18066 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18071 if (sw_if_index == ~0)
18073 errmsg ("missing interface name or sw_if_index");
18077 /* Construct the API message */
18078 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18080 mp->sw_if_index = ntohl (sw_if_index);
18088 api_classify_table_info (vat_main_t * vam)
18090 unformat_input_t *input = vam->input;
18091 vl_api_classify_table_info_t *mp;
18095 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18097 if (unformat (input, "table_id %d", &table_id))
18102 if (table_id == ~0)
18104 errmsg ("missing table id");
18108 /* Construct the API message */
18109 M (CLASSIFY_TABLE_INFO, mp);
18111 mp->table_id = ntohl (table_id);
18119 api_classify_session_dump (vat_main_t * vam)
18121 unformat_input_t *input = vam->input;
18122 vl_api_classify_session_dump_t *mp;
18123 vl_api_control_ping_t *mp_ping;
18127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18129 if (unformat (input, "table_id %d", &table_id))
18134 if (table_id == ~0)
18136 errmsg ("missing table id");
18140 /* Construct the API message */
18141 M (CLASSIFY_SESSION_DUMP, mp);
18143 mp->table_id = ntohl (table_id);
18146 /* Use a control ping for synchronization */
18147 MPING (CONTROL_PING, mp_ping);
18155 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18157 vat_main_t *vam = &vat_main;
18159 print (vam->ofp, "collector_address %U, collector_port %d, "
18160 "src_address %U, vrf_id %d, path_mtu %u, "
18161 "template_interval %u, udp_checksum %d",
18162 format_ip4_address, mp->collector_address,
18163 ntohs (mp->collector_port),
18164 format_ip4_address, mp->src_address,
18165 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18166 ntohl (mp->template_interval), mp->udp_checksum);
18169 vam->result_ready = 1;
18173 vl_api_ipfix_exporter_details_t_handler_json
18174 (vl_api_ipfix_exporter_details_t * mp)
18176 vat_main_t *vam = &vat_main;
18177 vat_json_node_t node;
18178 struct in_addr collector_address;
18179 struct in_addr src_address;
18181 vat_json_init_object (&node);
18182 clib_memcpy (&collector_address, &mp->collector_address,
18183 sizeof (collector_address));
18184 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18185 vat_json_object_add_uint (&node, "collector_port",
18186 ntohs (mp->collector_port));
18187 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18188 vat_json_object_add_ip4 (&node, "src_address", src_address);
18189 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18190 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18191 vat_json_object_add_uint (&node, "template_interval",
18192 ntohl (mp->template_interval));
18193 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18195 vat_json_print (vam->ofp, &node);
18196 vat_json_free (&node);
18198 vam->result_ready = 1;
18202 api_ipfix_exporter_dump (vat_main_t * vam)
18204 vl_api_ipfix_exporter_dump_t *mp;
18207 /* Construct the API message */
18208 M (IPFIX_EXPORTER_DUMP, mp);
18217 api_ipfix_classify_stream_dump (vat_main_t * vam)
18219 vl_api_ipfix_classify_stream_dump_t *mp;
18222 /* Construct the API message */
18223 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18234 vl_api_ipfix_classify_stream_details_t_handler
18235 (vl_api_ipfix_classify_stream_details_t * mp)
18237 vat_main_t *vam = &vat_main;
18238 print (vam->ofp, "domain_id %d, src_port %d",
18239 ntohl (mp->domain_id), ntohs (mp->src_port));
18241 vam->result_ready = 1;
18245 vl_api_ipfix_classify_stream_details_t_handler_json
18246 (vl_api_ipfix_classify_stream_details_t * mp)
18248 vat_main_t *vam = &vat_main;
18249 vat_json_node_t node;
18251 vat_json_init_object (&node);
18252 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18253 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18255 vat_json_print (vam->ofp, &node);
18256 vat_json_free (&node);
18258 vam->result_ready = 1;
18262 api_ipfix_classify_table_dump (vat_main_t * vam)
18264 vl_api_ipfix_classify_table_dump_t *mp;
18265 vl_api_control_ping_t *mp_ping;
18268 if (!vam->json_output)
18270 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18271 "transport_protocol");
18274 /* Construct the API message */
18275 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18280 /* Use a control ping for synchronization */
18281 MPING (CONTROL_PING, mp_ping);
18289 vl_api_ipfix_classify_table_details_t_handler
18290 (vl_api_ipfix_classify_table_details_t * mp)
18292 vat_main_t *vam = &vat_main;
18293 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18294 mp->transport_protocol);
18298 vl_api_ipfix_classify_table_details_t_handler_json
18299 (vl_api_ipfix_classify_table_details_t * mp)
18301 vat_json_node_t *node = NULL;
18302 vat_main_t *vam = &vat_main;
18304 if (VAT_JSON_ARRAY != vam->json_tree.type)
18306 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18307 vat_json_init_array (&vam->json_tree);
18310 node = vat_json_array_add (&vam->json_tree);
18311 vat_json_init_object (node);
18313 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18314 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18315 vat_json_object_add_uint (node, "transport_protocol",
18316 mp->transport_protocol);
18320 api_sw_interface_span_enable_disable (vat_main_t * vam)
18322 unformat_input_t *i = vam->input;
18323 vl_api_sw_interface_span_enable_disable_t *mp;
18324 u32 src_sw_if_index = ~0;
18325 u32 dst_sw_if_index = ~0;
18330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18333 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18335 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18339 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18341 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18343 else if (unformat (i, "disable"))
18345 else if (unformat (i, "rx"))
18347 else if (unformat (i, "tx"))
18349 else if (unformat (i, "both"))
18351 else if (unformat (i, "l2"))
18357 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18359 mp->sw_if_index_from = htonl (src_sw_if_index);
18360 mp->sw_if_index_to = htonl (dst_sw_if_index);
18370 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18373 vat_main_t *vam = &vat_main;
18374 u8 *sw_if_from_name = 0;
18375 u8 *sw_if_to_name = 0;
18376 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18377 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18378 char *states[] = { "none", "rx", "tx", "both" };
18382 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18384 if ((u32) p->value[0] == sw_if_index_from)
18386 sw_if_from_name = (u8 *)(p->key);
18390 if ((u32) p->value[0] == sw_if_index_to)
18392 sw_if_to_name = (u8 *)(p->key);
18393 if (sw_if_from_name)
18398 print (vam->ofp, "%20s => %20s (%s) %s",
18399 sw_if_from_name, sw_if_to_name, states[mp->state],
18400 mp->is_l2 ? "l2" : "device");
18404 vl_api_sw_interface_span_details_t_handler_json
18405 (vl_api_sw_interface_span_details_t * mp)
18407 vat_main_t *vam = &vat_main;
18408 vat_json_node_t *node = NULL;
18409 u8 *sw_if_from_name = 0;
18410 u8 *sw_if_to_name = 0;
18411 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18412 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18416 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18418 if ((u32) p->value[0] == sw_if_index_from)
18420 sw_if_from_name = (u8 *)(p->key);
18424 if ((u32) p->value[0] == sw_if_index_to)
18426 sw_if_to_name = (u8 *)(p->key);
18427 if (sw_if_from_name)
18433 if (VAT_JSON_ARRAY != vam->json_tree.type)
18435 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18436 vat_json_init_array (&vam->json_tree);
18438 node = vat_json_array_add (&vam->json_tree);
18440 vat_json_init_object (node);
18441 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18442 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18443 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18444 if (0 != sw_if_to_name)
18446 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18448 vat_json_object_add_uint (node, "state", mp->state);
18449 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18453 api_sw_interface_span_dump (vat_main_t * vam)
18455 unformat_input_t *input = vam->input;
18456 vl_api_sw_interface_span_dump_t *mp;
18457 vl_api_control_ping_t *mp_ping;
18461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18463 if (unformat (input, "l2"))
18469 M (SW_INTERFACE_SPAN_DUMP, mp);
18473 /* Use a control ping for synchronization */
18474 MPING (CONTROL_PING, mp_ping);
18482 api_pg_create_interface (vat_main_t * vam)
18484 unformat_input_t *input = vam->input;
18485 vl_api_pg_create_interface_t *mp;
18487 u32 if_id = ~0, gso_size = 0;
18488 u8 gso_enabled = 0;
18490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18492 if (unformat (input, "if_id %d", &if_id))
18494 else if (unformat (input, "gso-enabled"))
18497 if (unformat (input, "gso-size %u", &gso_size))
18501 errmsg ("missing gso-size");
18510 errmsg ("missing pg interface index");
18514 /* Construct the API message */
18515 M (PG_CREATE_INTERFACE, mp);
18517 mp->interface_id = ntohl (if_id);
18518 mp->gso_enabled = gso_enabled;
18526 api_pg_capture (vat_main_t * vam)
18528 unformat_input_t *input = vam->input;
18529 vl_api_pg_capture_t *mp;
18534 u8 pcap_file_set = 0;
18537 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18539 if (unformat (input, "if_id %d", &if_id))
18541 else if (unformat (input, "pcap %s", &pcap_file))
18543 else if (unformat (input, "count %d", &count))
18545 else if (unformat (input, "disable"))
18552 errmsg ("missing pg interface index");
18555 if (pcap_file_set > 0)
18557 if (vec_len (pcap_file) > 255)
18559 errmsg ("pcap file name is too long");
18564 /* Construct the API message */
18565 M (PG_CAPTURE, mp);
18567 mp->interface_id = ntohl (if_id);
18568 mp->is_enabled = enable;
18569 mp->count = ntohl (count);
18570 if (pcap_file_set != 0)
18572 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
18574 vec_free (pcap_file);
18582 api_pg_enable_disable (vat_main_t * vam)
18584 unformat_input_t *input = vam->input;
18585 vl_api_pg_enable_disable_t *mp;
18588 u8 stream_name_set = 0;
18589 u8 *stream_name = 0;
18591 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18593 if (unformat (input, "stream %s", &stream_name))
18594 stream_name_set = 1;
18595 else if (unformat (input, "disable"))
18601 if (stream_name_set > 0)
18603 if (vec_len (stream_name) > 255)
18605 errmsg ("stream name too long");
18610 /* Construct the API message */
18611 M (PG_ENABLE_DISABLE, mp);
18613 mp->is_enabled = enable;
18614 if (stream_name_set != 0)
18616 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
18618 vec_free (stream_name);
18626 api_pg_interface_enable_disable_coalesce (vat_main_t * vam)
18628 unformat_input_t *input = vam->input;
18629 vl_api_pg_interface_enable_disable_coalesce_t *mp;
18631 u32 sw_if_index = ~0;
18634 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18636 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18638 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18640 else if (unformat (input, "disable"))
18646 if (sw_if_index == ~0)
18648 errmsg ("Interface required but not specified");
18652 /* Construct the API message */
18653 M (PG_INTERFACE_ENABLE_DISABLE_COALESCE, mp);
18655 mp->coalesce_enabled = enable;
18656 mp->sw_if_index = htonl (sw_if_index);
18664 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18666 unformat_input_t *input = vam->input;
18667 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18669 u16 *low_ports = 0;
18670 u16 *high_ports = 0;
18673 vl_api_prefix_t prefix;
18680 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18682 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18684 else if (unformat (input, "vrf %d", &vrf_id))
18686 else if (unformat (input, "del"))
18688 else if (unformat (input, "port %d", &tmp))
18690 if (tmp == 0 || tmp > 65535)
18692 errmsg ("port %d out of range", tmp);
18696 this_hi = this_low + 1;
18697 vec_add1 (low_ports, this_low);
18698 vec_add1 (high_ports, this_hi);
18700 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18702 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18704 errmsg ("incorrect range parameters");
18708 /* Note: in debug CLI +1 is added to high before
18709 passing to real fn that does "the work"
18710 (ip_source_and_port_range_check_add_del).
18711 This fn is a wrapper around the binary API fn a
18712 control plane will call, which expects this increment
18713 to have occurred. Hence letting the binary API control
18714 plane fn do the increment for consistency between VAT
18715 and other control planes.
18718 vec_add1 (low_ports, this_low);
18719 vec_add1 (high_ports, this_hi);
18725 if (prefix_set == 0)
18727 errmsg ("<address>/<mask> not specified");
18733 errmsg ("VRF ID required, not specified");
18740 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18744 if (vec_len (low_ports) == 0)
18746 errmsg ("At least one port or port range required");
18750 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18752 mp->is_add = is_add;
18754 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18756 mp->number_of_ranges = vec_len (low_ports);
18758 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18759 vec_free (low_ports);
18761 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18762 vec_free (high_ports);
18764 mp->vrf_id = ntohl (vrf_id);
18772 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18774 unformat_input_t *input = vam->input;
18775 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18776 u32 sw_if_index = ~0;
18778 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18779 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18783 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18785 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18787 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18789 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18791 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18793 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18795 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18797 else if (unformat (input, "del"))
18803 if (sw_if_index == ~0)
18805 errmsg ("Interface required but not specified");
18811 errmsg ("VRF ID required but not specified");
18815 if (tcp_out_vrf_id == 0
18816 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18819 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18823 /* Construct the API message */
18824 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18826 mp->sw_if_index = ntohl (sw_if_index);
18827 mp->is_add = is_add;
18828 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18829 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18830 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18831 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18836 /* Wait for a reply... */
18842 api_set_punt (vat_main_t * vam)
18844 unformat_input_t *i = vam->input;
18845 vl_api_address_family_t af;
18846 vl_api_set_punt_t *mp;
18852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18854 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18856 else if (unformat (i, "protocol %d", &protocol))
18858 else if (unformat (i, "port %d", &port))
18860 else if (unformat (i, "del"))
18864 clib_warning ("parse error '%U'", format_unformat_error, i);
18871 mp->is_add = (u8) is_add;
18872 mp->punt.type = PUNT_API_TYPE_L4;
18873 mp->punt.punt.l4.af = af;
18874 mp->punt.punt.l4.protocol = (u8) protocol;
18875 mp->punt.punt.l4.port = htons ((u16) port);
18883 api_delete_subif (vat_main_t * vam)
18885 unformat_input_t *i = vam->input;
18886 vl_api_delete_subif_t *mp;
18887 u32 sw_if_index = ~0;
18890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18892 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18894 if (unformat (i, "sw_if_index %d", &sw_if_index))
18900 if (sw_if_index == ~0)
18902 errmsg ("missing sw_if_index");
18906 /* Construct the API message */
18907 M (DELETE_SUBIF, mp);
18908 mp->sw_if_index = ntohl (sw_if_index);
18915 #define foreach_pbb_vtr_op \
18916 _("disable", L2_VTR_DISABLED) \
18917 _("pop", L2_VTR_POP_2) \
18918 _("push", L2_VTR_PUSH_2)
18921 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18923 unformat_input_t *i = vam->input;
18924 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18925 u32 sw_if_index = ~0, vtr_op = ~0;
18926 u16 outer_tag = ~0;
18927 u8 dmac[6], smac[6];
18928 u8 dmac_set = 0, smac_set = 0;
18934 /* Shut up coverity */
18935 clib_memset (dmac, 0, sizeof (dmac));
18936 clib_memset (smac, 0, sizeof (smac));
18938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18940 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18942 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18944 else if (unformat (i, "vtr_op %d", &vtr_op))
18946 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18949 else if (unformat (i, "translate_pbb_stag"))
18951 if (unformat (i, "%d", &tmp))
18953 vtr_op = L2_VTR_TRANSLATE_2_1;
18959 ("translate_pbb_stag operation requires outer tag definition");
18963 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18965 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18967 else if (unformat (i, "sid %d", &sid))
18969 else if (unformat (i, "vlanid %d", &tmp))
18973 clib_warning ("parse error '%U'", format_unformat_error, i);
18978 if ((sw_if_index == ~0) || (vtr_op == ~0))
18980 errmsg ("missing sw_if_index or vtr operation");
18983 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18984 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18987 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18991 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18992 mp->sw_if_index = ntohl (sw_if_index);
18993 mp->vtr_op = ntohl (vtr_op);
18994 mp->outer_tag = ntohs (outer_tag);
18995 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
18996 clib_memcpy (mp->b_smac, smac, sizeof (smac));
18997 mp->b_vlanid = ntohs (vlanid);
18998 mp->i_sid = ntohl (sid);
19006 api_flow_classify_set_interface (vat_main_t * vam)
19008 unformat_input_t *i = vam->input;
19009 vl_api_flow_classify_set_interface_t *mp;
19011 int sw_if_index_set;
19012 u32 ip4_table_index = ~0;
19013 u32 ip6_table_index = ~0;
19017 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19019 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19020 sw_if_index_set = 1;
19021 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19022 sw_if_index_set = 1;
19023 else if (unformat (i, "del"))
19025 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19027 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19031 clib_warning ("parse error '%U'", format_unformat_error, i);
19036 if (sw_if_index_set == 0)
19038 errmsg ("missing interface name or sw_if_index");
19042 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19044 mp->sw_if_index = ntohl (sw_if_index);
19045 mp->ip4_table_index = ntohl (ip4_table_index);
19046 mp->ip6_table_index = ntohl (ip6_table_index);
19047 mp->is_add = is_add;
19055 api_flow_classify_dump (vat_main_t * vam)
19057 unformat_input_t *i = vam->input;
19058 vl_api_flow_classify_dump_t *mp;
19059 vl_api_control_ping_t *mp_ping;
19060 u8 type = FLOW_CLASSIFY_N_TABLES;
19063 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19067 errmsg ("classify table type must be specified");
19071 if (!vam->json_output)
19073 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19076 M (FLOW_CLASSIFY_DUMP, mp);
19081 /* Use a control ping for synchronization */
19082 MPING (CONTROL_PING, mp_ping);
19085 /* Wait for a reply... */
19091 api_feature_enable_disable (vat_main_t * vam)
19093 unformat_input_t *i = vam->input;
19094 vl_api_feature_enable_disable_t *mp;
19096 u8 *feature_name = 0;
19097 u32 sw_if_index = ~0;
19101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19103 if (unformat (i, "arc_name %s", &arc_name))
19105 else if (unformat (i, "feature_name %s", &feature_name))
19108 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19110 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19112 else if (unformat (i, "disable"))
19120 errmsg ("missing arc name");
19123 if (vec_len (arc_name) > 63)
19125 errmsg ("arc name too long");
19128 if (feature_name == 0)
19130 errmsg ("missing feature name");
19133 if (vec_len (feature_name) > 63)
19135 errmsg ("feature name too long");
19138 if (sw_if_index == ~0)
19140 errmsg ("missing interface name or sw_if_index");
19144 /* Construct the API message */
19145 M (FEATURE_ENABLE_DISABLE, mp);
19146 mp->sw_if_index = ntohl (sw_if_index);
19147 mp->enable = enable;
19148 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19149 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19150 vec_free (arc_name);
19151 vec_free (feature_name);
19159 api_feature_gso_enable_disable (vat_main_t * vam)
19161 unformat_input_t *i = vam->input;
19162 vl_api_feature_gso_enable_disable_t *mp;
19163 u32 sw_if_index = ~0;
19167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19169 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19171 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19173 else if (unformat (i, "enable"))
19175 else if (unformat (i, "disable"))
19181 if (sw_if_index == ~0)
19183 errmsg ("missing interface name or sw_if_index");
19187 /* Construct the API message */
19188 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19189 mp->sw_if_index = ntohl (sw_if_index);
19190 mp->enable_disable = enable;
19198 api_sw_interface_tag_add_del (vat_main_t * vam)
19200 unformat_input_t *i = vam->input;
19201 vl_api_sw_interface_tag_add_del_t *mp;
19202 u32 sw_if_index = ~0;
19207 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19209 if (unformat (i, "tag %s", &tag))
19211 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19213 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19215 else if (unformat (i, "del"))
19221 if (sw_if_index == ~0)
19223 errmsg ("missing interface name or sw_if_index");
19227 if (enable && (tag == 0))
19229 errmsg ("no tag specified");
19233 /* Construct the API message */
19234 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19235 mp->sw_if_index = ntohl (sw_if_index);
19236 mp->is_add = enable;
19238 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19247 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19249 unformat_input_t *i = vam->input;
19250 vl_api_mac_address_t mac = { 0 };
19251 vl_api_sw_interface_add_del_mac_address_t *mp;
19252 u32 sw_if_index = ~0;
19257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19259 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19261 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19263 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19265 else if (unformat (i, "del"))
19271 if (sw_if_index == ~0)
19273 errmsg ("missing interface name or sw_if_index");
19279 errmsg ("missing MAC address");
19283 /* Construct the API message */
19284 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19285 mp->sw_if_index = ntohl (sw_if_index);
19286 mp->is_add = is_add;
19287 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19294 static void vl_api_l2_xconnect_details_t_handler
19295 (vl_api_l2_xconnect_details_t * mp)
19297 vat_main_t *vam = &vat_main;
19299 print (vam->ofp, "%15d%15d",
19300 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19303 static void vl_api_l2_xconnect_details_t_handler_json
19304 (vl_api_l2_xconnect_details_t * mp)
19306 vat_main_t *vam = &vat_main;
19307 vat_json_node_t *node = NULL;
19309 if (VAT_JSON_ARRAY != vam->json_tree.type)
19311 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19312 vat_json_init_array (&vam->json_tree);
19314 node = vat_json_array_add (&vam->json_tree);
19316 vat_json_init_object (node);
19317 vat_json_object_add_uint (node, "rx_sw_if_index",
19318 ntohl (mp->rx_sw_if_index));
19319 vat_json_object_add_uint (node, "tx_sw_if_index",
19320 ntohl (mp->tx_sw_if_index));
19324 api_l2_xconnect_dump (vat_main_t * vam)
19326 vl_api_l2_xconnect_dump_t *mp;
19327 vl_api_control_ping_t *mp_ping;
19330 if (!vam->json_output)
19332 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19335 M (L2_XCONNECT_DUMP, mp);
19339 /* Use a control ping for synchronization */
19340 MPING (CONTROL_PING, mp_ping);
19348 api_hw_interface_set_mtu (vat_main_t * vam)
19350 unformat_input_t *i = vam->input;
19351 vl_api_hw_interface_set_mtu_t *mp;
19352 u32 sw_if_index = ~0;
19356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19358 if (unformat (i, "mtu %d", &mtu))
19360 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19362 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19368 if (sw_if_index == ~0)
19370 errmsg ("missing interface name or sw_if_index");
19376 errmsg ("no mtu specified");
19380 /* Construct the API message */
19381 M (HW_INTERFACE_SET_MTU, mp);
19382 mp->sw_if_index = ntohl (sw_if_index);
19383 mp->mtu = ntohs ((u16) mtu);
19391 api_p2p_ethernet_add (vat_main_t * vam)
19393 unformat_input_t *i = vam->input;
19394 vl_api_p2p_ethernet_add_t *mp;
19395 u32 parent_if_index = ~0;
19401 clib_memset (remote_mac, 0, sizeof (remote_mac));
19402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19404 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19406 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19410 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19412 else if (unformat (i, "sub_id %d", &sub_id))
19416 clib_warning ("parse error '%U'", format_unformat_error, i);
19421 if (parent_if_index == ~0)
19423 errmsg ("missing interface name or sw_if_index");
19428 errmsg ("missing remote mac address");
19433 errmsg ("missing sub-interface id");
19437 M (P2P_ETHERNET_ADD, mp);
19438 mp->parent_if_index = ntohl (parent_if_index);
19439 mp->subif_id = ntohl (sub_id);
19440 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19448 api_p2p_ethernet_del (vat_main_t * vam)
19450 unformat_input_t *i = vam->input;
19451 vl_api_p2p_ethernet_del_t *mp;
19452 u32 parent_if_index = ~0;
19457 clib_memset (remote_mac, 0, sizeof (remote_mac));
19458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19460 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19462 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19466 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19470 clib_warning ("parse error '%U'", format_unformat_error, i);
19475 if (parent_if_index == ~0)
19477 errmsg ("missing interface name or sw_if_index");
19482 errmsg ("missing remote mac address");
19486 M (P2P_ETHERNET_DEL, mp);
19487 mp->parent_if_index = ntohl (parent_if_index);
19488 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19496 api_lldp_config (vat_main_t * vam)
19498 unformat_input_t *i = vam->input;
19499 vl_api_lldp_config_t *mp;
19501 int tx_interval = 0;
19502 u8 *sys_name = NULL;
19505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19507 if (unformat (i, "system-name %s", &sys_name))
19509 else if (unformat (i, "tx-hold %d", &tx_hold))
19511 else if (unformat (i, "tx-interval %d", &tx_interval))
19515 clib_warning ("parse error '%U'", format_unformat_error, i);
19520 vec_add1 (sys_name, 0);
19522 M (LLDP_CONFIG, mp);
19523 mp->tx_hold = htonl (tx_hold);
19524 mp->tx_interval = htonl (tx_interval);
19525 vl_api_vec_to_api_string (sys_name, &mp->system_name);
19526 vec_free (sys_name);
19534 api_sw_interface_set_lldp (vat_main_t * vam)
19536 unformat_input_t *i = vam->input;
19537 vl_api_sw_interface_set_lldp_t *mp;
19538 u32 sw_if_index = ~0;
19540 u8 *port_desc = NULL, *mgmt_oid = NULL;
19541 ip4_address_t ip4_addr;
19542 ip6_address_t ip6_addr;
19545 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19546 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19550 if (unformat (i, "disable"))
19553 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19555 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19557 else if (unformat (i, "port-desc %s", &port_desc))
19559 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19561 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19563 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19569 if (sw_if_index == ~0)
19571 errmsg ("missing interface name or sw_if_index");
19575 /* Construct the API message */
19576 vec_add1 (port_desc, 0);
19577 vec_add1 (mgmt_oid, 0);
19578 M (SW_INTERFACE_SET_LLDP, mp);
19579 mp->sw_if_index = ntohl (sw_if_index);
19580 mp->enable = enable;
19581 vl_api_vec_to_api_string (port_desc, &mp->port_desc);
19582 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19583 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19584 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19585 vec_free (port_desc);
19586 vec_free (mgmt_oid);
19594 api_tcp_configure_src_addresses (vat_main_t * vam)
19596 vl_api_tcp_configure_src_addresses_t *mp;
19597 unformat_input_t *i = vam->input;
19598 vl_api_address_t first, last;
19603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19605 if (unformat (i, "%U - %U",
19606 unformat_vl_api_address, &first,
19607 unformat_vl_api_address, &last))
19611 errmsg ("one range per message (range already set)");
19616 else if (unformat (i, "vrf %d", &vrf_id))
19622 if (range_set == 0)
19624 errmsg ("address range not set");
19628 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19630 mp->vrf_id = ntohl (vrf_id);
19631 clib_memcpy (&mp->first_address, &first, sizeof (first));
19632 clib_memcpy (&mp->last_address, &last, sizeof (last));
19639 static void vl_api_app_namespace_add_del_reply_t_handler
19640 (vl_api_app_namespace_add_del_reply_t * mp)
19642 vat_main_t *vam = &vat_main;
19643 i32 retval = ntohl (mp->retval);
19644 if (vam->async_mode)
19646 vam->async_errors += (retval < 0);
19650 vam->retval = retval;
19652 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19653 vam->result_ready = 1;
19657 static void vl_api_app_namespace_add_del_reply_t_handler_json
19658 (vl_api_app_namespace_add_del_reply_t * mp)
19660 vat_main_t *vam = &vat_main;
19661 vat_json_node_t node;
19663 vat_json_init_object (&node);
19664 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19665 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19667 vat_json_print (vam->ofp, &node);
19668 vat_json_free (&node);
19670 vam->retval = ntohl (mp->retval);
19671 vam->result_ready = 1;
19675 api_app_namespace_add_del (vat_main_t * vam)
19677 vl_api_app_namespace_add_del_t *mp;
19678 unformat_input_t *i = vam->input;
19679 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19680 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19686 if (unformat (i, "id %_%v%_", &ns_id))
19688 else if (unformat (i, "secret %lu", &secret))
19690 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19691 sw_if_index_set = 1;
19692 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19694 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19699 if (!ns_id || !secret_set || !sw_if_index_set)
19701 errmsg ("namespace id, secret and sw_if_index must be set");
19704 if (vec_len (ns_id) > 64)
19706 errmsg ("namespace id too long");
19709 M (APP_NAMESPACE_ADD_DEL, mp);
19711 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
19712 mp->secret = clib_host_to_net_u64 (secret);
19713 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19714 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19715 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19723 api_sock_init_shm (vat_main_t * vam)
19725 #if VPP_API_TEST_BUILTIN == 0
19726 unformat_input_t *i = vam->input;
19727 vl_api_shm_elem_config_t *config = 0;
19728 u64 size = 64 << 20;
19731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19733 if (unformat (i, "size %U", unformat_memory_size, &size))
19740 * Canned custom ring allocator config.
19741 * Should probably parse all of this
19743 vec_validate (config, 6);
19744 config[0].type = VL_API_VLIB_RING;
19745 config[0].size = 256;
19746 config[0].count = 32;
19748 config[1].type = VL_API_VLIB_RING;
19749 config[1].size = 1024;
19750 config[1].count = 16;
19752 config[2].type = VL_API_VLIB_RING;
19753 config[2].size = 4096;
19754 config[2].count = 2;
19756 config[3].type = VL_API_CLIENT_RING;
19757 config[3].size = 256;
19758 config[3].count = 32;
19760 config[4].type = VL_API_CLIENT_RING;
19761 config[4].size = 1024;
19762 config[4].count = 16;
19764 config[5].type = VL_API_CLIENT_RING;
19765 config[5].size = 4096;
19766 config[5].count = 2;
19768 config[6].type = VL_API_QUEUE;
19769 config[6].count = 128;
19770 config[6].size = sizeof (uword);
19772 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19774 vam->client_index_invalid = 1;
19782 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19784 vat_main_t *vam = &vat_main;
19785 fib_prefix_t lcl, rmt;
19787 ip_prefix_decode (&mp->lcl, &lcl);
19788 ip_prefix_decode (&mp->rmt, &rmt);
19790 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19793 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19794 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19795 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
19796 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19797 &rmt.fp_addr.ip4, rmt.fp_len,
19798 clib_net_to_host_u16 (mp->rmt_port),
19799 clib_net_to_host_u32 (mp->action_index), mp->tag);
19804 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19805 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19806 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
19807 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19808 &rmt.fp_addr.ip6, rmt.fp_len,
19809 clib_net_to_host_u16 (mp->rmt_port),
19810 clib_net_to_host_u32 (mp->action_index), mp->tag);
19815 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19818 vat_main_t *vam = &vat_main;
19819 vat_json_node_t *node = NULL;
19820 struct in6_addr ip6;
19821 struct in_addr ip4;
19823 fib_prefix_t lcl, rmt;
19825 ip_prefix_decode (&mp->lcl, &lcl);
19826 ip_prefix_decode (&mp->rmt, &rmt);
19828 if (VAT_JSON_ARRAY != vam->json_tree.type)
19830 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19831 vat_json_init_array (&vam->json_tree);
19833 node = vat_json_array_add (&vam->json_tree);
19834 vat_json_init_object (node);
19836 vat_json_object_add_uint (node, "appns_index",
19837 clib_net_to_host_u32 (mp->appns_index));
19838 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19839 vat_json_object_add_uint (node, "scope", mp->scope);
19840 vat_json_object_add_uint (node, "action_index",
19841 clib_net_to_host_u32 (mp->action_index));
19842 vat_json_object_add_uint (node, "lcl_port",
19843 clib_net_to_host_u16 (mp->lcl_port));
19844 vat_json_object_add_uint (node, "rmt_port",
19845 clib_net_to_host_u16 (mp->rmt_port));
19846 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
19847 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
19848 vat_json_object_add_string_copy (node, "tag", mp->tag);
19849 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19851 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
19852 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19853 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
19854 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19858 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
19859 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19860 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
19861 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19866 api_session_rule_add_del (vat_main_t * vam)
19868 vl_api_session_rule_add_del_t *mp;
19869 unformat_input_t *i = vam->input;
19870 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19871 u32 appns_index = 0, scope = 0;
19872 ip4_address_t lcl_ip4, rmt_ip4;
19873 ip6_address_t lcl_ip6, rmt_ip6;
19874 u8 is_ip4 = 1, conn_set = 0;
19875 u8 is_add = 1, *tag = 0;
19877 fib_prefix_t lcl, rmt;
19879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19881 if (unformat (i, "del"))
19883 else if (unformat (i, "add"))
19885 else if (unformat (i, "proto tcp"))
19887 else if (unformat (i, "proto udp"))
19889 else if (unformat (i, "appns %d", &appns_index))
19891 else if (unformat (i, "scope %d", &scope))
19893 else if (unformat (i, "tag %_%v%_", &tag))
19897 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19898 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19906 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19907 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19913 else if (unformat (i, "action %d", &action))
19918 if (proto == ~0 || !conn_set || action == ~0)
19920 errmsg ("transport proto, connection and action must be set");
19926 errmsg ("scope should be 0-3");
19930 M (SESSION_RULE_ADD_DEL, mp);
19932 clib_memset (&lcl, 0, sizeof (lcl));
19933 clib_memset (&rmt, 0, sizeof (rmt));
19936 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
19937 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
19938 lcl.fp_len = lcl_plen;
19939 rmt.fp_len = rmt_plen;
19943 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
19944 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
19945 lcl.fp_len = lcl_plen;
19946 rmt.fp_len = rmt_plen;
19950 ip_prefix_encode (&lcl, &mp->lcl);
19951 ip_prefix_encode (&rmt, &mp->rmt);
19952 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19953 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19954 mp->transport_proto =
19955 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
19956 mp->action_index = clib_host_to_net_u32 (action);
19957 mp->appns_index = clib_host_to_net_u32 (appns_index);
19959 mp->is_add = is_add;
19962 clib_memcpy (mp->tag, tag, vec_len (tag));
19972 api_session_rules_dump (vat_main_t * vam)
19974 vl_api_session_rules_dump_t *mp;
19975 vl_api_control_ping_t *mp_ping;
19978 if (!vam->json_output)
19980 print (vam->ofp, "%=20s", "Session Rules");
19983 M (SESSION_RULES_DUMP, mp);
19987 /* Use a control ping for synchronization */
19988 MPING (CONTROL_PING, mp_ping);
19991 /* Wait for a reply... */
19997 api_ip_container_proxy_add_del (vat_main_t * vam)
19999 vl_api_ip_container_proxy_add_del_t *mp;
20000 unformat_input_t *i = vam->input;
20001 u32 sw_if_index = ~0;
20002 vl_api_prefix_t pfx = { };
20006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20008 if (unformat (i, "del"))
20010 else if (unformat (i, "add"))
20012 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20014 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20019 if (sw_if_index == ~0 || pfx.len == 0)
20021 errmsg ("address and sw_if_index must be set");
20025 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20027 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20028 mp->is_add = is_add;
20029 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20037 api_qos_record_enable_disable (vat_main_t * vam)
20039 unformat_input_t *i = vam->input;
20040 vl_api_qos_record_enable_disable_t *mp;
20041 u32 sw_if_index, qs = 0xff;
20042 u8 sw_if_index_set = 0;
20046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20048 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20049 sw_if_index_set = 1;
20050 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20051 sw_if_index_set = 1;
20052 else if (unformat (i, "%U", unformat_qos_source, &qs))
20054 else if (unformat (i, "disable"))
20058 clib_warning ("parse error '%U'", format_unformat_error, i);
20063 if (sw_if_index_set == 0)
20065 errmsg ("missing interface name or sw_if_index");
20070 errmsg ("input location must be specified");
20074 M (QOS_RECORD_ENABLE_DISABLE, mp);
20076 mp->record.sw_if_index = ntohl (sw_if_index);
20077 mp->record.input_source = qs;
20078 mp->enable = enable;
20087 q_or_quit (vat_main_t * vam)
20089 #if VPP_API_TEST_BUILTIN == 0
20090 longjmp (vam->jump_buf, 1);
20092 return 0; /* not so much */
20096 q (vat_main_t * vam)
20098 return q_or_quit (vam);
20102 quit (vat_main_t * vam)
20104 return q_or_quit (vam);
20108 comment (vat_main_t * vam)
20114 elog_save (vat_main_t * vam)
20116 #if VPP_API_TEST_BUILTIN == 0
20117 elog_main_t *em = &vam->elog_main;
20118 unformat_input_t *i = vam->input;
20119 char *file, *chroot_file;
20120 clib_error_t *error;
20122 if (!unformat (i, "%s", &file))
20124 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20128 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20129 if (strstr (file, "..") || index (file, '/'))
20131 errmsg ("illegal characters in filename '%s'", file);
20135 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20139 errmsg ("Saving %wd of %wd events to %s",
20140 elog_n_events_in_buffer (em),
20141 elog_buffer_capacity (em), chroot_file);
20143 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20144 vec_free (chroot_file);
20147 clib_error_report (error);
20149 errmsg ("Use the vpp event loger...");
20156 elog_setup (vat_main_t * vam)
20158 #if VPP_API_TEST_BUILTIN == 0
20159 elog_main_t *em = &vam->elog_main;
20160 unformat_input_t *i = vam->input;
20161 u32 nevents = 128 << 10;
20163 (void) unformat (i, "nevents %d", &nevents);
20165 elog_init (em, nevents);
20166 vl_api_set_elog_main (em);
20167 vl_api_set_elog_trace_api_messages (1);
20168 errmsg ("Event logger initialized with %u events", nevents);
20170 errmsg ("Use the vpp event loger...");
20176 elog_enable (vat_main_t * vam)
20178 #if VPP_API_TEST_BUILTIN == 0
20179 elog_main_t *em = &vam->elog_main;
20181 elog_enable_disable (em, 1 /* enable */ );
20182 vl_api_set_elog_trace_api_messages (1);
20183 errmsg ("Event logger enabled...");
20185 errmsg ("Use the vpp event loger...");
20191 elog_disable (vat_main_t * vam)
20193 #if VPP_API_TEST_BUILTIN == 0
20194 elog_main_t *em = &vam->elog_main;
20196 elog_enable_disable (em, 0 /* enable */ );
20197 vl_api_set_elog_trace_api_messages (1);
20198 errmsg ("Event logger disabled...");
20200 errmsg ("Use the vpp event loger...");
20206 statseg (vat_main_t * vam)
20208 ssvm_private_t *ssvmp = &vam->stat_segment;
20209 ssvm_shared_header_t *shared_header = ssvmp->sh;
20210 vlib_counter_t **counters;
20211 u64 thread0_index1_packets;
20212 u64 thread0_index1_bytes;
20213 f64 vector_rate, input_rate;
20216 uword *counter_vector_by_name;
20217 if (vam->stat_segment_lockp == 0)
20219 errmsg ("Stat segment not mapped...");
20223 /* look up "/if/rx for sw_if_index 1 as a test */
20225 clib_spinlock_lock (vam->stat_segment_lockp);
20227 counter_vector_by_name = (uword *) shared_header->opaque[1];
20229 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20232 clib_spinlock_unlock (vam->stat_segment_lockp);
20233 errmsg ("/if/tx not found?");
20237 /* Fish per-thread vector of combined counters from shared memory */
20238 counters = (vlib_counter_t **) p[0];
20240 if (vec_len (counters[0]) < 2)
20242 clib_spinlock_unlock (vam->stat_segment_lockp);
20243 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20247 /* Read thread 0 sw_if_index 1 counter */
20248 thread0_index1_packets = counters[0][1].packets;
20249 thread0_index1_bytes = counters[0][1].bytes;
20251 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20254 clib_spinlock_unlock (vam->stat_segment_lockp);
20255 errmsg ("vector_rate not found?");
20259 vector_rate = *(f64 *) (p[0]);
20260 p = hash_get_mem (counter_vector_by_name, "input_rate");
20263 clib_spinlock_unlock (vam->stat_segment_lockp);
20264 errmsg ("input_rate not found?");
20267 input_rate = *(f64 *) (p[0]);
20269 clib_spinlock_unlock (vam->stat_segment_lockp);
20271 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20272 vector_rate, input_rate);
20273 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20274 thread0_index1_packets, thread0_index1_bytes);
20280 cmd_cmp (void *a1, void *a2)
20285 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20289 help (vat_main_t * vam)
20294 unformat_input_t *i = vam->input;
20297 if (unformat (i, "%s", &name))
20301 vec_add1 (name, 0);
20303 hs = hash_get_mem (vam->help_by_name, name);
20305 print (vam->ofp, "usage: %s %s", name, hs[0]);
20307 print (vam->ofp, "No such msg / command '%s'", name);
20312 print (vam->ofp, "Help is available for the following:");
20315 hash_foreach_pair (p, vam->function_by_name,
20317 vec_add1 (cmds, (u8 *)(p->key));
20321 vec_sort_with_function (cmds, cmd_cmp);
20323 for (j = 0; j < vec_len (cmds); j++)
20324 print (vam->ofp, "%s", cmds[j]);
20331 set (vat_main_t * vam)
20333 u8 *name = 0, *value = 0;
20334 unformat_input_t *i = vam->input;
20336 if (unformat (i, "%s", &name))
20338 /* The input buffer is a vector, not a string. */
20339 value = vec_dup (i->buffer);
20340 vec_delete (value, i->index, 0);
20341 /* Almost certainly has a trailing newline */
20342 if (value[vec_len (value) - 1] == '\n')
20343 value[vec_len (value) - 1] = 0;
20344 /* Make sure it's a proper string, one way or the other */
20345 vec_add1 (value, 0);
20346 (void) clib_macro_set_value (&vam->macro_main,
20347 (char *) name, (char *) value);
20350 errmsg ("usage: set <name> <value>");
20358 unset (vat_main_t * vam)
20362 if (unformat (vam->input, "%s", &name))
20363 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20364 errmsg ("unset: %s wasn't set", name);
20377 macro_sort_cmp (void *a1, void *a2)
20379 macro_sort_t *s1 = a1;
20380 macro_sort_t *s2 = a2;
20382 return strcmp ((char *) (s1->name), (char *) (s2->name));
20386 dump_macro_table (vat_main_t * vam)
20388 macro_sort_t *sort_me = 0, *sm;
20393 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20395 vec_add2 (sort_me, sm, 1);
20396 sm->name = (u8 *)(p->key);
20397 sm->value = (u8 *) (p->value[0]);
20401 vec_sort_with_function (sort_me, macro_sort_cmp);
20403 if (vec_len (sort_me))
20404 print (vam->ofp, "%-15s%s", "Name", "Value");
20406 print (vam->ofp, "The macro table is empty...");
20408 for (i = 0; i < vec_len (sort_me); i++)
20409 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20414 dump_node_table (vat_main_t * vam)
20417 vlib_node_t *node, *next_node;
20419 if (vec_len (vam->graph_nodes) == 0)
20421 print (vam->ofp, "Node table empty, issue get_node_graph...");
20425 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20427 node = vam->graph_nodes[0][i];
20428 print (vam->ofp, "[%d] %s", i, node->name);
20429 for (j = 0; j < vec_len (node->next_nodes); j++)
20431 if (node->next_nodes[j] != ~0)
20433 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20434 print (vam->ofp, " [%d] %s", j, next_node->name);
20442 value_sort_cmp (void *a1, void *a2)
20444 name_sort_t *n1 = a1;
20445 name_sort_t *n2 = a2;
20447 if (n1->value < n2->value)
20449 if (n1->value > n2->value)
20456 dump_msg_api_table (vat_main_t * vam)
20458 api_main_t *am = vlibapi_get_main ();
20459 name_sort_t *nses = 0, *ns;
20464 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20466 vec_add2 (nses, ns, 1);
20467 ns->name = (u8 *)(hp->key);
20468 ns->value = (u32) hp->value[0];
20472 vec_sort_with_function (nses, value_sort_cmp);
20474 for (i = 0; i < vec_len (nses); i++)
20475 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20481 get_msg_id (vat_main_t * vam)
20486 if (unformat (vam->input, "%s", &name_and_crc))
20488 message_index = vl_msg_api_get_msg_index (name_and_crc);
20489 if (message_index == ~0)
20491 print (vam->ofp, " '%s' not found", name_and_crc);
20494 print (vam->ofp, " '%s' has message index %d",
20495 name_and_crc, message_index);
20498 errmsg ("name_and_crc required...");
20503 search_node_table (vat_main_t * vam)
20505 unformat_input_t *line_input = vam->input;
20508 vlib_node_t *node, *next_node;
20511 if (vam->graph_node_index_by_name == 0)
20513 print (vam->ofp, "Node table empty, issue get_node_graph...");
20517 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20519 if (unformat (line_input, "%s", &node_to_find))
20521 vec_add1 (node_to_find, 0);
20522 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20525 print (vam->ofp, "%s not found...", node_to_find);
20528 node = vam->graph_nodes[0][p[0]];
20529 print (vam->ofp, "[%d] %s", p[0], node->name);
20530 for (j = 0; j < vec_len (node->next_nodes); j++)
20532 if (node->next_nodes[j] != ~0)
20534 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20535 print (vam->ofp, " [%d] %s", j, next_node->name);
20542 clib_warning ("parse error '%U'", format_unformat_error,
20548 vec_free (node_to_find);
20557 script (vat_main_t * vam)
20559 #if (VPP_API_TEST_BUILTIN==0)
20561 char *save_current_file;
20562 unformat_input_t save_input;
20563 jmp_buf save_jump_buf;
20564 u32 save_line_number;
20566 FILE *new_fp, *save_ifp;
20568 if (unformat (vam->input, "%s", &s))
20570 new_fp = fopen ((char *) s, "r");
20573 errmsg ("Couldn't open script file %s", s);
20580 errmsg ("Missing script name");
20584 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20585 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20586 save_ifp = vam->ifp;
20587 save_line_number = vam->input_line_number;
20588 save_current_file = (char *) vam->current_file;
20590 vam->input_line_number = 0;
20592 vam->current_file = s;
20595 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20596 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20597 vam->ifp = save_ifp;
20598 vam->input_line_number = save_line_number;
20599 vam->current_file = (u8 *) save_current_file;
20604 clib_warning ("use the exec command...");
20610 echo (vat_main_t * vam)
20612 print (vam->ofp, "%v", vam->input->buffer);
20616 /* List of API message constructors, CLI names map to api_xxx */
20617 #define foreach_vpe_api_msg \
20618 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20619 _(sw_interface_dump,"") \
20620 _(sw_interface_set_flags, \
20621 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20622 _(sw_interface_add_del_address, \
20623 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20624 _(sw_interface_set_rx_mode, \
20625 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20626 _(sw_interface_set_rx_placement, \
20627 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20628 _(sw_interface_rx_placement_dump, \
20629 "[<intfc> | sw_if_index <id>]") \
20630 _(sw_interface_set_table, \
20631 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20632 _(sw_interface_set_mpls_enable, \
20633 "<intfc> | sw_if_index [disable | dis]") \
20634 _(sw_interface_set_vpath, \
20635 "<intfc> | sw_if_index <id> enable | disable") \
20636 _(sw_interface_set_vxlan_bypass, \
20637 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20638 _(sw_interface_set_geneve_bypass, \
20639 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20640 _(sw_interface_set_l2_xconnect, \
20641 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20642 "enable | disable") \
20643 _(sw_interface_set_l2_bridge, \
20644 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20645 "[shg <split-horizon-group>] [bvi]\n" \
20646 "enable | disable") \
20647 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20648 _(bridge_domain_add_del, \
20649 "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") \
20650 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20652 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20653 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20654 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20656 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20658 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20660 "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]") \
20662 "<vpp-if-name> | sw_if_index <id>") \
20663 _(sw_interface_tap_v2_dump, "") \
20664 _(virtio_pci_create, \
20665 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20666 _(virtio_pci_delete, \
20667 "<vpp-if-name> | sw_if_index <id>") \
20668 _(sw_interface_virtio_pci_dump, "") \
20670 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20671 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20674 "<vpp-if-name> | sw_if_index <id>") \
20675 _(bond_add_member, \
20676 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20677 _(bond_detach_member, \
20678 "sw_if_index <n>") \
20679 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20680 _(sw_bond_interface_dump, "<intfc> | sw_if_index <nn>") \
20681 _(sw_member_interface_dump, \
20682 "<vpp-if-name> | sw_if_index <id>") \
20683 _(ip_table_add_del, \
20684 "table <n> [ipv6] [add | del]\n") \
20685 _(ip_route_add_del, \
20686 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20687 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20688 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20689 "[multipath] [count <n>] [del]") \
20690 _(ip_mroute_add_del, \
20691 "<src> <grp>/<mask> [table-id <n>]\n" \
20692 "[<intfc> | sw_if_index <id>] [local] [del]") \
20693 _(mpls_table_add_del, \
20694 "table <n> [add | del]\n") \
20695 _(mpls_route_add_del, \
20696 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20697 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20698 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20699 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20700 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20701 "[count <n>] [del]") \
20702 _(mpls_ip_bind_unbind, \
20703 "<label> <addr/len>") \
20704 _(mpls_tunnel_add_del, \
20705 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20706 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20707 "[l2-only] [out-label <n>]") \
20708 _(sr_mpls_policy_add, \
20709 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20710 _(sr_mpls_policy_del, \
20712 _(bier_table_add_del, \
20713 "<label> <sub-domain> <set> <bsl> [del]") \
20714 _(bier_route_add_del, \
20715 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20716 "[<intfc> | sw_if_index <id>]" \
20717 "[weight <n>] [del] [multipath]") \
20718 _(sw_interface_set_unnumbered, \
20719 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20720 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20721 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20722 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20723 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20724 "[outer_vlan_id_any][inner_vlan_id_any]") \
20725 _(ip_table_replace_begin, "table <n> [ipv6]") \
20726 _(ip_table_flush, "table <n> [ipv6]") \
20727 _(ip_table_replace_end, "table <n> [ipv6]") \
20728 _(set_ip_flow_hash, \
20729 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20730 _(sw_interface_ip6_enable_disable, \
20731 "<intfc> | sw_if_index <id> enable | disable") \
20732 _(l2_patch_add_del, \
20733 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20734 "enable | disable") \
20735 _(sr_localsid_add_del, \
20736 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20737 "fib-table <num> (end.psp) sw_if_index <num>") \
20738 _(classify_add_del_table, \
20739 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20740 " [del] [del-chain] mask <mask-value>\n" \
20741 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20742 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20743 _(classify_add_del_session, \
20744 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20745 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20746 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20747 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20748 _(classify_set_interface_ip_table, \
20749 "<intfc> | sw_if_index <nn> table <nn>") \
20750 _(classify_set_interface_l2_tables, \
20751 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20752 " [other-table <nn>]") \
20753 _(get_node_index, "node <node-name") \
20754 _(add_node_next, "node <node-name> next <next-node-name>") \
20755 _(l2tpv3_create_tunnel, \
20756 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20757 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20758 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20759 _(l2tpv3_set_tunnel_cookies, \
20760 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20761 "[new_remote_cookie <nn>]\n") \
20762 _(l2tpv3_interface_enable_disable, \
20763 "<intfc> | sw_if_index <nn> enable | disable") \
20764 _(l2tpv3_set_lookup_key, \
20765 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20766 _(sw_if_l2tpv3_tunnel_dump, "") \
20767 _(vxlan_offload_rx, \
20768 "hw { <interface name> | hw_if_index <nn>} " \
20769 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20770 _(vxlan_add_del_tunnel, \
20771 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20772 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20773 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20774 _(geneve_add_del_tunnel, \
20775 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20776 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20777 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20778 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20779 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20780 _(gre_tunnel_add_del, \
20781 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20782 "[teb | erspan <session-id>] [del]") \
20783 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20784 _(l2_fib_clear_table, "") \
20785 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20786 _(l2_interface_vlan_tag_rewrite, \
20787 "<intfc> | sw_if_index <nn> \n" \
20788 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20789 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20790 _(create_vhost_user_if, \
20791 "socket <filename> [server] [renumber <dev_instance>] " \
20792 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20793 "[mac <mac_address>] [packed]") \
20794 _(modify_vhost_user_if, \
20795 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20796 "[server] [renumber <dev_instance>] [gso] [packed]") \
20797 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20798 _(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
20799 _(show_version, "") \
20800 _(show_threads, "") \
20801 _(vxlan_gpe_add_del_tunnel, \
20802 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20803 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20804 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20805 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20806 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20807 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20808 _(interface_name_renumber, \
20809 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20810 _(input_acl_set_interface, \
20811 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20812 " [l2-table <nn>] [del]") \
20813 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20814 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20815 _(ip_dump, "ipv4 | ipv6") \
20816 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20817 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20819 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20820 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20821 " integ_alg <alg> integ_key <hex>") \
20822 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20823 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20824 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20825 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20826 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20827 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20828 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20829 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20830 " [instance <n>]") \
20831 _(ipsec_sa_dump, "[sa_id <n>]") \
20832 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20833 _(delete_loopback,"sw_if_index <nn>") \
20834 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20835 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20836 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20837 _(want_interface_events, "enable|disable") \
20838 _(get_first_msg_id, "client <name>") \
20839 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20840 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20841 "fib-id <nn> [ip4][ip6][default]") \
20842 _(get_node_graph, " ") \
20843 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20844 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20845 _(ioam_disable, "") \
20846 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20847 " sw_if_index <sw_if_index> p <priority> " \
20848 "w <weight>] [del]") \
20849 _(one_add_del_locator, "locator-set <locator_name> " \
20850 "iface <intf> | sw_if_index <sw_if_index> " \
20851 "p <priority> w <weight> [del]") \
20852 _(one_add_del_local_eid,"vni <vni> eid " \
20853 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20854 "locator-set <locator_name> [del]" \
20855 "[key-id sha1|sha256 secret-key <secret-key>]")\
20856 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20857 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20858 _(one_enable_disable, "enable|disable") \
20859 _(one_map_register_enable_disable, "enable|disable") \
20860 _(one_map_register_fallback_threshold, "<value>") \
20861 _(one_rloc_probe_enable_disable, "enable|disable") \
20862 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20864 "rloc <locator> p <prio> " \
20865 "w <weight> [rloc <loc> ... ] " \
20866 "action <action> [del-all]") \
20867 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20869 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20870 _(one_use_petr, "ip-address> | disable") \
20871 _(one_map_request_mode, "src-dst|dst-only") \
20872 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20873 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20874 _(one_locator_set_dump, "[local | remote]") \
20875 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20876 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20877 "[local] | [remote]") \
20878 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20879 _(one_ndp_bd_get, "") \
20880 _(one_ndp_entries_get, "bd <bridge-domain>") \
20881 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20882 _(one_l2_arp_bd_get, "") \
20883 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20884 _(one_stats_enable_disable, "enable|disable") \
20885 _(show_one_stats_enable_disable, "") \
20886 _(one_eid_table_vni_dump, "") \
20887 _(one_eid_table_map_dump, "l2|l3") \
20888 _(one_map_resolver_dump, "") \
20889 _(one_map_server_dump, "") \
20890 _(one_adjacencies_get, "vni <vni>") \
20891 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20892 _(show_one_rloc_probe_state, "") \
20893 _(show_one_map_register_state, "") \
20894 _(show_one_status, "") \
20895 _(one_stats_dump, "") \
20896 _(one_stats_flush, "") \
20897 _(one_get_map_request_itr_rlocs, "") \
20898 _(one_map_register_set_ttl, "<ttl>") \
20899 _(one_set_transport_protocol, "udp|api") \
20900 _(one_get_transport_protocol, "") \
20901 _(one_enable_disable_xtr_mode, "enable|disable") \
20902 _(one_show_xtr_mode, "") \
20903 _(one_enable_disable_pitr_mode, "enable|disable") \
20904 _(one_show_pitr_mode, "") \
20905 _(one_enable_disable_petr_mode, "enable|disable") \
20906 _(one_show_petr_mode, "") \
20907 _(show_one_nsh_mapping, "") \
20908 _(show_one_pitr, "") \
20909 _(show_one_use_petr, "") \
20910 _(show_one_map_request_mode, "") \
20911 _(show_one_map_register_ttl, "") \
20912 _(show_one_map_register_fallback_threshold, "") \
20913 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20914 " sw_if_index <sw_if_index> p <priority> " \
20915 "w <weight>] [del]") \
20916 _(lisp_add_del_locator, "locator-set <locator_name> " \
20917 "iface <intf> | sw_if_index <sw_if_index> " \
20918 "p <priority> w <weight> [del]") \
20919 _(lisp_add_del_local_eid,"vni <vni> eid " \
20920 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20921 "locator-set <locator_name> [del]" \
20922 "[key-id sha1|sha256 secret-key <secret-key>]") \
20923 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20924 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20925 _(lisp_enable_disable, "enable|disable") \
20926 _(lisp_map_register_enable_disable, "enable|disable") \
20927 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20928 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20930 "rloc <locator> p <prio> " \
20931 "w <weight> [rloc <loc> ... ] " \
20932 "action <action> [del-all]") \
20933 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20935 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20936 _(lisp_use_petr, "<ip-address> | disable") \
20937 _(lisp_map_request_mode, "src-dst|dst-only") \
20938 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20939 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20940 _(lisp_locator_set_dump, "[local | remote]") \
20941 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20942 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20943 "[local] | [remote]") \
20944 _(lisp_eid_table_vni_dump, "") \
20945 _(lisp_eid_table_map_dump, "l2|l3") \
20946 _(lisp_map_resolver_dump, "") \
20947 _(lisp_map_server_dump, "") \
20948 _(lisp_adjacencies_get, "vni <vni>") \
20949 _(gpe_fwd_entry_vnis_get, "") \
20950 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20951 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20952 "[table <table-id>]") \
20953 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20954 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20955 _(gpe_set_encap_mode, "lisp|vxlan") \
20956 _(gpe_get_encap_mode, "") \
20957 _(lisp_gpe_add_del_iface, "up|down") \
20958 _(lisp_gpe_enable_disable, "enable|disable") \
20959 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20960 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20961 _(show_lisp_rloc_probe_state, "") \
20962 _(show_lisp_map_register_state, "") \
20963 _(show_lisp_status, "") \
20964 _(lisp_get_map_request_itr_rlocs, "") \
20965 _(show_lisp_pitr, "") \
20966 _(show_lisp_use_petr, "") \
20967 _(show_lisp_map_request_mode, "") \
20968 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20969 _(af_packet_delete, "name <host interface name>") \
20970 _(af_packet_dump, "") \
20971 _(policer_add_del, "name <policer name> <params> [del]") \
20972 _(policer_dump, "[name <policer name>]") \
20973 _(policer_classify_set_interface, \
20974 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20975 " [l2-table <nn>] [del]") \
20976 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20977 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20978 _(mpls_table_dump, "") \
20979 _(mpls_route_dump, "table-id <ID>") \
20980 _(classify_table_ids, "") \
20981 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20982 _(classify_table_info, "table_id <nn>") \
20983 _(classify_session_dump, "table_id <nn>") \
20984 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20985 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20986 "[template_interval <nn>] [udp_checksum]") \
20987 _(ipfix_exporter_dump, "") \
20988 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20989 _(ipfix_classify_stream_dump, "") \
20990 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20991 _(ipfix_classify_table_dump, "") \
20992 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20993 _(sw_interface_span_dump, "[l2]") \
20994 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20995 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
20996 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20997 _(pg_enable_disable, "[stream <id>] disable") \
20998 _(pg_interface_enable_disable_coalesce, "<intf> | sw_if_index <nn> enable | disable") \
20999 _(ip_source_and_port_range_check_add_del, \
21000 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21001 _(ip_source_and_port_range_check_interface_add_del, \
21002 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21003 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21004 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21005 _(l2_interface_pbb_tag_rewrite, \
21006 "<intfc> | sw_if_index <nn> \n" \
21007 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21008 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21009 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21010 _(flow_classify_set_interface, \
21011 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21012 _(flow_classify_dump, "type [ip4|ip6]") \
21013 _(ip_table_dump, "") \
21014 _(ip_route_dump, "table-id [ip4|ip6]") \
21015 _(ip_mtable_dump, "") \
21016 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21017 _(feature_enable_disable, "arc_name <arc_name> " \
21018 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21019 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21020 "[enable | disable] ") \
21021 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21023 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21024 "mac <mac-address> [del]") \
21025 _(l2_xconnect_dump, "") \
21026 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21027 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21028 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21029 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21030 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21031 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21032 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21033 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21034 _(sock_init_shm, "size <nnn>") \
21035 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21036 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21037 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21038 _(session_rules_dump, "") \
21039 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21040 _(output_acl_set_interface, \
21041 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21042 " [l2-table <nn>] [del]") \
21043 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21045 /* List of command functions, CLI names map directly to functions */
21046 #define foreach_cli_function \
21047 _(comment, "usage: comment <ignore-rest-of-line>") \
21048 _(dump_interface_table, "usage: dump_interface_table") \
21049 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21050 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21051 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21052 _(dump_macro_table, "usage: dump_macro_table ") \
21053 _(dump_node_table, "usage: dump_node_table") \
21054 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21055 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21056 _(elog_disable, "usage: elog_disable") \
21057 _(elog_enable, "usage: elog_enable") \
21058 _(elog_save, "usage: elog_save <filename>") \
21059 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21060 _(echo, "usage: echo <message>") \
21061 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21062 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21063 _(help, "usage: help") \
21064 _(q, "usage: quit") \
21065 _(quit, "usage: quit") \
21066 _(search_node_table, "usage: search_node_table <name>...") \
21067 _(set, "usage: set <variable-name> <value>") \
21068 _(script, "usage: script <file-name>") \
21069 _(statseg, "usage: statseg") \
21070 _(unset, "usage: unset <variable-name>")
21073 static void vl_api_##n##_t_handler_uni \
21074 (vl_api_##n##_t * mp) \
21076 vat_main_t * vam = &vat_main; \
21077 if (vam->json_output) { \
21078 vl_api_##n##_t_handler_json(mp); \
21080 vl_api_##n##_t_handler(mp); \
21083 foreach_vpe_api_reply_msg;
21084 #if VPP_API_TEST_BUILTIN == 0
21085 foreach_standalone_reply_msg;
21090 vat_api_hookup (vat_main_t * vam)
21093 vl_msg_api_set_handlers(VL_API_##N, #n, \
21094 vl_api_##n##_t_handler_uni, \
21096 vl_api_##n##_t_endian, \
21097 vl_api_##n##_t_print, \
21098 sizeof(vl_api_##n##_t), 1);
21099 foreach_vpe_api_reply_msg;
21100 #if VPP_API_TEST_BUILTIN == 0
21101 foreach_standalone_reply_msg;
21105 #if (VPP_API_TEST_BUILTIN==0)
21106 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21108 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21110 vam->function_by_name = hash_create_string (0, sizeof (uword));
21112 vam->help_by_name = hash_create_string (0, sizeof (uword));
21115 /* API messages we can send */
21116 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21117 foreach_vpe_api_msg;
21121 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21122 foreach_vpe_api_msg;
21125 /* CLI functions */
21126 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21127 foreach_cli_function;
21131 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21132 foreach_cli_function;
21136 #if VPP_API_TEST_BUILTIN
21137 static clib_error_t *
21138 vat_api_hookup_shim (vlib_main_t * vm)
21140 vat_api_hookup (&vat_main);
21144 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21148 * fd.io coding-style-patch-verification: ON
21151 * eval: (c-set-style "gnu")