2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vpp/api/types.h>
22 #include <vppinfra/socket.h>
23 #include <vlibapi/api.h>
24 #include <vlibmemory/api.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/ip/ip_neighbor.h>
27 #include <vnet/ip/ip_types_api.h>
28 #include <vnet/l2/l2_input.h>
29 #include <vnet/l2tp/l2tp.h>
30 #include <vnet/vxlan/vxlan.h>
31 #include <vnet/geneve/geneve.h>
32 #include <vnet/gre/gre.h>
33 #include <vnet/vxlan-gpe/vxlan_gpe.h>
34 #include <vnet/lisp-gpe/lisp_gpe.h>
36 #include <vpp/api/vpe_msg_enum.h>
37 #include <vnet/l2/l2_classify.h>
38 #include <vnet/l2/l2_vtr.h>
39 #include <vnet/classify/in_out_acl.h>
40 #include <vnet/classify/policer_classify.h>
41 #include <vnet/classify/flow_classify.h>
42 #include <vnet/mpls/mpls.h>
43 #include <vnet/ipsec/ipsec.h>
45 #include <vnet/cop/cop.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/dhcp/dhcp_proxy.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
57 #include <vnet/ip/ip_types_api.h>
58 #include "vat/json_format.h"
59 #include <vnet/ip/ip_types_api.h>
60 #include <vnet/ethernet/ethernet_types_api.h>
61 #include <vlibapi/api_types_inlines.h>
66 #define vl_typedefs /* define message structures */
67 #include <vpp/api/vpe_all_api_h.h>
70 /* declare message handlers for each api */
72 #define vl_endianfun /* define message structures */
73 #include <vpp/api/vpe_all_api_h.h>
76 /* instantiate all the print functions we know about */
77 #if VPP_API_TEST_BUILTIN == 0
78 #define vl_print(handle, ...)
80 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
83 #include <vpp/api/vpe_all_api_h.h>
86 #define __plugin_msg_base 0
87 #include <vlibapi/vat_helper_macros.h>
89 #if VPP_API_TEST_BUILTIN == 0
99 vat_socket_connect (vat_main_t * vam)
102 vam->socket_client_main = &socket_client_main;
103 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
105 0 /* default socket rx, tx buffer */ )))
107 /* vpp expects the client index in network order */
108 vam->my_client_index = htonl (socket_client_main.client_index);
111 #else /* vpp built-in case, we don't do sockets... */
113 vat_socket_connect (vat_main_t * vam)
119 vl_socket_client_read (int wait)
125 vl_socket_client_write ()
131 vl_socket_client_msg_alloc (int nbytes)
139 vat_time_now (vat_main_t * vam)
141 #if VPP_API_TEST_BUILTIN
142 return vlib_time_now (vam->vlib_main);
144 return clib_time_now (&vam->clib_time);
149 errmsg (char *fmt, ...)
151 vat_main_t *vam = &vat_main;
156 s = va_format (0, fmt, &va);
161 #if VPP_API_TEST_BUILTIN
162 vlib_cli_output (vam->vlib_main, (char *) s);
165 if (vam->ifp != stdin)
166 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
167 vam->input_line_number);
168 fformat (vam->ofp, (char *) s);
176 #if VPP_API_TEST_BUILTIN == 0
178 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
180 vat_main_t *vam = va_arg (*args, vat_main_t *);
181 u32 *result = va_arg (*args, u32 *);
185 if (!unformat (input, "%s", &if_name))
188 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
196 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
201 /* Parse an IP4 address %d.%d.%d.%d. */
203 unformat_ip4_address (unformat_input_t * input, va_list * args)
205 u8 *result = va_arg (*args, u8 *);
208 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
211 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
223 unformat_ethernet_address (unformat_input_t * input, va_list * args)
225 u8 *result = va_arg (*args, u8 *);
228 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
229 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
233 for (i = 0; i < 6; i++)
234 if (a[i] >= (1 << 8))
237 for (i = 0; i < 6; i++)
243 /* Returns ethernet type as an int in host byte order. */
245 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
248 u16 *result = va_arg (*args, u16 *);
252 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
254 if (type >= (1 << 16))
262 /* Parse an IP6 address. */
264 unformat_ip6_address (unformat_input_t * input, va_list * args)
266 ip6_address_t *result = va_arg (*args, ip6_address_t *);
268 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
269 uword c, n_colon, double_colon_index;
271 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
272 double_colon_index = ARRAY_LEN (hex_quads);
273 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
276 if (c >= '0' && c <= '9')
278 else if (c >= 'a' && c <= 'f')
279 hex_digit = c + 10 - 'a';
280 else if (c >= 'A' && c <= 'F')
281 hex_digit = c + 10 - 'A';
282 else if (c == ':' && n_colon < 2)
286 unformat_put_input (input);
290 /* Too many hex quads. */
291 if (n_hex_quads >= ARRAY_LEN (hex_quads))
296 hex_quad = (hex_quad << 4) | hex_digit;
298 /* Hex quad must fit in 16 bits. */
299 if (n_hex_digits >= 4)
306 /* Save position of :: */
309 /* More than one :: ? */
310 if (double_colon_index < ARRAY_LEN (hex_quads))
312 double_colon_index = n_hex_quads;
315 if (n_colon > 0 && n_hex_digits > 0)
317 hex_quads[n_hex_quads++] = hex_quad;
323 if (n_hex_digits > 0)
324 hex_quads[n_hex_quads++] = hex_quad;
329 /* Expand :: to appropriate number of zero hex quads. */
330 if (double_colon_index < ARRAY_LEN (hex_quads))
332 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
334 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
335 hex_quads[n_zero + i] = hex_quads[i];
337 for (i = 0; i < n_zero; i++)
338 hex_quads[double_colon_index + i] = 0;
340 n_hex_quads = ARRAY_LEN (hex_quads);
343 /* Too few hex quads given. */
344 if (n_hex_quads < ARRAY_LEN (hex_quads))
347 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
348 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
355 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
357 u32 *r = va_arg (*args, u32 *);
360 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
361 foreach_ipsec_policy_action
369 format_ipsec_crypto_alg (u8 * s, va_list * args)
371 u32 i = va_arg (*args, u32);
376 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
377 foreach_ipsec_crypto_alg
380 return format (s, "unknown");
382 return format (s, "%s", t);
386 format_ipsec_integ_alg (u8 * s, va_list * args)
388 u32 i = va_arg (*args, u32);
393 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
394 foreach_ipsec_integ_alg
397 return format (s, "unknown");
399 return format (s, "%s", t);
402 #else /* VPP_API_TEST_BUILTIN == 1 */
404 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
406 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
407 vnet_main_t *vnm = vnet_get_main ();
408 u32 *result = va_arg (*args, u32 *);
410 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
414 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
416 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
417 vnet_main_t *vnm = vnet_get_main ();
418 u32 *result = va_arg (*args, u32 *);
420 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
423 #endif /* VPP_API_TEST_BUILTIN */
426 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
428 u32 *r = va_arg (*args, u32 *);
431 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
432 foreach_ipsec_crypto_alg
440 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
442 u32 *r = va_arg (*args, u32 *);
445 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
446 foreach_ipsec_integ_alg
454 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
456 u8 *r = va_arg (*args, u8 *);
458 if (unformat (input, "kbps"))
459 *r = SSE2_QOS_RATE_KBPS;
460 else if (unformat (input, "pps"))
461 *r = SSE2_QOS_RATE_PPS;
468 unformat_policer_round_type (unformat_input_t * input, va_list * args)
470 u8 *r = va_arg (*args, u8 *);
472 if (unformat (input, "closest"))
473 *r = SSE2_QOS_ROUND_TO_CLOSEST;
474 else if (unformat (input, "up"))
475 *r = SSE2_QOS_ROUND_TO_UP;
476 else if (unformat (input, "down"))
477 *r = SSE2_QOS_ROUND_TO_DOWN;
484 unformat_policer_type (unformat_input_t * input, va_list * args)
486 u8 *r = va_arg (*args, u8 *);
488 if (unformat (input, "1r2c"))
489 *r = SSE2_QOS_POLICER_TYPE_1R2C;
490 else if (unformat (input, "1r3c"))
491 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
492 else if (unformat (input, "2r3c-2698"))
493 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
494 else if (unformat (input, "2r3c-4115"))
495 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
496 else if (unformat (input, "2r3c-mef5cf1"))
497 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
504 unformat_dscp (unformat_input_t * input, va_list * va)
506 u8 *r = va_arg (*va, u8 *);
509 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
518 unformat_policer_action_type (unformat_input_t * input, va_list * va)
520 sse2_qos_pol_action_params_st *a
521 = va_arg (*va, sse2_qos_pol_action_params_st *);
523 if (unformat (input, "drop"))
524 a->action_type = SSE2_QOS_ACTION_DROP;
525 else if (unformat (input, "transmit"))
526 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
527 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
528 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
535 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
537 u32 *r = va_arg (*va, u32 *);
540 if (unformat (input, "ip4"))
541 tid = POLICER_CLASSIFY_TABLE_IP4;
542 else if (unformat (input, "ip6"))
543 tid = POLICER_CLASSIFY_TABLE_IP6;
544 else if (unformat (input, "l2"))
545 tid = POLICER_CLASSIFY_TABLE_L2;
554 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
556 u32 *r = va_arg (*va, u32 *);
559 if (unformat (input, "ip4"))
560 tid = FLOW_CLASSIFY_TABLE_IP4;
561 else if (unformat (input, "ip6"))
562 tid = FLOW_CLASSIFY_TABLE_IP6;
570 #if (VPP_API_TEST_BUILTIN==0)
572 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
573 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
574 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
575 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
578 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
580 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
581 mfib_itf_attribute_t attr;
584 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
586 if (unformat (input, mfib_itf_flag_long_names[attr]))
587 *iflags |= (1 << attr);
589 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
591 if (unformat (input, mfib_itf_flag_names[attr]))
592 *iflags |= (1 << attr);
595 return (old == *iflags ? 0 : 1);
599 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
601 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
602 mfib_entry_attribute_t attr;
605 FOR_EACH_MFIB_ATTRIBUTE (attr)
607 if (unformat (input, mfib_flag_long_names[attr]))
608 *eflags |= (1 << attr);
610 FOR_EACH_MFIB_ATTRIBUTE (attr)
612 if (unformat (input, mfib_flag_names[attr]))
613 *eflags |= (1 << attr);
616 return (old == *eflags ? 0 : 1);
620 format_ip4_address (u8 * s, va_list * args)
622 u8 *a = va_arg (*args, u8 *);
623 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
627 format_ip6_address (u8 * s, va_list * args)
629 ip6_address_t *a = va_arg (*args, ip6_address_t *);
630 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
632 i_max_n_zero = ARRAY_LEN (a->as_u16);
634 i_first_zero = i_max_n_zero;
636 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
638 u32 is_zero = a->as_u16[i] == 0;
639 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
645 if ((!is_zero && n_zeros > max_n_zeros)
646 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
648 i_max_n_zero = i_first_zero;
649 max_n_zeros = n_zeros;
650 i_first_zero = ARRAY_LEN (a->as_u16);
655 last_double_colon = 0;
656 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
658 if (i == i_max_n_zero && max_n_zeros > 1)
660 s = format (s, "::");
661 i += max_n_zeros - 1;
662 last_double_colon = 1;
666 s = format (s, "%s%x",
667 (last_double_colon || i == 0) ? "" : ":",
668 clib_net_to_host_u16 (a->as_u16[i]));
669 last_double_colon = 0;
676 /* Format an IP46 address. */
678 format_ip46_address (u8 * s, va_list * args)
680 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
681 ip46_type_t type = va_arg (*args, ip46_type_t);
687 is_ip4 = ip46_address_is_ip4 (ip46);
698 format (s, "%U", format_ip4_address, &ip46->ip4) :
699 format (s, "%U", format_ip6_address, &ip46->ip6);
703 format_ethernet_address (u8 * s, va_list * args)
705 u8 *a = va_arg (*args, u8 *);
707 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
708 a[0], a[1], a[2], a[3], a[4], a[5]);
713 increment_v4_address (vl_api_ip4_address_t * i)
715 ip4_address_t *a = (ip4_address_t *) i;
718 v = ntohl (a->as_u32) + 1;
719 a->as_u32 = ntohl (v);
723 increment_v6_address (vl_api_ip6_address_t * i)
725 ip6_address_t *a = (ip6_address_t *) i;
728 v0 = clib_net_to_host_u64 (a->as_u64[0]);
729 v1 = clib_net_to_host_u64 (a->as_u64[1]);
734 a->as_u64[0] = clib_net_to_host_u64 (v0);
735 a->as_u64[1] = clib_net_to_host_u64 (v1);
739 increment_address (vl_api_address_t * a)
741 if (a->af == ADDRESS_IP4)
742 increment_v4_address (&a->un.ip4);
743 else if (a->af == ADDRESS_IP6)
744 increment_v6_address (&a->un.ip6);
748 set_ip4_address (vl_api_address_t * a, u32 v)
750 if (a->af == ADDRESS_IP4)
752 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
758 increment_mac_address (u8 * mac)
760 u64 tmp = *((u64 *) mac);
761 tmp = clib_net_to_host_u64 (tmp);
762 tmp += 1 << 16; /* skip unused (least significant) octets */
763 tmp = clib_host_to_net_u64 (tmp);
765 clib_memcpy (mac, &tmp, 6);
769 vat_json_object_add_address (vat_json_node_t * node,
770 const char *str, const vl_api_address_t * addr)
772 if (ADDRESS_IP6 == addr->af)
776 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
777 vat_json_object_add_ip6 (node, str, ip6);
783 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
784 vat_json_object_add_ip4 (node, str, ip4);
789 vat_json_object_add_prefix (vat_json_node_t * node,
790 const vl_api_prefix_t * prefix)
792 vat_json_object_add_uint (node, "address_length", prefix->address_length);
793 vat_json_object_add_address (node, "prefix", &prefix->address);
796 static void vl_api_create_loopback_reply_t_handler
797 (vl_api_create_loopback_reply_t * mp)
799 vat_main_t *vam = &vat_main;
800 i32 retval = ntohl (mp->retval);
802 vam->retval = retval;
803 vam->regenerate_interface_table = 1;
804 vam->sw_if_index = ntohl (mp->sw_if_index);
805 vam->result_ready = 1;
808 static void vl_api_create_loopback_reply_t_handler_json
809 (vl_api_create_loopback_reply_t * mp)
811 vat_main_t *vam = &vat_main;
812 vat_json_node_t node;
814 vat_json_init_object (&node);
815 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
816 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
818 vat_json_print (vam->ofp, &node);
819 vat_json_free (&node);
820 vam->retval = ntohl (mp->retval);
821 vam->result_ready = 1;
824 static void vl_api_create_loopback_instance_reply_t_handler
825 (vl_api_create_loopback_instance_reply_t * mp)
827 vat_main_t *vam = &vat_main;
828 i32 retval = ntohl (mp->retval);
830 vam->retval = retval;
831 vam->regenerate_interface_table = 1;
832 vam->sw_if_index = ntohl (mp->sw_if_index);
833 vam->result_ready = 1;
836 static void vl_api_create_loopback_instance_reply_t_handler_json
837 (vl_api_create_loopback_instance_reply_t * mp)
839 vat_main_t *vam = &vat_main;
840 vat_json_node_t node;
842 vat_json_init_object (&node);
843 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
844 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
846 vat_json_print (vam->ofp, &node);
847 vat_json_free (&node);
848 vam->retval = ntohl (mp->retval);
849 vam->result_ready = 1;
852 static void vl_api_af_packet_create_reply_t_handler
853 (vl_api_af_packet_create_reply_t * mp)
855 vat_main_t *vam = &vat_main;
856 i32 retval = ntohl (mp->retval);
858 vam->retval = retval;
859 vam->regenerate_interface_table = 1;
860 vam->sw_if_index = ntohl (mp->sw_if_index);
861 vam->result_ready = 1;
864 static void vl_api_af_packet_create_reply_t_handler_json
865 (vl_api_af_packet_create_reply_t * mp)
867 vat_main_t *vam = &vat_main;
868 vat_json_node_t node;
870 vat_json_init_object (&node);
871 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
872 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
874 vat_json_print (vam->ofp, &node);
875 vat_json_free (&node);
877 vam->retval = ntohl (mp->retval);
878 vam->result_ready = 1;
881 static void vl_api_create_vlan_subif_reply_t_handler
882 (vl_api_create_vlan_subif_reply_t * mp)
884 vat_main_t *vam = &vat_main;
885 i32 retval = ntohl (mp->retval);
887 vam->retval = retval;
888 vam->regenerate_interface_table = 1;
889 vam->sw_if_index = ntohl (mp->sw_if_index);
890 vam->result_ready = 1;
893 static void vl_api_create_vlan_subif_reply_t_handler_json
894 (vl_api_create_vlan_subif_reply_t * mp)
896 vat_main_t *vam = &vat_main;
897 vat_json_node_t node;
899 vat_json_init_object (&node);
900 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
901 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
903 vat_json_print (vam->ofp, &node);
904 vat_json_free (&node);
906 vam->retval = ntohl (mp->retval);
907 vam->result_ready = 1;
910 static void vl_api_create_subif_reply_t_handler
911 (vl_api_create_subif_reply_t * mp)
913 vat_main_t *vam = &vat_main;
914 i32 retval = ntohl (mp->retval);
916 vam->retval = retval;
917 vam->regenerate_interface_table = 1;
918 vam->sw_if_index = ntohl (mp->sw_if_index);
919 vam->result_ready = 1;
922 static void vl_api_create_subif_reply_t_handler_json
923 (vl_api_create_subif_reply_t * mp)
925 vat_main_t *vam = &vat_main;
926 vat_json_node_t node;
928 vat_json_init_object (&node);
929 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
930 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
932 vat_json_print (vam->ofp, &node);
933 vat_json_free (&node);
935 vam->retval = ntohl (mp->retval);
936 vam->result_ready = 1;
939 static void vl_api_interface_name_renumber_reply_t_handler
940 (vl_api_interface_name_renumber_reply_t * mp)
942 vat_main_t *vam = &vat_main;
943 i32 retval = ntohl (mp->retval);
945 vam->retval = retval;
946 vam->regenerate_interface_table = 1;
947 vam->result_ready = 1;
950 static void vl_api_interface_name_renumber_reply_t_handler_json
951 (vl_api_interface_name_renumber_reply_t * mp)
953 vat_main_t *vam = &vat_main;
954 vat_json_node_t node;
956 vat_json_init_object (&node);
957 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
959 vat_json_print (vam->ofp, &node);
960 vat_json_free (&node);
962 vam->retval = ntohl (mp->retval);
963 vam->result_ready = 1;
967 * Special-case: build the interface table, maintain
968 * the next loopback sw_if_index vbl.
970 static void vl_api_sw_interface_details_t_handler
971 (vl_api_sw_interface_details_t * mp)
973 vat_main_t *vam = &vat_main;
974 u8 *s = format (0, "%s%c", mp->interface_name, 0);
976 hash_set_mem (vam->sw_if_index_by_interface_name, s,
977 ntohl (mp->sw_if_index));
979 /* In sub interface case, fill the sub interface table entry */
980 if (mp->sw_if_index != mp->sup_sw_if_index)
982 sw_interface_subif_t *sub = NULL;
984 vec_add2 (vam->sw_if_subif_table, sub, 1);
986 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
987 strncpy ((char *) sub->interface_name, (char *) s,
988 vec_len (sub->interface_name));
989 sub->sw_if_index = ntohl (mp->sw_if_index);
990 sub->sub_id = ntohl (mp->sub_id);
992 sub->sub_dot1ad = mp->sub_dot1ad;
993 sub->sub_number_of_tags = mp->sub_number_of_tags;
994 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
995 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
996 sub->sub_exact_match = mp->sub_exact_match;
997 sub->sub_default = mp->sub_default;
998 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
999 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
1001 /* vlan tag rewrite */
1002 sub->vtr_op = ntohl (mp->vtr_op);
1003 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1004 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1005 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1009 static void vl_api_sw_interface_details_t_handler_json
1010 (vl_api_sw_interface_details_t * mp)
1012 vat_main_t *vam = &vat_main;
1013 vat_json_node_t *node = NULL;
1015 if (VAT_JSON_ARRAY != vam->json_tree.type)
1017 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1018 vat_json_init_array (&vam->json_tree);
1020 node = vat_json_array_add (&vam->json_tree);
1022 vat_json_init_object (node);
1023 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1024 vat_json_object_add_uint (node, "sup_sw_if_index",
1025 ntohl (mp->sup_sw_if_index));
1026 vat_json_object_add_uint (node, "l2_address_length",
1027 ntohl (mp->l2_address_length));
1028 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1029 sizeof (mp->l2_address));
1030 vat_json_object_add_string_copy (node, "interface_name",
1031 mp->interface_name);
1032 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
1033 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
1034 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1035 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1036 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1037 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1038 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
1039 vat_json_object_add_uint (node, "sub_number_of_tags",
1040 mp->sub_number_of_tags);
1041 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1042 ntohs (mp->sub_outer_vlan_id));
1043 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1044 ntohs (mp->sub_inner_vlan_id));
1045 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
1046 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
1047 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
1048 mp->sub_outer_vlan_id_any);
1049 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
1050 mp->sub_inner_vlan_id_any);
1051 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1052 vat_json_object_add_uint (node, "vtr_push_dot1q",
1053 ntohl (mp->vtr_push_dot1q));
1054 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1055 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1058 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1060 format_ethernet_address,
1062 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1064 format_ethernet_address,
1066 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1067 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1071 #if VPP_API_TEST_BUILTIN == 0
1072 static void vl_api_sw_interface_event_t_handler
1073 (vl_api_sw_interface_event_t * mp)
1075 vat_main_t *vam = &vat_main;
1076 if (vam->interface_event_display)
1077 errmsg ("interface flags: sw_if_index %d %s %s",
1078 ntohl (mp->sw_if_index),
1079 mp->admin_up_down ? "admin-up" : "admin-down",
1080 mp->link_up_down ? "link-up" : "link-down");
1084 __clib_unused static void
1085 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1087 /* JSON output not supported */
1091 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1093 vat_main_t *vam = &vat_main;
1094 i32 retval = ntohl (mp->retval);
1096 vam->retval = retval;
1097 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1098 vam->result_ready = 1;
1102 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1104 vat_main_t *vam = &vat_main;
1105 vat_json_node_t node;
1106 api_main_t *am = &api_main;
1110 vat_json_init_object (&node);
1111 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1112 vat_json_object_add_uint (&node, "reply_in_shmem",
1113 ntohl (mp->reply_in_shmem));
1114 /* Toss the shared-memory original... */
1115 pthread_mutex_lock (&am->vlib_rp->mutex);
1116 oldheap = svm_push_data_heap (am->vlib_rp);
1118 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1121 svm_pop_heap (oldheap);
1122 pthread_mutex_unlock (&am->vlib_rp->mutex);
1124 vat_json_print (vam->ofp, &node);
1125 vat_json_free (&node);
1127 vam->retval = ntohl (mp->retval);
1128 vam->result_ready = 1;
1132 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1134 vat_main_t *vam = &vat_main;
1135 i32 retval = ntohl (mp->retval);
1136 u32 length = vl_api_string_len (&mp->reply);
1138 vec_reset_length (vam->cmd_reply);
1140 vam->retval = retval;
1143 vec_validate (vam->cmd_reply, length);
1144 clib_memcpy ((char *) (vam->cmd_reply),
1145 vl_api_from_api_string (&mp->reply), length);
1146 vam->cmd_reply[length] = 0;
1148 vam->result_ready = 1;
1152 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1154 vat_main_t *vam = &vat_main;
1155 vat_json_node_t node;
1157 vec_reset_length (vam->cmd_reply);
1159 vat_json_init_object (&node);
1160 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1161 vat_json_object_add_string_copy (&node, "reply",
1162 vl_api_from_api_string (&mp->reply));
1164 vat_json_print (vam->ofp, &node);
1165 vat_json_free (&node);
1167 vam->retval = ntohl (mp->retval);
1168 vam->result_ready = 1;
1171 static void vl_api_classify_add_del_table_reply_t_handler
1172 (vl_api_classify_add_del_table_reply_t * mp)
1174 vat_main_t *vam = &vat_main;
1175 i32 retval = ntohl (mp->retval);
1176 if (vam->async_mode)
1178 vam->async_errors += (retval < 0);
1182 vam->retval = retval;
1184 ((mp->new_table_index != 0xFFFFFFFF) ||
1185 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1186 (mp->match_n_vectors != 0xFFFFFFFF)))
1188 * Note: this is just barely thread-safe, depends on
1189 * the main thread spinning waiting for an answer...
1191 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1192 ntohl (mp->new_table_index),
1193 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1194 vam->result_ready = 1;
1198 static void vl_api_classify_add_del_table_reply_t_handler_json
1199 (vl_api_classify_add_del_table_reply_t * mp)
1201 vat_main_t *vam = &vat_main;
1202 vat_json_node_t node;
1204 vat_json_init_object (&node);
1205 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1206 vat_json_object_add_uint (&node, "new_table_index",
1207 ntohl (mp->new_table_index));
1208 vat_json_object_add_uint (&node, "skip_n_vectors",
1209 ntohl (mp->skip_n_vectors));
1210 vat_json_object_add_uint (&node, "match_n_vectors",
1211 ntohl (mp->match_n_vectors));
1213 vat_json_print (vam->ofp, &node);
1214 vat_json_free (&node);
1216 vam->retval = ntohl (mp->retval);
1217 vam->result_ready = 1;
1220 static void vl_api_get_node_index_reply_t_handler
1221 (vl_api_get_node_index_reply_t * mp)
1223 vat_main_t *vam = &vat_main;
1224 i32 retval = ntohl (mp->retval);
1225 if (vam->async_mode)
1227 vam->async_errors += (retval < 0);
1231 vam->retval = retval;
1233 errmsg ("node index %d", ntohl (mp->node_index));
1234 vam->result_ready = 1;
1238 static void vl_api_get_node_index_reply_t_handler_json
1239 (vl_api_get_node_index_reply_t * mp)
1241 vat_main_t *vam = &vat_main;
1242 vat_json_node_t node;
1244 vat_json_init_object (&node);
1245 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1246 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1248 vat_json_print (vam->ofp, &node);
1249 vat_json_free (&node);
1251 vam->retval = ntohl (mp->retval);
1252 vam->result_ready = 1;
1255 static void vl_api_get_next_index_reply_t_handler
1256 (vl_api_get_next_index_reply_t * mp)
1258 vat_main_t *vam = &vat_main;
1259 i32 retval = ntohl (mp->retval);
1260 if (vam->async_mode)
1262 vam->async_errors += (retval < 0);
1266 vam->retval = retval;
1268 errmsg ("next node index %d", ntohl (mp->next_index));
1269 vam->result_ready = 1;
1273 static void vl_api_get_next_index_reply_t_handler_json
1274 (vl_api_get_next_index_reply_t * mp)
1276 vat_main_t *vam = &vat_main;
1277 vat_json_node_t node;
1279 vat_json_init_object (&node);
1280 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1281 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1283 vat_json_print (vam->ofp, &node);
1284 vat_json_free (&node);
1286 vam->retval = ntohl (mp->retval);
1287 vam->result_ready = 1;
1290 static void vl_api_add_node_next_reply_t_handler
1291 (vl_api_add_node_next_reply_t * mp)
1293 vat_main_t *vam = &vat_main;
1294 i32 retval = ntohl (mp->retval);
1295 if (vam->async_mode)
1297 vam->async_errors += (retval < 0);
1301 vam->retval = retval;
1303 errmsg ("next index %d", ntohl (mp->next_index));
1304 vam->result_ready = 1;
1308 static void vl_api_add_node_next_reply_t_handler_json
1309 (vl_api_add_node_next_reply_t * mp)
1311 vat_main_t *vam = &vat_main;
1312 vat_json_node_t node;
1314 vat_json_init_object (&node);
1315 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1316 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1318 vat_json_print (vam->ofp, &node);
1319 vat_json_free (&node);
1321 vam->retval = ntohl (mp->retval);
1322 vam->result_ready = 1;
1325 static void vl_api_show_version_reply_t_handler
1326 (vl_api_show_version_reply_t * mp)
1328 vat_main_t *vam = &vat_main;
1329 i32 retval = ntohl (mp->retval);
1334 char *p = (char *) &mp->program;
1336 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1337 errmsg (" program: %v\n", s);
1341 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1342 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1343 errmsg (" version: %v\n", s);
1347 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1348 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1349 errmsg (" build date: %v\n", s);
1353 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1354 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1357 errmsg ("build directory: %v\n", s);
1359 vam->retval = retval;
1360 vam->result_ready = 1;
1363 static void vl_api_show_version_reply_t_handler_json
1364 (vl_api_show_version_reply_t * mp)
1366 vat_main_t *vam = &vat_main;
1367 vat_json_node_t node;
1369 vat_json_init_object (&node);
1370 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1371 char *p = (char *) &mp->program;
1372 vat_json_object_add_string_copy (&node, "program",
1373 vl_api_from_api_string ((vl_api_string_t *)
1375 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1376 vat_json_object_add_string_copy (&node, "version",
1377 vl_api_from_api_string ((vl_api_string_t *)
1379 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1380 vat_json_object_add_string_copy (&node, "build_date",
1381 vl_api_from_api_string ((vl_api_string_t *)
1383 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1384 vat_json_object_add_string_copy (&node, "build_directory",
1385 vl_api_from_api_string ((vl_api_string_t *)
1388 vat_json_print (vam->ofp, &node);
1389 vat_json_free (&node);
1391 vam->retval = ntohl (mp->retval);
1392 vam->result_ready = 1;
1395 static void vl_api_show_threads_reply_t_handler
1396 (vl_api_show_threads_reply_t * mp)
1398 vat_main_t *vam = &vat_main;
1399 i32 retval = ntohl (mp->retval);
1403 count = ntohl (mp->count);
1405 for (i = 0; i < count; i++)
1407 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1408 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1409 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1410 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1411 ntohl (mp->thread_data[i].cpu_socket));
1413 vam->retval = retval;
1414 vam->result_ready = 1;
1417 static void vl_api_show_threads_reply_t_handler_json
1418 (vl_api_show_threads_reply_t * mp)
1420 vat_main_t *vam = &vat_main;
1421 vat_json_node_t node;
1422 vl_api_thread_data_t *td;
1423 i32 retval = ntohl (mp->retval);
1427 count = ntohl (mp->count);
1429 vat_json_init_object (&node);
1430 vat_json_object_add_int (&node, "retval", retval);
1431 vat_json_object_add_uint (&node, "count", count);
1433 for (i = 0; i < count; i++)
1435 td = &mp->thread_data[i];
1436 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1437 vat_json_object_add_string_copy (&node, "name", td->name);
1438 vat_json_object_add_string_copy (&node, "type", td->type);
1439 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1440 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1441 vat_json_object_add_int (&node, "core", ntohl (td->id));
1442 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1445 vat_json_print (vam->ofp, &node);
1446 vat_json_free (&node);
1448 vam->retval = retval;
1449 vam->result_ready = 1;
1453 api_show_threads (vat_main_t * vam)
1455 vl_api_show_threads_t *mp;
1459 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1460 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1462 M (SHOW_THREADS, mp);
1470 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1472 u32 sw_if_index = ntohl (mp->sw_if_index);
1473 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1474 mp->mac_ip ? "mac/ip binding" : "address resolution",
1475 ntohl (mp->pid), format_ip4_address, mp->ip,
1476 format_vl_api_mac_address, &mp->mac, sw_if_index);
1480 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1482 /* JSON output not supported */
1486 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1488 u32 sw_if_index = ntohl (mp->sw_if_index);
1489 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1490 mp->mac_ip ? "mac/ip binding" : "address resolution",
1491 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1492 format_vl_api_mac_address, mp->mac, sw_if_index);
1496 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1498 /* JSON output not supported */
1502 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1504 u32 n_macs = ntohl (mp->n_macs);
1505 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1506 ntohl (mp->pid), mp->client_index, n_macs);
1508 for (i = 0; i < n_macs; i++)
1510 vl_api_mac_entry_t *mac = &mp->mac[i];
1511 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1512 i + 1, ntohl (mac->sw_if_index),
1513 format_ethernet_address, mac->mac_addr, mac->action);
1520 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1522 /* JSON output not supported */
1525 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1526 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1529 * Special-case: build the bridge domain table, maintain
1530 * the next bd id vbl.
1532 static void vl_api_bridge_domain_details_t_handler
1533 (vl_api_bridge_domain_details_t * mp)
1535 vat_main_t *vam = &vat_main;
1536 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1539 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1540 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1542 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1543 ntohl (mp->bd_id), mp->learn, mp->forward,
1544 mp->flood, ntohl (mp->bvi_sw_if_index),
1545 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1549 vl_api_bridge_domain_sw_if_t *sw_ifs;
1550 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1553 sw_ifs = mp->sw_if_details;
1554 for (i = 0; i < n_sw_ifs; i++)
1560 sw_if_index = ntohl (sw_ifs->sw_if_index);
1563 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1565 if ((u32) p->value[0] == sw_if_index)
1567 sw_if_name = (u8 *)(p->key);
1572 print (vam->ofp, "%7d %3d %s", sw_if_index,
1573 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1574 "sw_if_index not found!");
1581 static void vl_api_bridge_domain_details_t_handler_json
1582 (vl_api_bridge_domain_details_t * mp)
1584 vat_main_t *vam = &vat_main;
1585 vat_json_node_t *node, *array = NULL;
1586 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1588 if (VAT_JSON_ARRAY != vam->json_tree.type)
1590 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1591 vat_json_init_array (&vam->json_tree);
1593 node = vat_json_array_add (&vam->json_tree);
1595 vat_json_init_object (node);
1596 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1597 vat_json_object_add_uint (node, "flood", mp->flood);
1598 vat_json_object_add_uint (node, "forward", mp->forward);
1599 vat_json_object_add_uint (node, "learn", mp->learn);
1600 vat_json_object_add_uint (node, "bvi_sw_if_index",
1601 ntohl (mp->bvi_sw_if_index));
1602 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1603 array = vat_json_object_add (node, "sw_if");
1604 vat_json_init_array (array);
1610 vl_api_bridge_domain_sw_if_t *sw_ifs;
1613 sw_ifs = mp->sw_if_details;
1614 for (i = 0; i < n_sw_ifs; i++)
1616 node = vat_json_array_add (array);
1617 vat_json_init_object (node);
1618 vat_json_object_add_uint (node, "sw_if_index",
1619 ntohl (sw_ifs->sw_if_index));
1620 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1626 static void vl_api_control_ping_reply_t_handler
1627 (vl_api_control_ping_reply_t * mp)
1629 vat_main_t *vam = &vat_main;
1630 i32 retval = ntohl (mp->retval);
1631 if (vam->async_mode)
1633 vam->async_errors += (retval < 0);
1637 vam->retval = retval;
1638 vam->result_ready = 1;
1640 if (vam->socket_client_main)
1641 vam->socket_client_main->control_pings_outstanding--;
1644 static void vl_api_control_ping_reply_t_handler_json
1645 (vl_api_control_ping_reply_t * mp)
1647 vat_main_t *vam = &vat_main;
1648 i32 retval = ntohl (mp->retval);
1650 if (VAT_JSON_NONE != vam->json_tree.type)
1652 vat_json_print (vam->ofp, &vam->json_tree);
1653 vat_json_free (&vam->json_tree);
1654 vam->json_tree.type = VAT_JSON_NONE;
1659 vat_json_init_array (&vam->json_tree);
1660 vat_json_print (vam->ofp, &vam->json_tree);
1661 vam->json_tree.type = VAT_JSON_NONE;
1664 vam->retval = retval;
1665 vam->result_ready = 1;
1669 vl_api_bridge_domain_set_mac_age_reply_t_handler
1670 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1672 vat_main_t *vam = &vat_main;
1673 i32 retval = ntohl (mp->retval);
1674 if (vam->async_mode)
1676 vam->async_errors += (retval < 0);
1680 vam->retval = retval;
1681 vam->result_ready = 1;
1685 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1686 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1688 vat_main_t *vam = &vat_main;
1689 vat_json_node_t node;
1691 vat_json_init_object (&node);
1692 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1694 vat_json_print (vam->ofp, &node);
1695 vat_json_free (&node);
1697 vam->retval = ntohl (mp->retval);
1698 vam->result_ready = 1;
1702 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1704 vat_main_t *vam = &vat_main;
1705 i32 retval = ntohl (mp->retval);
1706 if (vam->async_mode)
1708 vam->async_errors += (retval < 0);
1712 vam->retval = retval;
1713 vam->result_ready = 1;
1717 static void vl_api_l2_flags_reply_t_handler_json
1718 (vl_api_l2_flags_reply_t * mp)
1720 vat_main_t *vam = &vat_main;
1721 vat_json_node_t node;
1723 vat_json_init_object (&node);
1724 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1725 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1726 ntohl (mp->resulting_feature_bitmap));
1728 vat_json_print (vam->ofp, &node);
1729 vat_json_free (&node);
1731 vam->retval = ntohl (mp->retval);
1732 vam->result_ready = 1;
1735 static void vl_api_bridge_flags_reply_t_handler
1736 (vl_api_bridge_flags_reply_t * mp)
1738 vat_main_t *vam = &vat_main;
1739 i32 retval = ntohl (mp->retval);
1740 if (vam->async_mode)
1742 vam->async_errors += (retval < 0);
1746 vam->retval = retval;
1747 vam->result_ready = 1;
1751 static void vl_api_bridge_flags_reply_t_handler_json
1752 (vl_api_bridge_flags_reply_t * mp)
1754 vat_main_t *vam = &vat_main;
1755 vat_json_node_t node;
1757 vat_json_init_object (&node);
1758 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1759 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1760 ntohl (mp->resulting_feature_bitmap));
1762 vat_json_print (vam->ofp, &node);
1763 vat_json_free (&node);
1765 vam->retval = ntohl (mp->retval);
1766 vam->result_ready = 1;
1770 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1772 vat_main_t *vam = &vat_main;
1773 i32 retval = ntohl (mp->retval);
1774 if (vam->async_mode)
1776 vam->async_errors += (retval < 0);
1780 vam->retval = retval;
1781 vam->sw_if_index = ntohl (mp->sw_if_index);
1782 vam->result_ready = 1;
1787 static void vl_api_tap_create_v2_reply_t_handler_json
1788 (vl_api_tap_create_v2_reply_t * mp)
1790 vat_main_t *vam = &vat_main;
1791 vat_json_node_t node;
1793 vat_json_init_object (&node);
1794 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1795 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1797 vat_json_print (vam->ofp, &node);
1798 vat_json_free (&node);
1800 vam->retval = ntohl (mp->retval);
1801 vam->result_ready = 1;
1806 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1808 vat_main_t *vam = &vat_main;
1809 i32 retval = ntohl (mp->retval);
1810 if (vam->async_mode)
1812 vam->async_errors += (retval < 0);
1816 vam->retval = retval;
1817 vam->result_ready = 1;
1821 static void vl_api_tap_delete_v2_reply_t_handler_json
1822 (vl_api_tap_delete_v2_reply_t * mp)
1824 vat_main_t *vam = &vat_main;
1825 vat_json_node_t node;
1827 vat_json_init_object (&node);
1828 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1830 vat_json_print (vam->ofp, &node);
1831 vat_json_free (&node);
1833 vam->retval = ntohl (mp->retval);
1834 vam->result_ready = 1;
1838 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1841 vat_main_t *vam = &vat_main;
1842 i32 retval = ntohl (mp->retval);
1843 if (vam->async_mode)
1845 vam->async_errors += (retval < 0);
1849 vam->retval = retval;
1850 vam->sw_if_index = ntohl (mp->sw_if_index);
1851 vam->result_ready = 1;
1855 static void vl_api_virtio_pci_create_reply_t_handler_json
1856 (vl_api_virtio_pci_create_reply_t * mp)
1858 vat_main_t *vam = &vat_main;
1859 vat_json_node_t node;
1861 vat_json_init_object (&node);
1862 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1863 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1865 vat_json_print (vam->ofp, &node);
1866 vat_json_free (&node);
1868 vam->retval = ntohl (mp->retval);
1869 vam->result_ready = 1;
1874 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1877 vat_main_t *vam = &vat_main;
1878 i32 retval = ntohl (mp->retval);
1879 if (vam->async_mode)
1881 vam->async_errors += (retval < 0);
1885 vam->retval = retval;
1886 vam->result_ready = 1;
1890 static void vl_api_virtio_pci_delete_reply_t_handler_json
1891 (vl_api_virtio_pci_delete_reply_t * mp)
1893 vat_main_t *vam = &vat_main;
1894 vat_json_node_t node;
1896 vat_json_init_object (&node);
1897 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1899 vat_json_print (vam->ofp, &node);
1900 vat_json_free (&node);
1902 vam->retval = ntohl (mp->retval);
1903 vam->result_ready = 1;
1907 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1909 vat_main_t *vam = &vat_main;
1910 i32 retval = ntohl (mp->retval);
1912 if (vam->async_mode)
1914 vam->async_errors += (retval < 0);
1918 vam->retval = retval;
1919 vam->sw_if_index = ntohl (mp->sw_if_index);
1920 vam->result_ready = 1;
1924 static void vl_api_bond_create_reply_t_handler_json
1925 (vl_api_bond_create_reply_t * mp)
1927 vat_main_t *vam = &vat_main;
1928 vat_json_node_t node;
1930 vat_json_init_object (&node);
1931 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1932 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1934 vat_json_print (vam->ofp, &node);
1935 vat_json_free (&node);
1937 vam->retval = ntohl (mp->retval);
1938 vam->result_ready = 1;
1942 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1944 vat_main_t *vam = &vat_main;
1945 i32 retval = ntohl (mp->retval);
1947 if (vam->async_mode)
1949 vam->async_errors += (retval < 0);
1953 vam->retval = retval;
1954 vam->result_ready = 1;
1958 static void vl_api_bond_delete_reply_t_handler_json
1959 (vl_api_bond_delete_reply_t * mp)
1961 vat_main_t *vam = &vat_main;
1962 vat_json_node_t node;
1964 vat_json_init_object (&node);
1965 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1967 vat_json_print (vam->ofp, &node);
1968 vat_json_free (&node);
1970 vam->retval = ntohl (mp->retval);
1971 vam->result_ready = 1;
1975 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1977 vat_main_t *vam = &vat_main;
1978 i32 retval = ntohl (mp->retval);
1980 if (vam->async_mode)
1982 vam->async_errors += (retval < 0);
1986 vam->retval = retval;
1987 vam->result_ready = 1;
1991 static void vl_api_bond_enslave_reply_t_handler_json
1992 (vl_api_bond_enslave_reply_t * mp)
1994 vat_main_t *vam = &vat_main;
1995 vat_json_node_t node;
1997 vat_json_init_object (&node);
1998 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2000 vat_json_print (vam->ofp, &node);
2001 vat_json_free (&node);
2003 vam->retval = ntohl (mp->retval);
2004 vam->result_ready = 1;
2008 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
2011 vat_main_t *vam = &vat_main;
2012 i32 retval = ntohl (mp->retval);
2014 if (vam->async_mode)
2016 vam->async_errors += (retval < 0);
2020 vam->retval = retval;
2021 vam->result_ready = 1;
2025 static void vl_api_bond_detach_slave_reply_t_handler_json
2026 (vl_api_bond_detach_slave_reply_t * mp)
2028 vat_main_t *vam = &vat_main;
2029 vat_json_node_t node;
2031 vat_json_init_object (&node);
2032 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2034 vat_json_print (vam->ofp, &node);
2035 vat_json_free (&node);
2037 vam->retval = ntohl (mp->retval);
2038 vam->result_ready = 1;
2041 static void vl_api_sw_interface_bond_details_t_handler
2042 (vl_api_sw_interface_bond_details_t * mp)
2044 vat_main_t *vam = &vat_main;
2047 "%-16s %-12d %-12U %-13U %-14u %-14u",
2048 mp->interface_name, ntohl (mp->sw_if_index),
2049 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2050 ntohl (mp->active_slaves), ntohl (mp->slaves));
2053 static void vl_api_sw_interface_bond_details_t_handler_json
2054 (vl_api_sw_interface_bond_details_t * mp)
2056 vat_main_t *vam = &vat_main;
2057 vat_json_node_t *node = NULL;
2059 if (VAT_JSON_ARRAY != vam->json_tree.type)
2061 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2062 vat_json_init_array (&vam->json_tree);
2064 node = vat_json_array_add (&vam->json_tree);
2066 vat_json_init_object (node);
2067 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2068 vat_json_object_add_string_copy (node, "interface_name",
2069 mp->interface_name);
2070 vat_json_object_add_uint (node, "mode", mp->mode);
2071 vat_json_object_add_uint (node, "load_balance", mp->lb);
2072 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2073 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2077 api_sw_interface_bond_dump (vat_main_t * vam)
2079 vl_api_sw_interface_bond_dump_t *mp;
2080 vl_api_control_ping_t *mp_ping;
2084 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2085 "interface name", "sw_if_index", "mode", "load balance",
2086 "active slaves", "slaves");
2088 /* Get list of bond interfaces */
2089 M (SW_INTERFACE_BOND_DUMP, mp);
2092 /* Use a control ping for synchronization */
2093 MPING (CONTROL_PING, mp_ping);
2100 static void vl_api_sw_interface_slave_details_t_handler
2101 (vl_api_sw_interface_slave_details_t * mp)
2103 vat_main_t *vam = &vat_main;
2106 "%-25s %-12d %-12d %d", mp->interface_name,
2107 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2110 static void vl_api_sw_interface_slave_details_t_handler_json
2111 (vl_api_sw_interface_slave_details_t * mp)
2113 vat_main_t *vam = &vat_main;
2114 vat_json_node_t *node = NULL;
2116 if (VAT_JSON_ARRAY != vam->json_tree.type)
2118 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2119 vat_json_init_array (&vam->json_tree);
2121 node = vat_json_array_add (&vam->json_tree);
2123 vat_json_init_object (node);
2124 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2125 vat_json_object_add_string_copy (node, "interface_name",
2126 mp->interface_name);
2127 vat_json_object_add_uint (node, "passive", mp->is_passive);
2128 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2132 api_sw_interface_slave_dump (vat_main_t * vam)
2134 unformat_input_t *i = vam->input;
2135 vl_api_sw_interface_slave_dump_t *mp;
2136 vl_api_control_ping_t *mp_ping;
2137 u32 sw_if_index = ~0;
2138 u8 sw_if_index_set = 0;
2141 /* Parse args required to build the message */
2142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2144 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2145 sw_if_index_set = 1;
2146 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2147 sw_if_index_set = 1;
2152 if (sw_if_index_set == 0)
2154 errmsg ("missing vpp interface name. ");
2159 "\n%-25s %-12s %-12s %s",
2160 "slave interface name", "sw_if_index", "passive", "long_timeout");
2162 /* Get list of bond interfaces */
2163 M (SW_INTERFACE_SLAVE_DUMP, mp);
2164 mp->sw_if_index = ntohl (sw_if_index);
2167 /* Use a control ping for synchronization */
2168 MPING (CONTROL_PING, mp_ping);
2175 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2176 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2178 vat_main_t *vam = &vat_main;
2179 i32 retval = ntohl (mp->retval);
2180 if (vam->async_mode)
2182 vam->async_errors += (retval < 0);
2186 vam->retval = retval;
2187 vam->sw_if_index = ntohl (mp->sw_if_index);
2188 vam->result_ready = 1;
2190 vam->regenerate_interface_table = 1;
2193 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2194 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2196 vat_main_t *vam = &vat_main;
2197 vat_json_node_t node;
2199 vat_json_init_object (&node);
2200 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2201 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2202 ntohl (mp->sw_if_index));
2204 vat_json_print (vam->ofp, &node);
2205 vat_json_free (&node);
2207 vam->retval = ntohl (mp->retval);
2208 vam->result_ready = 1;
2211 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2212 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2214 vat_main_t *vam = &vat_main;
2215 i32 retval = ntohl (mp->retval);
2216 if (vam->async_mode)
2218 vam->async_errors += (retval < 0);
2222 vam->retval = retval;
2223 vam->sw_if_index = ntohl (mp->sw_if_index);
2224 vam->result_ready = 1;
2228 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2229 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2231 vat_main_t *vam = &vat_main;
2232 vat_json_node_t node;
2234 vat_json_init_object (&node);
2235 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2236 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2238 vat_json_print (vam->ofp, &node);
2239 vat_json_free (&node);
2241 vam->retval = ntohl (mp->retval);
2242 vam->result_ready = 1;
2245 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2246 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2248 vat_main_t *vam = &vat_main;
2249 i32 retval = ntohl (mp->retval);
2250 if (vam->async_mode)
2252 vam->async_errors += (retval < 0);
2256 vam->retval = retval;
2257 vam->result_ready = 1;
2261 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2262 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2264 vat_main_t *vam = &vat_main;
2265 vat_json_node_t node;
2267 vat_json_init_object (&node);
2268 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2269 vat_json_object_add_uint (&node, "fwd_entry_index",
2270 clib_net_to_host_u32 (mp->fwd_entry_index));
2272 vat_json_print (vam->ofp, &node);
2273 vat_json_free (&node);
2275 vam->retval = ntohl (mp->retval);
2276 vam->result_ready = 1;
2280 format_lisp_transport_protocol (u8 * s, va_list * args)
2282 u32 proto = va_arg (*args, u32);
2287 return format (s, "udp");
2289 return format (s, "api");
2296 static void vl_api_one_get_transport_protocol_reply_t_handler
2297 (vl_api_one_get_transport_protocol_reply_t * mp)
2299 vat_main_t *vam = &vat_main;
2300 i32 retval = ntohl (mp->retval);
2301 if (vam->async_mode)
2303 vam->async_errors += (retval < 0);
2307 u32 proto = mp->protocol;
2308 print (vam->ofp, "Transport protocol: %U",
2309 format_lisp_transport_protocol, proto);
2310 vam->retval = retval;
2311 vam->result_ready = 1;
2315 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2316 (vl_api_one_get_transport_protocol_reply_t * mp)
2318 vat_main_t *vam = &vat_main;
2319 vat_json_node_t node;
2322 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2325 vat_json_init_object (&node);
2326 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2327 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2330 vat_json_print (vam->ofp, &node);
2331 vat_json_free (&node);
2333 vam->retval = ntohl (mp->retval);
2334 vam->result_ready = 1;
2337 static void vl_api_one_add_del_locator_set_reply_t_handler
2338 (vl_api_one_add_del_locator_set_reply_t * mp)
2340 vat_main_t *vam = &vat_main;
2341 i32 retval = ntohl (mp->retval);
2342 if (vam->async_mode)
2344 vam->async_errors += (retval < 0);
2348 vam->retval = retval;
2349 vam->result_ready = 1;
2353 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2354 (vl_api_one_add_del_locator_set_reply_t * mp)
2356 vat_main_t *vam = &vat_main;
2357 vat_json_node_t node;
2359 vat_json_init_object (&node);
2360 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2361 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2363 vat_json_print (vam->ofp, &node);
2364 vat_json_free (&node);
2366 vam->retval = ntohl (mp->retval);
2367 vam->result_ready = 1;
2370 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2371 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2373 vat_main_t *vam = &vat_main;
2374 i32 retval = ntohl (mp->retval);
2375 if (vam->async_mode)
2377 vam->async_errors += (retval < 0);
2381 vam->retval = retval;
2382 vam->sw_if_index = ntohl (mp->sw_if_index);
2383 vam->result_ready = 1;
2385 vam->regenerate_interface_table = 1;
2388 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2389 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2391 vat_main_t *vam = &vat_main;
2392 vat_json_node_t node;
2394 vat_json_init_object (&node);
2395 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2396 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2398 vat_json_print (vam->ofp, &node);
2399 vat_json_free (&node);
2401 vam->retval = ntohl (mp->retval);
2402 vam->result_ready = 1;
2405 static void vl_api_vxlan_offload_rx_reply_t_handler
2406 (vl_api_vxlan_offload_rx_reply_t * mp)
2408 vat_main_t *vam = &vat_main;
2409 i32 retval = ntohl (mp->retval);
2410 if (vam->async_mode)
2412 vam->async_errors += (retval < 0);
2416 vam->retval = retval;
2417 vam->result_ready = 1;
2421 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2422 (vl_api_vxlan_offload_rx_reply_t * mp)
2424 vat_main_t *vam = &vat_main;
2425 vat_json_node_t node;
2427 vat_json_init_object (&node);
2428 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2430 vat_json_print (vam->ofp, &node);
2431 vat_json_free (&node);
2433 vam->retval = ntohl (mp->retval);
2434 vam->result_ready = 1;
2437 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2438 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2440 vat_main_t *vam = &vat_main;
2441 i32 retval = ntohl (mp->retval);
2442 if (vam->async_mode)
2444 vam->async_errors += (retval < 0);
2448 vam->retval = retval;
2449 vam->sw_if_index = ntohl (mp->sw_if_index);
2450 vam->result_ready = 1;
2454 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2455 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2457 vat_main_t *vam = &vat_main;
2458 vat_json_node_t node;
2460 vat_json_init_object (&node);
2461 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2462 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2464 vat_json_print (vam->ofp, &node);
2465 vat_json_free (&node);
2467 vam->retval = ntohl (mp->retval);
2468 vam->result_ready = 1;
2471 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2472 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2474 vat_main_t *vam = &vat_main;
2475 i32 retval = ntohl (mp->retval);
2476 if (vam->async_mode)
2478 vam->async_errors += (retval < 0);
2482 vam->retval = retval;
2483 vam->sw_if_index = ntohl (mp->sw_if_index);
2484 vam->result_ready = 1;
2486 vam->regenerate_interface_table = 1;
2489 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2490 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2492 vat_main_t *vam = &vat_main;
2493 vat_json_node_t node;
2495 vat_json_init_object (&node);
2496 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2497 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2499 vat_json_print (vam->ofp, &node);
2500 vat_json_free (&node);
2502 vam->retval = ntohl (mp->retval);
2503 vam->result_ready = 1;
2506 static void vl_api_gre_tunnel_add_del_reply_t_handler
2507 (vl_api_gre_tunnel_add_del_reply_t * mp)
2509 vat_main_t *vam = &vat_main;
2510 i32 retval = ntohl (mp->retval);
2511 if (vam->async_mode)
2513 vam->async_errors += (retval < 0);
2517 vam->retval = retval;
2518 vam->sw_if_index = ntohl (mp->sw_if_index);
2519 vam->result_ready = 1;
2523 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2524 (vl_api_gre_tunnel_add_del_reply_t * mp)
2526 vat_main_t *vam = &vat_main;
2527 vat_json_node_t node;
2529 vat_json_init_object (&node);
2530 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2531 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2533 vat_json_print (vam->ofp, &node);
2534 vat_json_free (&node);
2536 vam->retval = ntohl (mp->retval);
2537 vam->result_ready = 1;
2540 static void vl_api_create_vhost_user_if_reply_t_handler
2541 (vl_api_create_vhost_user_if_reply_t * mp)
2543 vat_main_t *vam = &vat_main;
2544 i32 retval = ntohl (mp->retval);
2545 if (vam->async_mode)
2547 vam->async_errors += (retval < 0);
2551 vam->retval = retval;
2552 vam->sw_if_index = ntohl (mp->sw_if_index);
2553 vam->result_ready = 1;
2555 vam->regenerate_interface_table = 1;
2558 static void vl_api_create_vhost_user_if_reply_t_handler_json
2559 (vl_api_create_vhost_user_if_reply_t * mp)
2561 vat_main_t *vam = &vat_main;
2562 vat_json_node_t node;
2564 vat_json_init_object (&node);
2565 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2566 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2568 vat_json_print (vam->ofp, &node);
2569 vat_json_free (&node);
2571 vam->retval = ntohl (mp->retval);
2572 vam->result_ready = 1;
2575 static void vl_api_dns_resolve_name_reply_t_handler
2576 (vl_api_dns_resolve_name_reply_t * mp)
2578 vat_main_t *vam = &vat_main;
2579 i32 retval = ntohl (mp->retval);
2580 if (vam->async_mode)
2582 vam->async_errors += (retval < 0);
2586 vam->retval = retval;
2587 vam->result_ready = 1;
2592 clib_warning ("ip4 address %U", format_ip4_address,
2593 (ip4_address_t *) mp->ip4_address);
2595 clib_warning ("ip6 address %U", format_ip6_address,
2596 (ip6_address_t *) mp->ip6_address);
2599 clib_warning ("retval %d", retval);
2603 static void vl_api_dns_resolve_name_reply_t_handler_json
2604 (vl_api_dns_resolve_name_reply_t * mp)
2606 clib_warning ("not implemented");
2609 static void vl_api_dns_resolve_ip_reply_t_handler
2610 (vl_api_dns_resolve_ip_reply_t * mp)
2612 vat_main_t *vam = &vat_main;
2613 i32 retval = ntohl (mp->retval);
2614 if (vam->async_mode)
2616 vam->async_errors += (retval < 0);
2620 vam->retval = retval;
2621 vam->result_ready = 1;
2625 clib_warning ("canonical name %s", mp->name);
2628 clib_warning ("retval %d", retval);
2632 static void vl_api_dns_resolve_ip_reply_t_handler_json
2633 (vl_api_dns_resolve_ip_reply_t * mp)
2635 clib_warning ("not implemented");
2639 static void vl_api_ip_address_details_t_handler
2640 (vl_api_ip_address_details_t * mp)
2642 vat_main_t *vam = &vat_main;
2643 static ip_address_details_t empty_ip_address_details = { {0} };
2644 ip_address_details_t *address = NULL;
2645 ip_details_t *current_ip_details = NULL;
2646 ip_details_t *details = NULL;
2648 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2650 if (!details || vam->current_sw_if_index >= vec_len (details)
2651 || !details[vam->current_sw_if_index].present)
2653 errmsg ("ip address details arrived but not stored");
2654 errmsg ("ip_dump should be called first");
2658 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2660 #define addresses (current_ip_details->addr)
2662 vec_validate_init_empty (addresses, vec_len (addresses),
2663 empty_ip_address_details);
2665 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2667 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2668 address->prefix_length = mp->prefix.address_length;
2672 static void vl_api_ip_address_details_t_handler_json
2673 (vl_api_ip_address_details_t * mp)
2675 vat_main_t *vam = &vat_main;
2676 vat_json_node_t *node = NULL;
2678 if (VAT_JSON_ARRAY != vam->json_tree.type)
2680 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2681 vat_json_init_array (&vam->json_tree);
2683 node = vat_json_array_add (&vam->json_tree);
2685 vat_json_init_object (node);
2686 vat_json_object_add_prefix (node, &mp->prefix);
2690 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2692 vat_main_t *vam = &vat_main;
2693 static ip_details_t empty_ip_details = { 0 };
2694 ip_details_t *ip = NULL;
2695 u32 sw_if_index = ~0;
2697 sw_if_index = ntohl (mp->sw_if_index);
2699 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2700 sw_if_index, empty_ip_details);
2702 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2709 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2711 vat_main_t *vam = &vat_main;
2713 if (VAT_JSON_ARRAY != vam->json_tree.type)
2715 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2716 vat_json_init_array (&vam->json_tree);
2718 vat_json_array_add_uint (&vam->json_tree,
2719 clib_net_to_host_u32 (mp->sw_if_index));
2723 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2727 s = format (0, "DHCP compl event: pid %d %s hostname %s host_addr %U "
2728 "host_mac %U router_addr %U",
2729 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2731 format_ip4_address, mp->lease.host_address,
2732 format_ethernet_address, mp->lease.host_mac,
2733 format_ip4_address, mp->lease.router_address);
2735 for (i = 0; i < mp->lease.count; i++)
2737 format (s, " domain_server_addr %U", format_ip4_address,
2738 mp->lease.domain_server[i].address);
2740 errmsg ((char *) s);
2744 static void vl_api_dhcp_compl_event_t_handler_json
2745 (vl_api_dhcp_compl_event_t * mp)
2747 /* JSON output not supported */
2750 static void vl_api_get_first_msg_id_reply_t_handler
2751 (vl_api_get_first_msg_id_reply_t * mp)
2753 vat_main_t *vam = &vat_main;
2754 i32 retval = ntohl (mp->retval);
2756 if (vam->async_mode)
2758 vam->async_errors += (retval < 0);
2762 vam->retval = retval;
2763 vam->result_ready = 1;
2767 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2771 static void vl_api_get_first_msg_id_reply_t_handler_json
2772 (vl_api_get_first_msg_id_reply_t * mp)
2774 vat_main_t *vam = &vat_main;
2775 vat_json_node_t node;
2777 vat_json_init_object (&node);
2778 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2779 vat_json_object_add_uint (&node, "first_msg_id",
2780 (uint) ntohs (mp->first_msg_id));
2782 vat_json_print (vam->ofp, &node);
2783 vat_json_free (&node);
2785 vam->retval = ntohl (mp->retval);
2786 vam->result_ready = 1;
2789 static void vl_api_get_node_graph_reply_t_handler
2790 (vl_api_get_node_graph_reply_t * mp)
2792 vat_main_t *vam = &vat_main;
2793 api_main_t *am = &api_main;
2794 i32 retval = ntohl (mp->retval);
2795 u8 *pvt_copy, *reply;
2800 if (vam->async_mode)
2802 vam->async_errors += (retval < 0);
2806 vam->retval = retval;
2807 vam->result_ready = 1;
2810 /* "Should never happen..." */
2814 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2815 pvt_copy = vec_dup (reply);
2817 /* Toss the shared-memory original... */
2818 pthread_mutex_lock (&am->vlib_rp->mutex);
2819 oldheap = svm_push_data_heap (am->vlib_rp);
2823 svm_pop_heap (oldheap);
2824 pthread_mutex_unlock (&am->vlib_rp->mutex);
2826 if (vam->graph_nodes)
2828 hash_free (vam->graph_node_index_by_name);
2830 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2832 node = vam->graph_nodes[0][i];
2833 vec_free (node->name);
2834 vec_free (node->next_nodes);
2837 vec_free (vam->graph_nodes[0]);
2838 vec_free (vam->graph_nodes);
2841 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2842 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2843 vec_free (pvt_copy);
2845 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2847 node = vam->graph_nodes[0][i];
2848 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2852 static void vl_api_get_node_graph_reply_t_handler_json
2853 (vl_api_get_node_graph_reply_t * mp)
2855 vat_main_t *vam = &vat_main;
2856 api_main_t *am = &api_main;
2858 vat_json_node_t node;
2861 /* $$$$ make this real? */
2862 vat_json_init_object (&node);
2863 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2864 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2866 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2868 /* Toss the shared-memory original... */
2869 pthread_mutex_lock (&am->vlib_rp->mutex);
2870 oldheap = svm_push_data_heap (am->vlib_rp);
2874 svm_pop_heap (oldheap);
2875 pthread_mutex_unlock (&am->vlib_rp->mutex);
2877 vat_json_print (vam->ofp, &node);
2878 vat_json_free (&node);
2880 vam->retval = ntohl (mp->retval);
2881 vam->result_ready = 1;
2885 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2887 vat_main_t *vam = &vat_main;
2892 s = format (s, "%=16d%=16d%=16d",
2893 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2897 s = format (s, "%=16U%=16d%=16d",
2898 mp->is_ipv6 ? format_ip6_address :
2900 mp->ip_address, mp->priority, mp->weight);
2903 print (vam->ofp, "%v", s);
2908 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2910 vat_main_t *vam = &vat_main;
2911 vat_json_node_t *node = NULL;
2912 struct in6_addr ip6;
2915 if (VAT_JSON_ARRAY != vam->json_tree.type)
2917 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2918 vat_json_init_array (&vam->json_tree);
2920 node = vat_json_array_add (&vam->json_tree);
2921 vat_json_init_object (node);
2923 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2924 vat_json_object_add_uint (node, "priority", mp->priority);
2925 vat_json_object_add_uint (node, "weight", mp->weight);
2928 vat_json_object_add_uint (node, "sw_if_index",
2929 clib_net_to_host_u32 (mp->sw_if_index));
2934 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2935 vat_json_object_add_ip6 (node, "address", ip6);
2939 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2940 vat_json_object_add_ip4 (node, "address", ip4);
2946 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2949 vat_main_t *vam = &vat_main;
2952 ls_name = format (0, "%s", mp->ls_name);
2954 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2960 vl_api_one_locator_set_details_t_handler_json
2961 (vl_api_one_locator_set_details_t * mp)
2963 vat_main_t *vam = &vat_main;
2964 vat_json_node_t *node = 0;
2967 ls_name = format (0, "%s", mp->ls_name);
2968 vec_add1 (ls_name, 0);
2970 if (VAT_JSON_ARRAY != vam->json_tree.type)
2972 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2973 vat_json_init_array (&vam->json_tree);
2975 node = vat_json_array_add (&vam->json_tree);
2977 vat_json_init_object (node);
2978 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2979 vat_json_object_add_uint (node, "ls_index",
2980 clib_net_to_host_u32 (mp->ls_index));
2988 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2991 unformat_nsh_address (unformat_input_t * input, va_list * args)
2993 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2994 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2998 format_nsh_address_vat (u8 * s, va_list * args)
3000 nsh_t *a = va_arg (*args, nsh_t *);
3001 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
3005 format_lisp_flat_eid (u8 * s, va_list * args)
3007 u32 type = va_arg (*args, u32);
3008 u8 *eid = va_arg (*args, u8 *);
3009 u32 eid_len = va_arg (*args, u32);
3014 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3016 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3018 return format (s, "%U", format_ethernet_address, eid);
3020 return format (s, "%U", format_nsh_address_vat, eid);
3026 format_lisp_eid_vat (u8 * s, va_list * args)
3028 u32 type = va_arg (*args, u32);
3029 u8 *eid = va_arg (*args, u8 *);
3030 u32 eid_len = va_arg (*args, u32);
3031 u8 *seid = va_arg (*args, u8 *);
3032 u32 seid_len = va_arg (*args, u32);
3033 u32 is_src_dst = va_arg (*args, u32);
3036 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3038 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3044 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3046 vat_main_t *vam = &vat_main;
3047 u8 *s = 0, *eid = 0;
3049 if (~0 == mp->locator_set_index)
3050 s = format (0, "action: %d", mp->action);
3052 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3054 eid = format (0, "%U", format_lisp_eid_vat,
3058 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3061 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3062 clib_net_to_host_u32 (mp->vni),
3064 mp->is_local ? "local" : "remote",
3065 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3066 clib_net_to_host_u16 (mp->key_id), mp->key);
3073 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3076 vat_main_t *vam = &vat_main;
3077 vat_json_node_t *node = 0;
3080 if (VAT_JSON_ARRAY != vam->json_tree.type)
3082 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3083 vat_json_init_array (&vam->json_tree);
3085 node = vat_json_array_add (&vam->json_tree);
3087 vat_json_init_object (node);
3088 if (~0 == mp->locator_set_index)
3089 vat_json_object_add_uint (node, "action", mp->action);
3091 vat_json_object_add_uint (node, "locator_set_index",
3092 clib_net_to_host_u32 (mp->locator_set_index));
3094 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3095 if (mp->eid_type == 3)
3097 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3098 vat_json_init_object (nsh_json);
3099 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3100 vat_json_object_add_uint (nsh_json, "spi",
3101 clib_net_to_host_u32 (nsh->spi));
3102 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3106 eid = format (0, "%U", format_lisp_eid_vat,
3110 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3112 vat_json_object_add_string_copy (node, "eid", eid);
3115 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3116 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3117 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3121 vat_json_object_add_uint (node, "key_id",
3122 clib_net_to_host_u16 (mp->key_id));
3123 vat_json_object_add_string_copy (node, "key", mp->key);
3128 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3130 vat_main_t *vam = &vat_main;
3131 u8 *seid = 0, *deid = 0;
3132 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3134 deid = format (0, "%U", format_lisp_eid_vat,
3135 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3137 seid = format (0, "%U", format_lisp_eid_vat,
3138 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3144 format_ip_address_fcn = format_ip4_address;
3146 format_ip_address_fcn = format_ip6_address;
3149 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3150 clib_net_to_host_u32 (mp->vni),
3152 format_ip_address_fcn, mp->lloc,
3153 format_ip_address_fcn, mp->rloc,
3154 clib_net_to_host_u32 (mp->pkt_count),
3155 clib_net_to_host_u32 (mp->bytes));
3162 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3164 struct in6_addr ip6;
3166 vat_main_t *vam = &vat_main;
3167 vat_json_node_t *node = 0;
3168 u8 *deid = 0, *seid = 0;
3170 if (VAT_JSON_ARRAY != vam->json_tree.type)
3172 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3173 vat_json_init_array (&vam->json_tree);
3175 node = vat_json_array_add (&vam->json_tree);
3177 vat_json_init_object (node);
3178 deid = format (0, "%U", format_lisp_eid_vat,
3179 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3181 seid = format (0, "%U", format_lisp_eid_vat,
3182 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3187 vat_json_object_add_string_copy (node, "seid", seid);
3188 vat_json_object_add_string_copy (node, "deid", deid);
3189 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3193 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3194 vat_json_object_add_ip4 (node, "lloc", ip4);
3195 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3196 vat_json_object_add_ip4 (node, "rloc", ip4);
3200 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3201 vat_json_object_add_ip6 (node, "lloc", ip6);
3202 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3203 vat_json_object_add_ip6 (node, "rloc", ip6);
3205 vat_json_object_add_uint (node, "pkt_count",
3206 clib_net_to_host_u32 (mp->pkt_count));
3207 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3214 vl_api_one_eid_table_map_details_t_handler
3215 (vl_api_one_eid_table_map_details_t * mp)
3217 vat_main_t *vam = &vat_main;
3219 u8 *line = format (0, "%=10d%=10d",
3220 clib_net_to_host_u32 (mp->vni),
3221 clib_net_to_host_u32 (mp->dp_table));
3222 print (vam->ofp, "%v", line);
3227 vl_api_one_eid_table_map_details_t_handler_json
3228 (vl_api_one_eid_table_map_details_t * mp)
3230 vat_main_t *vam = &vat_main;
3231 vat_json_node_t *node = NULL;
3233 if (VAT_JSON_ARRAY != vam->json_tree.type)
3235 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3236 vat_json_init_array (&vam->json_tree);
3238 node = vat_json_array_add (&vam->json_tree);
3239 vat_json_init_object (node);
3240 vat_json_object_add_uint (node, "dp_table",
3241 clib_net_to_host_u32 (mp->dp_table));
3242 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3246 vl_api_one_eid_table_vni_details_t_handler
3247 (vl_api_one_eid_table_vni_details_t * mp)
3249 vat_main_t *vam = &vat_main;
3251 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3252 print (vam->ofp, "%v", line);
3257 vl_api_one_eid_table_vni_details_t_handler_json
3258 (vl_api_one_eid_table_vni_details_t * mp)
3260 vat_main_t *vam = &vat_main;
3261 vat_json_node_t *node = NULL;
3263 if (VAT_JSON_ARRAY != vam->json_tree.type)
3265 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3266 vat_json_init_array (&vam->json_tree);
3268 node = vat_json_array_add (&vam->json_tree);
3269 vat_json_init_object (node);
3270 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3274 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3275 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3277 vat_main_t *vam = &vat_main;
3278 int retval = clib_net_to_host_u32 (mp->retval);
3280 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3281 print (vam->ofp, "fallback threshold value: %d", mp->value);
3283 vam->retval = retval;
3284 vam->result_ready = 1;
3288 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3289 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3291 vat_main_t *vam = &vat_main;
3292 vat_json_node_t _node, *node = &_node;
3293 int retval = clib_net_to_host_u32 (mp->retval);
3295 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3296 vat_json_init_object (node);
3297 vat_json_object_add_uint (node, "value", mp->value);
3299 vat_json_print (vam->ofp, node);
3300 vat_json_free (node);
3302 vam->retval = retval;
3303 vam->result_ready = 1;
3307 vl_api_show_one_map_register_state_reply_t_handler
3308 (vl_api_show_one_map_register_state_reply_t * mp)
3310 vat_main_t *vam = &vat_main;
3311 int retval = clib_net_to_host_u32 (mp->retval);
3313 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3315 vam->retval = retval;
3316 vam->result_ready = 1;
3320 vl_api_show_one_map_register_state_reply_t_handler_json
3321 (vl_api_show_one_map_register_state_reply_t * mp)
3323 vat_main_t *vam = &vat_main;
3324 vat_json_node_t _node, *node = &_node;
3325 int retval = clib_net_to_host_u32 (mp->retval);
3327 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3329 vat_json_init_object (node);
3330 vat_json_object_add_string_copy (node, "state", s);
3332 vat_json_print (vam->ofp, node);
3333 vat_json_free (node);
3335 vam->retval = retval;
3336 vam->result_ready = 1;
3341 vl_api_show_one_rloc_probe_state_reply_t_handler
3342 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3344 vat_main_t *vam = &vat_main;
3345 int retval = clib_net_to_host_u32 (mp->retval);
3350 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3352 vam->retval = retval;
3353 vam->result_ready = 1;
3357 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3358 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3360 vat_main_t *vam = &vat_main;
3361 vat_json_node_t _node, *node = &_node;
3362 int retval = clib_net_to_host_u32 (mp->retval);
3364 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3365 vat_json_init_object (node);
3366 vat_json_object_add_string_copy (node, "state", s);
3368 vat_json_print (vam->ofp, node);
3369 vat_json_free (node);
3371 vam->retval = retval;
3372 vam->result_ready = 1;
3377 vl_api_show_one_stats_enable_disable_reply_t_handler
3378 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3380 vat_main_t *vam = &vat_main;
3381 int retval = clib_net_to_host_u32 (mp->retval);
3386 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3388 vam->retval = retval;
3389 vam->result_ready = 1;
3393 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3394 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3396 vat_main_t *vam = &vat_main;
3397 vat_json_node_t _node, *node = &_node;
3398 int retval = clib_net_to_host_u32 (mp->retval);
3400 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3401 vat_json_init_object (node);
3402 vat_json_object_add_string_copy (node, "state", s);
3404 vat_json_print (vam->ofp, node);
3405 vat_json_free (node);
3407 vam->retval = retval;
3408 vam->result_ready = 1;
3413 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3415 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3416 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3417 e->vni = clib_net_to_host_u32 (e->vni);
3421 gpe_fwd_entries_get_reply_t_net_to_host
3422 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3426 mp->count = clib_net_to_host_u32 (mp->count);
3427 for (i = 0; i < mp->count; i++)
3429 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3434 format_gpe_encap_mode (u8 * s, va_list * args)
3436 u32 mode = va_arg (*args, u32);
3441 return format (s, "lisp");
3443 return format (s, "vxlan");
3449 vl_api_gpe_get_encap_mode_reply_t_handler
3450 (vl_api_gpe_get_encap_mode_reply_t * mp)
3452 vat_main_t *vam = &vat_main;
3454 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3455 vam->retval = ntohl (mp->retval);
3456 vam->result_ready = 1;
3460 vl_api_gpe_get_encap_mode_reply_t_handler_json
3461 (vl_api_gpe_get_encap_mode_reply_t * mp)
3463 vat_main_t *vam = &vat_main;
3464 vat_json_node_t node;
3466 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3467 vec_add1 (encap_mode, 0);
3469 vat_json_init_object (&node);
3470 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3472 vec_free (encap_mode);
3473 vat_json_print (vam->ofp, &node);
3474 vat_json_free (&node);
3476 vam->retval = ntohl (mp->retval);
3477 vam->result_ready = 1;
3481 vl_api_gpe_fwd_entry_path_details_t_handler
3482 (vl_api_gpe_fwd_entry_path_details_t * mp)
3484 vat_main_t *vam = &vat_main;
3485 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3487 if (mp->lcl_loc.is_ip4)
3488 format_ip_address_fcn = format_ip4_address;
3490 format_ip_address_fcn = format_ip6_address;
3492 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3493 format_ip_address_fcn, &mp->lcl_loc,
3494 format_ip_address_fcn, &mp->rmt_loc);
3498 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3500 struct in6_addr ip6;
3505 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3506 vat_json_object_add_ip4 (n, "address", ip4);
3510 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3511 vat_json_object_add_ip6 (n, "address", ip6);
3513 vat_json_object_add_uint (n, "weight", loc->weight);
3517 vl_api_gpe_fwd_entry_path_details_t_handler_json
3518 (vl_api_gpe_fwd_entry_path_details_t * mp)
3520 vat_main_t *vam = &vat_main;
3521 vat_json_node_t *node = NULL;
3522 vat_json_node_t *loc_node;
3524 if (VAT_JSON_ARRAY != vam->json_tree.type)
3526 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3527 vat_json_init_array (&vam->json_tree);
3529 node = vat_json_array_add (&vam->json_tree);
3530 vat_json_init_object (node);
3532 loc_node = vat_json_object_add (node, "local_locator");
3533 vat_json_init_object (loc_node);
3534 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3536 loc_node = vat_json_object_add (node, "remote_locator");
3537 vat_json_init_object (loc_node);
3538 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3542 vl_api_gpe_fwd_entries_get_reply_t_handler
3543 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3545 vat_main_t *vam = &vat_main;
3547 int retval = clib_net_to_host_u32 (mp->retval);
3548 vl_api_gpe_fwd_entry_t *e;
3553 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3555 for (i = 0; i < mp->count; i++)
3557 e = &mp->entries[i];
3558 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3559 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3560 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3564 vam->retval = retval;
3565 vam->result_ready = 1;
3569 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3570 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3573 vat_main_t *vam = &vat_main;
3574 vat_json_node_t *e = 0, root;
3576 int retval = clib_net_to_host_u32 (mp->retval);
3577 vl_api_gpe_fwd_entry_t *fwd;
3582 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3583 vat_json_init_array (&root);
3585 for (i = 0; i < mp->count; i++)
3587 e = vat_json_array_add (&root);
3588 fwd = &mp->entries[i];
3590 vat_json_init_object (e);
3591 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3592 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3593 vat_json_object_add_int (e, "vni", fwd->vni);
3594 vat_json_object_add_int (e, "action", fwd->action);
3596 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3597 fwd->leid_prefix_len);
3599 vat_json_object_add_string_copy (e, "leid", s);
3602 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3603 fwd->reid_prefix_len);
3605 vat_json_object_add_string_copy (e, "reid", s);
3609 vat_json_print (vam->ofp, &root);
3610 vat_json_free (&root);
3613 vam->retval = retval;
3614 vam->result_ready = 1;
3618 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3619 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3621 vat_main_t *vam = &vat_main;
3623 int retval = clib_net_to_host_u32 (mp->retval);
3624 vl_api_gpe_native_fwd_rpath_t *r;
3629 n = clib_net_to_host_u32 (mp->count);
3631 for (i = 0; i < n; i++)
3633 r = &mp->entries[i];
3634 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3635 clib_net_to_host_u32 (r->fib_index),
3636 clib_net_to_host_u32 (r->nh_sw_if_index),
3637 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3641 vam->retval = retval;
3642 vam->result_ready = 1;
3646 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3647 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3649 vat_main_t *vam = &vat_main;
3650 vat_json_node_t root, *e;
3652 int retval = clib_net_to_host_u32 (mp->retval);
3653 vl_api_gpe_native_fwd_rpath_t *r;
3659 n = clib_net_to_host_u32 (mp->count);
3660 vat_json_init_array (&root);
3662 for (i = 0; i < n; i++)
3664 e = vat_json_array_add (&root);
3665 vat_json_init_object (e);
3666 r = &mp->entries[i];
3668 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3671 vat_json_object_add_string_copy (e, "ip4", s);
3674 vat_json_object_add_uint (e, "fib_index",
3675 clib_net_to_host_u32 (r->fib_index));
3676 vat_json_object_add_uint (e, "nh_sw_if_index",
3677 clib_net_to_host_u32 (r->nh_sw_if_index));
3680 vat_json_print (vam->ofp, &root);
3681 vat_json_free (&root);
3684 vam->retval = retval;
3685 vam->result_ready = 1;
3689 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3690 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3692 vat_main_t *vam = &vat_main;
3694 int retval = clib_net_to_host_u32 (mp->retval);
3699 n = clib_net_to_host_u32 (mp->count);
3701 for (i = 0; i < n; i++)
3702 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3705 vam->retval = retval;
3706 vam->result_ready = 1;
3710 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3711 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3713 vat_main_t *vam = &vat_main;
3714 vat_json_node_t root;
3716 int retval = clib_net_to_host_u32 (mp->retval);
3721 n = clib_net_to_host_u32 (mp->count);
3722 vat_json_init_array (&root);
3724 for (i = 0; i < n; i++)
3725 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3727 vat_json_print (vam->ofp, &root);
3728 vat_json_free (&root);
3731 vam->retval = retval;
3732 vam->result_ready = 1;
3736 vl_api_one_ndp_entries_get_reply_t_handler
3737 (vl_api_one_ndp_entries_get_reply_t * mp)
3739 vat_main_t *vam = &vat_main;
3741 int retval = clib_net_to_host_u32 (mp->retval);
3746 n = clib_net_to_host_u32 (mp->count);
3748 for (i = 0; i < n; i++)
3749 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3750 format_ethernet_address, mp->entries[i].mac);
3753 vam->retval = retval;
3754 vam->result_ready = 1;
3758 vl_api_one_ndp_entries_get_reply_t_handler_json
3759 (vl_api_one_ndp_entries_get_reply_t * mp)
3762 vat_main_t *vam = &vat_main;
3763 vat_json_node_t *e = 0, root;
3765 int retval = clib_net_to_host_u32 (mp->retval);
3766 vl_api_one_ndp_entry_t *arp_entry;
3771 n = clib_net_to_host_u32 (mp->count);
3772 vat_json_init_array (&root);
3774 for (i = 0; i < n; i++)
3776 e = vat_json_array_add (&root);
3777 arp_entry = &mp->entries[i];
3779 vat_json_init_object (e);
3780 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3783 vat_json_object_add_string_copy (e, "mac", s);
3786 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3788 vat_json_object_add_string_copy (e, "ip6", s);
3792 vat_json_print (vam->ofp, &root);
3793 vat_json_free (&root);
3796 vam->retval = retval;
3797 vam->result_ready = 1;
3801 vl_api_one_l2_arp_entries_get_reply_t_handler
3802 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3804 vat_main_t *vam = &vat_main;
3806 int retval = clib_net_to_host_u32 (mp->retval);
3811 n = clib_net_to_host_u32 (mp->count);
3813 for (i = 0; i < n; i++)
3814 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3815 format_ethernet_address, mp->entries[i].mac);
3818 vam->retval = retval;
3819 vam->result_ready = 1;
3823 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3824 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3827 vat_main_t *vam = &vat_main;
3828 vat_json_node_t *e = 0, root;
3830 int retval = clib_net_to_host_u32 (mp->retval);
3831 vl_api_one_l2_arp_entry_t *arp_entry;
3836 n = clib_net_to_host_u32 (mp->count);
3837 vat_json_init_array (&root);
3839 for (i = 0; i < n; i++)
3841 e = vat_json_array_add (&root);
3842 arp_entry = &mp->entries[i];
3844 vat_json_init_object (e);
3845 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3848 vat_json_object_add_string_copy (e, "mac", s);
3851 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3853 vat_json_object_add_string_copy (e, "ip4", s);
3857 vat_json_print (vam->ofp, &root);
3858 vat_json_free (&root);
3861 vam->retval = retval;
3862 vam->result_ready = 1;
3866 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3868 vat_main_t *vam = &vat_main;
3870 int retval = clib_net_to_host_u32 (mp->retval);
3875 n = clib_net_to_host_u32 (mp->count);
3877 for (i = 0; i < n; i++)
3879 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3883 vam->retval = retval;
3884 vam->result_ready = 1;
3888 vl_api_one_ndp_bd_get_reply_t_handler_json
3889 (vl_api_one_ndp_bd_get_reply_t * mp)
3891 vat_main_t *vam = &vat_main;
3892 vat_json_node_t root;
3894 int retval = clib_net_to_host_u32 (mp->retval);
3899 n = clib_net_to_host_u32 (mp->count);
3900 vat_json_init_array (&root);
3902 for (i = 0; i < n; i++)
3904 vat_json_array_add_uint (&root,
3905 clib_net_to_host_u32 (mp->bridge_domains[i]));
3908 vat_json_print (vam->ofp, &root);
3909 vat_json_free (&root);
3912 vam->retval = retval;
3913 vam->result_ready = 1;
3917 vl_api_one_l2_arp_bd_get_reply_t_handler
3918 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3920 vat_main_t *vam = &vat_main;
3922 int retval = clib_net_to_host_u32 (mp->retval);
3927 n = clib_net_to_host_u32 (mp->count);
3929 for (i = 0; i < n; i++)
3931 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3935 vam->retval = retval;
3936 vam->result_ready = 1;
3940 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3941 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3943 vat_main_t *vam = &vat_main;
3944 vat_json_node_t root;
3946 int retval = clib_net_to_host_u32 (mp->retval);
3951 n = clib_net_to_host_u32 (mp->count);
3952 vat_json_init_array (&root);
3954 for (i = 0; i < n; i++)
3956 vat_json_array_add_uint (&root,
3957 clib_net_to_host_u32 (mp->bridge_domains[i]));
3960 vat_json_print (vam->ofp, &root);
3961 vat_json_free (&root);
3964 vam->retval = retval;
3965 vam->result_ready = 1;
3969 vl_api_one_adjacencies_get_reply_t_handler
3970 (vl_api_one_adjacencies_get_reply_t * mp)
3972 vat_main_t *vam = &vat_main;
3974 int retval = clib_net_to_host_u32 (mp->retval);
3975 vl_api_one_adjacency_t *a;
3980 n = clib_net_to_host_u32 (mp->count);
3982 for (i = 0; i < n; i++)
3984 a = &mp->adjacencies[i];
3985 print (vam->ofp, "%U %40U",
3986 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3987 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3991 vam->retval = retval;
3992 vam->result_ready = 1;
3996 vl_api_one_adjacencies_get_reply_t_handler_json
3997 (vl_api_one_adjacencies_get_reply_t * mp)
4000 vat_main_t *vam = &vat_main;
4001 vat_json_node_t *e = 0, root;
4003 int retval = clib_net_to_host_u32 (mp->retval);
4004 vl_api_one_adjacency_t *a;
4009 n = clib_net_to_host_u32 (mp->count);
4010 vat_json_init_array (&root);
4012 for (i = 0; i < n; i++)
4014 e = vat_json_array_add (&root);
4015 a = &mp->adjacencies[i];
4017 vat_json_init_object (e);
4018 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4019 a->leid_prefix_len);
4021 vat_json_object_add_string_copy (e, "leid", s);
4024 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4025 a->reid_prefix_len);
4027 vat_json_object_add_string_copy (e, "reid", s);
4031 vat_json_print (vam->ofp, &root);
4032 vat_json_free (&root);
4035 vam->retval = retval;
4036 vam->result_ready = 1;
4040 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4042 vat_main_t *vam = &vat_main;
4044 print (vam->ofp, "%=20U",
4045 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4050 vl_api_one_map_server_details_t_handler_json
4051 (vl_api_one_map_server_details_t * mp)
4053 vat_main_t *vam = &vat_main;
4054 vat_json_node_t *node = NULL;
4055 struct in6_addr ip6;
4058 if (VAT_JSON_ARRAY != vam->json_tree.type)
4060 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4061 vat_json_init_array (&vam->json_tree);
4063 node = vat_json_array_add (&vam->json_tree);
4065 vat_json_init_object (node);
4068 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4069 vat_json_object_add_ip6 (node, "map-server", ip6);
4073 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4074 vat_json_object_add_ip4 (node, "map-server", ip4);
4079 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4082 vat_main_t *vam = &vat_main;
4084 print (vam->ofp, "%=20U",
4085 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4090 vl_api_one_map_resolver_details_t_handler_json
4091 (vl_api_one_map_resolver_details_t * mp)
4093 vat_main_t *vam = &vat_main;
4094 vat_json_node_t *node = NULL;
4095 struct in6_addr ip6;
4098 if (VAT_JSON_ARRAY != vam->json_tree.type)
4100 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4101 vat_json_init_array (&vam->json_tree);
4103 node = vat_json_array_add (&vam->json_tree);
4105 vat_json_init_object (node);
4108 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4109 vat_json_object_add_ip6 (node, "map resolver", ip6);
4113 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4114 vat_json_object_add_ip4 (node, "map resolver", ip4);
4119 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4121 vat_main_t *vam = &vat_main;
4122 i32 retval = ntohl (mp->retval);
4126 print (vam->ofp, "feature: %s\ngpe: %s",
4127 mp->feature_status ? "enabled" : "disabled",
4128 mp->gpe_status ? "enabled" : "disabled");
4131 vam->retval = retval;
4132 vam->result_ready = 1;
4136 vl_api_show_one_status_reply_t_handler_json
4137 (vl_api_show_one_status_reply_t * mp)
4139 vat_main_t *vam = &vat_main;
4140 vat_json_node_t node;
4141 u8 *gpe_status = NULL;
4142 u8 *feature_status = NULL;
4144 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4145 feature_status = format (0, "%s",
4146 mp->feature_status ? "enabled" : "disabled");
4147 vec_add1 (gpe_status, 0);
4148 vec_add1 (feature_status, 0);
4150 vat_json_init_object (&node);
4151 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4152 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4154 vec_free (gpe_status);
4155 vec_free (feature_status);
4157 vat_json_print (vam->ofp, &node);
4158 vat_json_free (&node);
4160 vam->retval = ntohl (mp->retval);
4161 vam->result_ready = 1;
4165 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4166 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4168 vat_main_t *vam = &vat_main;
4169 i32 retval = ntohl (mp->retval);
4173 print (vam->ofp, "%=20s", mp->locator_set_name);
4176 vam->retval = retval;
4177 vam->result_ready = 1;
4181 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4182 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4184 vat_main_t *vam = &vat_main;
4185 vat_json_node_t *node = NULL;
4187 if (VAT_JSON_ARRAY != vam->json_tree.type)
4189 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4190 vat_json_init_array (&vam->json_tree);
4192 node = vat_json_array_add (&vam->json_tree);
4194 vat_json_init_object (node);
4195 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4197 vat_json_print (vam->ofp, node);
4198 vat_json_free (node);
4200 vam->retval = ntohl (mp->retval);
4201 vam->result_ready = 1;
4205 format_lisp_map_request_mode (u8 * s, va_list * args)
4207 u32 mode = va_arg (*args, u32);
4212 return format (0, "dst-only");
4214 return format (0, "src-dst");
4220 vl_api_show_one_map_request_mode_reply_t_handler
4221 (vl_api_show_one_map_request_mode_reply_t * mp)
4223 vat_main_t *vam = &vat_main;
4224 i32 retval = ntohl (mp->retval);
4228 u32 mode = mp->mode;
4229 print (vam->ofp, "map_request_mode: %U",
4230 format_lisp_map_request_mode, mode);
4233 vam->retval = retval;
4234 vam->result_ready = 1;
4238 vl_api_show_one_map_request_mode_reply_t_handler_json
4239 (vl_api_show_one_map_request_mode_reply_t * mp)
4241 vat_main_t *vam = &vat_main;
4242 vat_json_node_t node;
4247 s = format (0, "%U", format_lisp_map_request_mode, mode);
4250 vat_json_init_object (&node);
4251 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4252 vat_json_print (vam->ofp, &node);
4253 vat_json_free (&node);
4256 vam->retval = ntohl (mp->retval);
4257 vam->result_ready = 1;
4261 vl_api_one_show_xtr_mode_reply_t_handler
4262 (vl_api_one_show_xtr_mode_reply_t * mp)
4264 vat_main_t *vam = &vat_main;
4265 i32 retval = ntohl (mp->retval);
4269 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4272 vam->retval = retval;
4273 vam->result_ready = 1;
4277 vl_api_one_show_xtr_mode_reply_t_handler_json
4278 (vl_api_one_show_xtr_mode_reply_t * mp)
4280 vat_main_t *vam = &vat_main;
4281 vat_json_node_t node;
4284 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4285 vec_add1 (status, 0);
4287 vat_json_init_object (&node);
4288 vat_json_object_add_string_copy (&node, "status", status);
4292 vat_json_print (vam->ofp, &node);
4293 vat_json_free (&node);
4295 vam->retval = ntohl (mp->retval);
4296 vam->result_ready = 1;
4300 vl_api_one_show_pitr_mode_reply_t_handler
4301 (vl_api_one_show_pitr_mode_reply_t * mp)
4303 vat_main_t *vam = &vat_main;
4304 i32 retval = ntohl (mp->retval);
4308 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4311 vam->retval = retval;
4312 vam->result_ready = 1;
4316 vl_api_one_show_pitr_mode_reply_t_handler_json
4317 (vl_api_one_show_pitr_mode_reply_t * mp)
4319 vat_main_t *vam = &vat_main;
4320 vat_json_node_t node;
4323 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4324 vec_add1 (status, 0);
4326 vat_json_init_object (&node);
4327 vat_json_object_add_string_copy (&node, "status", status);
4331 vat_json_print (vam->ofp, &node);
4332 vat_json_free (&node);
4334 vam->retval = ntohl (mp->retval);
4335 vam->result_ready = 1;
4339 vl_api_one_show_petr_mode_reply_t_handler
4340 (vl_api_one_show_petr_mode_reply_t * mp)
4342 vat_main_t *vam = &vat_main;
4343 i32 retval = ntohl (mp->retval);
4347 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4350 vam->retval = retval;
4351 vam->result_ready = 1;
4355 vl_api_one_show_petr_mode_reply_t_handler_json
4356 (vl_api_one_show_petr_mode_reply_t * mp)
4358 vat_main_t *vam = &vat_main;
4359 vat_json_node_t node;
4362 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4363 vec_add1 (status, 0);
4365 vat_json_init_object (&node);
4366 vat_json_object_add_string_copy (&node, "status", status);
4370 vat_json_print (vam->ofp, &node);
4371 vat_json_free (&node);
4373 vam->retval = ntohl (mp->retval);
4374 vam->result_ready = 1;
4378 vl_api_show_one_use_petr_reply_t_handler
4379 (vl_api_show_one_use_petr_reply_t * mp)
4381 vat_main_t *vam = &vat_main;
4382 i32 retval = ntohl (mp->retval);
4386 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4389 print (vam->ofp, "Proxy-ETR address; %U",
4390 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4395 vam->retval = retval;
4396 vam->result_ready = 1;
4400 vl_api_show_one_use_petr_reply_t_handler_json
4401 (vl_api_show_one_use_petr_reply_t * mp)
4403 vat_main_t *vam = &vat_main;
4404 vat_json_node_t node;
4407 struct in6_addr ip6;
4409 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4410 vec_add1 (status, 0);
4412 vat_json_init_object (&node);
4413 vat_json_object_add_string_copy (&node, "status", status);
4418 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4419 vat_json_object_add_ip6 (&node, "address", ip6);
4423 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4424 vat_json_object_add_ip4 (&node, "address", ip4);
4430 vat_json_print (vam->ofp, &node);
4431 vat_json_free (&node);
4433 vam->retval = ntohl (mp->retval);
4434 vam->result_ready = 1;
4438 vl_api_show_one_nsh_mapping_reply_t_handler
4439 (vl_api_show_one_nsh_mapping_reply_t * mp)
4441 vat_main_t *vam = &vat_main;
4442 i32 retval = ntohl (mp->retval);
4446 print (vam->ofp, "%-20s%-16s",
4447 mp->is_set ? "set" : "not-set",
4448 mp->is_set ? (char *) mp->locator_set_name : "");
4451 vam->retval = retval;
4452 vam->result_ready = 1;
4456 vl_api_show_one_nsh_mapping_reply_t_handler_json
4457 (vl_api_show_one_nsh_mapping_reply_t * mp)
4459 vat_main_t *vam = &vat_main;
4460 vat_json_node_t node;
4463 status = format (0, "%s", mp->is_set ? "yes" : "no");
4464 vec_add1 (status, 0);
4466 vat_json_init_object (&node);
4467 vat_json_object_add_string_copy (&node, "is_set", status);
4470 vat_json_object_add_string_copy (&node, "locator_set",
4471 mp->locator_set_name);
4476 vat_json_print (vam->ofp, &node);
4477 vat_json_free (&node);
4479 vam->retval = ntohl (mp->retval);
4480 vam->result_ready = 1;
4484 vl_api_show_one_map_register_ttl_reply_t_handler
4485 (vl_api_show_one_map_register_ttl_reply_t * mp)
4487 vat_main_t *vam = &vat_main;
4488 i32 retval = ntohl (mp->retval);
4490 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4494 print (vam->ofp, "ttl: %u", mp->ttl);
4497 vam->retval = retval;
4498 vam->result_ready = 1;
4502 vl_api_show_one_map_register_ttl_reply_t_handler_json
4503 (vl_api_show_one_map_register_ttl_reply_t * mp)
4505 vat_main_t *vam = &vat_main;
4506 vat_json_node_t node;
4508 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4509 vat_json_init_object (&node);
4510 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4512 vat_json_print (vam->ofp, &node);
4513 vat_json_free (&node);
4515 vam->retval = ntohl (mp->retval);
4516 vam->result_ready = 1;
4520 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4522 vat_main_t *vam = &vat_main;
4523 i32 retval = ntohl (mp->retval);
4527 print (vam->ofp, "%-20s%-16s",
4528 mp->status ? "enabled" : "disabled",
4529 mp->status ? (char *) mp->locator_set_name : "");
4532 vam->retval = retval;
4533 vam->result_ready = 1;
4537 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4539 vat_main_t *vam = &vat_main;
4540 vat_json_node_t node;
4543 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4544 vec_add1 (status, 0);
4546 vat_json_init_object (&node);
4547 vat_json_object_add_string_copy (&node, "status", status);
4550 vat_json_object_add_string_copy (&node, "locator_set",
4551 mp->locator_set_name);
4556 vat_json_print (vam->ofp, &node);
4557 vat_json_free (&node);
4559 vam->retval = ntohl (mp->retval);
4560 vam->result_ready = 1;
4564 format_policer_type (u8 * s, va_list * va)
4566 u32 i = va_arg (*va, u32);
4568 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4569 s = format (s, "1r2c");
4570 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4571 s = format (s, "1r3c");
4572 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4573 s = format (s, "2r3c-2698");
4574 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4575 s = format (s, "2r3c-4115");
4576 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4577 s = format (s, "2r3c-mef5cf1");
4579 s = format (s, "ILLEGAL");
4584 format_policer_rate_type (u8 * s, va_list * va)
4586 u32 i = va_arg (*va, u32);
4588 if (i == SSE2_QOS_RATE_KBPS)
4589 s = format (s, "kbps");
4590 else if (i == SSE2_QOS_RATE_PPS)
4591 s = format (s, "pps");
4593 s = format (s, "ILLEGAL");
4598 format_policer_round_type (u8 * s, va_list * va)
4600 u32 i = va_arg (*va, u32);
4602 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4603 s = format (s, "closest");
4604 else if (i == SSE2_QOS_ROUND_TO_UP)
4605 s = format (s, "up");
4606 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4607 s = format (s, "down");
4609 s = format (s, "ILLEGAL");
4614 format_policer_action_type (u8 * s, va_list * va)
4616 u32 i = va_arg (*va, u32);
4618 if (i == SSE2_QOS_ACTION_DROP)
4619 s = format (s, "drop");
4620 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4621 s = format (s, "transmit");
4622 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4623 s = format (s, "mark-and-transmit");
4625 s = format (s, "ILLEGAL");
4630 format_dscp (u8 * s, va_list * va)
4632 u32 i = va_arg (*va, u32);
4637 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4641 return format (s, "ILLEGAL");
4643 s = format (s, "%s", t);
4648 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4650 vat_main_t *vam = &vat_main;
4651 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4653 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4654 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4656 conform_dscp_str = format (0, "");
4658 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4659 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4661 exceed_dscp_str = format (0, "");
4663 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4664 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4666 violate_dscp_str = format (0, "");
4668 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4669 "rate type %U, round type %U, %s rate, %s color-aware, "
4670 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4671 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4672 "conform action %U%s, exceed action %U%s, violate action %U%s",
4674 format_policer_type, mp->type,
4677 clib_net_to_host_u64 (mp->cb),
4678 clib_net_to_host_u64 (mp->eb),
4679 format_policer_rate_type, mp->rate_type,
4680 format_policer_round_type, mp->round_type,
4681 mp->single_rate ? "single" : "dual",
4682 mp->color_aware ? "is" : "not",
4683 ntohl (mp->cir_tokens_per_period),
4684 ntohl (mp->pir_tokens_per_period),
4686 ntohl (mp->current_limit),
4687 ntohl (mp->current_bucket),
4688 ntohl (mp->extended_limit),
4689 ntohl (mp->extended_bucket),
4690 clib_net_to_host_u64 (mp->last_update_time),
4691 format_policer_action_type, mp->conform_action_type,
4693 format_policer_action_type, mp->exceed_action_type,
4695 format_policer_action_type, mp->violate_action_type,
4698 vec_free (conform_dscp_str);
4699 vec_free (exceed_dscp_str);
4700 vec_free (violate_dscp_str);
4703 static void vl_api_policer_details_t_handler_json
4704 (vl_api_policer_details_t * mp)
4706 vat_main_t *vam = &vat_main;
4707 vat_json_node_t *node;
4708 u8 *rate_type_str, *round_type_str, *type_str;
4709 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4711 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4713 format (0, "%U", format_policer_round_type, mp->round_type);
4714 type_str = format (0, "%U", format_policer_type, mp->type);
4715 conform_action_str = format (0, "%U", format_policer_action_type,
4716 mp->conform_action_type);
4717 exceed_action_str = format (0, "%U", format_policer_action_type,
4718 mp->exceed_action_type);
4719 violate_action_str = format (0, "%U", format_policer_action_type,
4720 mp->violate_action_type);
4722 if (VAT_JSON_ARRAY != vam->json_tree.type)
4724 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4725 vat_json_init_array (&vam->json_tree);
4727 node = vat_json_array_add (&vam->json_tree);
4729 vat_json_init_object (node);
4730 vat_json_object_add_string_copy (node, "name", mp->name);
4731 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4732 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4733 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4734 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4735 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4736 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4737 vat_json_object_add_string_copy (node, "type", type_str);
4738 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4739 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4740 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4741 vat_json_object_add_uint (node, "cir_tokens_per_period",
4742 ntohl (mp->cir_tokens_per_period));
4743 vat_json_object_add_uint (node, "eir_tokens_per_period",
4744 ntohl (mp->pir_tokens_per_period));
4745 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4746 vat_json_object_add_uint (node, "current_bucket",
4747 ntohl (mp->current_bucket));
4748 vat_json_object_add_uint (node, "extended_limit",
4749 ntohl (mp->extended_limit));
4750 vat_json_object_add_uint (node, "extended_bucket",
4751 ntohl (mp->extended_bucket));
4752 vat_json_object_add_uint (node, "last_update_time",
4753 ntohl (mp->last_update_time));
4754 vat_json_object_add_string_copy (node, "conform_action",
4755 conform_action_str);
4756 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4758 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4759 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4760 vec_free (dscp_str);
4762 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4763 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4765 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4766 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4767 vec_free (dscp_str);
4769 vat_json_object_add_string_copy (node, "violate_action",
4770 violate_action_str);
4771 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4773 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4774 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4775 vec_free (dscp_str);
4778 vec_free (rate_type_str);
4779 vec_free (round_type_str);
4780 vec_free (type_str);
4781 vec_free (conform_action_str);
4782 vec_free (exceed_action_str);
4783 vec_free (violate_action_str);
4787 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4790 vat_main_t *vam = &vat_main;
4791 int i, count = ntohl (mp->count);
4794 print (vam->ofp, "classify table ids (%d) : ", count);
4795 for (i = 0; i < count; i++)
4797 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4798 print (vam->ofp, (i < count - 1) ? "," : "");
4800 vam->retval = ntohl (mp->retval);
4801 vam->result_ready = 1;
4805 vl_api_classify_table_ids_reply_t_handler_json
4806 (vl_api_classify_table_ids_reply_t * mp)
4808 vat_main_t *vam = &vat_main;
4809 int i, count = ntohl (mp->count);
4813 vat_json_node_t node;
4815 vat_json_init_object (&node);
4816 for (i = 0; i < count; i++)
4818 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4820 vat_json_print (vam->ofp, &node);
4821 vat_json_free (&node);
4823 vam->retval = ntohl (mp->retval);
4824 vam->result_ready = 1;
4828 vl_api_classify_table_by_interface_reply_t_handler
4829 (vl_api_classify_table_by_interface_reply_t * mp)
4831 vat_main_t *vam = &vat_main;
4834 table_id = ntohl (mp->l2_table_id);
4836 print (vam->ofp, "l2 table id : %d", table_id);
4838 print (vam->ofp, "l2 table id : No input ACL tables configured");
4839 table_id = ntohl (mp->ip4_table_id);
4841 print (vam->ofp, "ip4 table id : %d", table_id);
4843 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4844 table_id = ntohl (mp->ip6_table_id);
4846 print (vam->ofp, "ip6 table id : %d", table_id);
4848 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4849 vam->retval = ntohl (mp->retval);
4850 vam->result_ready = 1;
4854 vl_api_classify_table_by_interface_reply_t_handler_json
4855 (vl_api_classify_table_by_interface_reply_t * mp)
4857 vat_main_t *vam = &vat_main;
4858 vat_json_node_t node;
4860 vat_json_init_object (&node);
4862 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4863 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4864 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4866 vat_json_print (vam->ofp, &node);
4867 vat_json_free (&node);
4869 vam->retval = ntohl (mp->retval);
4870 vam->result_ready = 1;
4873 static void vl_api_policer_add_del_reply_t_handler
4874 (vl_api_policer_add_del_reply_t * mp)
4876 vat_main_t *vam = &vat_main;
4877 i32 retval = ntohl (mp->retval);
4878 if (vam->async_mode)
4880 vam->async_errors += (retval < 0);
4884 vam->retval = retval;
4885 vam->result_ready = 1;
4886 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4888 * Note: this is just barely thread-safe, depends on
4889 * the main thread spinning waiting for an answer...
4891 errmsg ("policer index %d", ntohl (mp->policer_index));
4895 static void vl_api_policer_add_del_reply_t_handler_json
4896 (vl_api_policer_add_del_reply_t * mp)
4898 vat_main_t *vam = &vat_main;
4899 vat_json_node_t node;
4901 vat_json_init_object (&node);
4902 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4903 vat_json_object_add_uint (&node, "policer_index",
4904 ntohl (mp->policer_index));
4906 vat_json_print (vam->ofp, &node);
4907 vat_json_free (&node);
4909 vam->retval = ntohl (mp->retval);
4910 vam->result_ready = 1;
4913 /* Format hex dump. */
4915 format_hex_bytes (u8 * s, va_list * va)
4917 u8 *bytes = va_arg (*va, u8 *);
4918 int n_bytes = va_arg (*va, int);
4921 /* Print short or long form depending on byte count. */
4922 uword short_form = n_bytes <= 32;
4923 u32 indent = format_get_indent (s);
4928 for (i = 0; i < n_bytes; i++)
4930 if (!short_form && (i % 32) == 0)
4931 s = format (s, "%08x: ", i);
4932 s = format (s, "%02x", bytes[i]);
4933 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4934 s = format (s, "\n%U", format_white_space, indent);
4941 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4944 vat_main_t *vam = &vat_main;
4945 i32 retval = ntohl (mp->retval);
4948 print (vam->ofp, "classify table info :");
4949 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4950 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4951 ntohl (mp->miss_next_index));
4952 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4953 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4954 ntohl (mp->match_n_vectors));
4955 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4956 ntohl (mp->mask_length));
4958 vam->retval = retval;
4959 vam->result_ready = 1;
4963 vl_api_classify_table_info_reply_t_handler_json
4964 (vl_api_classify_table_info_reply_t * mp)
4966 vat_main_t *vam = &vat_main;
4967 vat_json_node_t node;
4969 i32 retval = ntohl (mp->retval);
4972 vat_json_init_object (&node);
4974 vat_json_object_add_int (&node, "sessions",
4975 ntohl (mp->active_sessions));
4976 vat_json_object_add_int (&node, "nexttbl",
4977 ntohl (mp->next_table_index));
4978 vat_json_object_add_int (&node, "nextnode",
4979 ntohl (mp->miss_next_index));
4980 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4981 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4982 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4983 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4984 ntohl (mp->mask_length), 0);
4985 vat_json_object_add_string_copy (&node, "mask", s);
4987 vat_json_print (vam->ofp, &node);
4988 vat_json_free (&node);
4990 vam->retval = ntohl (mp->retval);
4991 vam->result_ready = 1;
4995 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4998 vat_main_t *vam = &vat_main;
5000 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
5001 ntohl (mp->hit_next_index), ntohl (mp->advance),
5002 ntohl (mp->opaque_index));
5003 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
5004 ntohl (mp->match_length));
5008 vl_api_classify_session_details_t_handler_json
5009 (vl_api_classify_session_details_t * mp)
5011 vat_main_t *vam = &vat_main;
5012 vat_json_node_t *node = NULL;
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_int (node, "next_index", ntohl (mp->hit_next_index));
5023 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5024 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5026 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5028 vat_json_object_add_string_copy (node, "match", s);
5031 static void vl_api_pg_create_interface_reply_t_handler
5032 (vl_api_pg_create_interface_reply_t * mp)
5034 vat_main_t *vam = &vat_main;
5036 vam->retval = ntohl (mp->retval);
5037 vam->result_ready = 1;
5040 static void vl_api_pg_create_interface_reply_t_handler_json
5041 (vl_api_pg_create_interface_reply_t * mp)
5043 vat_main_t *vam = &vat_main;
5044 vat_json_node_t node;
5046 i32 retval = ntohl (mp->retval);
5049 vat_json_init_object (&node);
5051 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5053 vat_json_print (vam->ofp, &node);
5054 vat_json_free (&node);
5056 vam->retval = ntohl (mp->retval);
5057 vam->result_ready = 1;
5060 static void vl_api_policer_classify_details_t_handler
5061 (vl_api_policer_classify_details_t * mp)
5063 vat_main_t *vam = &vat_main;
5065 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5066 ntohl (mp->table_index));
5069 static void vl_api_policer_classify_details_t_handler_json
5070 (vl_api_policer_classify_details_t * mp)
5072 vat_main_t *vam = &vat_main;
5073 vat_json_node_t *node;
5075 if (VAT_JSON_ARRAY != vam->json_tree.type)
5077 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5078 vat_json_init_array (&vam->json_tree);
5080 node = vat_json_array_add (&vam->json_tree);
5082 vat_json_init_object (node);
5083 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5084 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5087 static void vl_api_flow_classify_details_t_handler
5088 (vl_api_flow_classify_details_t * mp)
5090 vat_main_t *vam = &vat_main;
5092 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5093 ntohl (mp->table_index));
5096 static void vl_api_flow_classify_details_t_handler_json
5097 (vl_api_flow_classify_details_t * mp)
5099 vat_main_t *vam = &vat_main;
5100 vat_json_node_t *node;
5102 if (VAT_JSON_ARRAY != vam->json_tree.type)
5104 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5105 vat_json_init_array (&vam->json_tree);
5107 node = vat_json_array_add (&vam->json_tree);
5109 vat_json_init_object (node);
5110 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5111 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5114 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5115 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5116 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5117 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5118 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5119 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5120 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5121 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5122 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5123 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5126 * Generate boilerplate reply handlers, which
5127 * dig the return value out of the xxx_reply_t API message,
5128 * stick it into vam->retval, and set vam->result_ready
5130 * Could also do this by pointing N message decode slots at
5131 * a single function, but that could break in subtle ways.
5134 #define foreach_standard_reply_retval_handler \
5135 _(sw_interface_set_flags_reply) \
5136 _(sw_interface_add_del_address_reply) \
5137 _(sw_interface_set_rx_mode_reply) \
5138 _(sw_interface_set_rx_placement_reply) \
5139 _(sw_interface_set_table_reply) \
5140 _(sw_interface_set_mpls_enable_reply) \
5141 _(sw_interface_set_vpath_reply) \
5142 _(sw_interface_set_vxlan_bypass_reply) \
5143 _(sw_interface_set_geneve_bypass_reply) \
5144 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5145 _(sw_interface_set_l2_bridge_reply) \
5146 _(bridge_domain_add_del_reply) \
5147 _(sw_interface_set_l2_xconnect_reply) \
5148 _(l2fib_add_del_reply) \
5149 _(l2fib_flush_int_reply) \
5150 _(l2fib_flush_bd_reply) \
5151 _(ip_route_add_del_reply) \
5152 _(ip_table_add_del_reply) \
5153 _(ip_mroute_add_del_reply) \
5154 _(mpls_route_add_del_reply) \
5155 _(mpls_table_add_del_reply) \
5156 _(mpls_ip_bind_unbind_reply) \
5157 _(bier_route_add_del_reply) \
5158 _(bier_table_add_del_reply) \
5159 _(proxy_arp_add_del_reply) \
5160 _(proxy_arp_intfc_enable_disable_reply) \
5161 _(sw_interface_set_unnumbered_reply) \
5162 _(ip_neighbor_add_del_reply) \
5163 _(reset_fib_reply) \
5164 _(dhcp_proxy_config_reply) \
5165 _(dhcp_proxy_set_vss_reply) \
5166 _(dhcp_client_config_reply) \
5167 _(set_ip_flow_hash_reply) \
5168 _(sw_interface_ip6_enable_disable_reply) \
5169 _(ip6nd_proxy_add_del_reply) \
5170 _(sw_interface_ip6nd_ra_prefix_reply) \
5171 _(sw_interface_ip6nd_ra_config_reply) \
5172 _(set_arp_neighbor_limit_reply) \
5173 _(l2_patch_add_del_reply) \
5174 _(sr_mpls_policy_add_reply) \
5175 _(sr_mpls_policy_mod_reply) \
5176 _(sr_mpls_policy_del_reply) \
5177 _(sr_policy_add_reply) \
5178 _(sr_policy_mod_reply) \
5179 _(sr_policy_del_reply) \
5180 _(sr_localsid_add_del_reply) \
5181 _(sr_steering_add_del_reply) \
5182 _(classify_add_del_session_reply) \
5183 _(classify_set_interface_ip_table_reply) \
5184 _(classify_set_interface_l2_tables_reply) \
5185 _(l2tpv3_set_tunnel_cookies_reply) \
5186 _(l2tpv3_interface_enable_disable_reply) \
5187 _(l2tpv3_set_lookup_key_reply) \
5188 _(l2_fib_clear_table_reply) \
5189 _(l2_interface_efp_filter_reply) \
5190 _(l2_interface_vlan_tag_rewrite_reply) \
5191 _(modify_vhost_user_if_reply) \
5192 _(delete_vhost_user_if_reply) \
5193 _(ip_probe_neighbor_reply) \
5194 _(ip_scan_neighbor_enable_disable_reply) \
5195 _(want_ip4_arp_events_reply) \
5196 _(want_ip6_nd_events_reply) \
5197 _(want_l2_macs_events_reply) \
5198 _(input_acl_set_interface_reply) \
5199 _(ipsec_spd_add_del_reply) \
5200 _(ipsec_interface_add_del_spd_reply) \
5201 _(ipsec_spd_entry_add_del_reply) \
5202 _(ipsec_sad_entry_add_del_reply) \
5203 _(ipsec_tunnel_if_add_del_reply) \
5204 _(ipsec_tunnel_if_set_sa_reply) \
5205 _(delete_loopback_reply) \
5206 _(bd_ip_mac_add_del_reply) \
5207 _(bd_ip_mac_flush_reply) \
5208 _(want_interface_events_reply) \
5209 _(cop_interface_enable_disable_reply) \
5210 _(cop_whitelist_enable_disable_reply) \
5211 _(sw_interface_clear_stats_reply) \
5212 _(ioam_enable_reply) \
5213 _(ioam_disable_reply) \
5214 _(one_add_del_locator_reply) \
5215 _(one_add_del_local_eid_reply) \
5216 _(one_add_del_remote_mapping_reply) \
5217 _(one_add_del_adjacency_reply) \
5218 _(one_add_del_map_resolver_reply) \
5219 _(one_add_del_map_server_reply) \
5220 _(one_enable_disable_reply) \
5221 _(one_rloc_probe_enable_disable_reply) \
5222 _(one_map_register_enable_disable_reply) \
5223 _(one_map_register_set_ttl_reply) \
5224 _(one_set_transport_protocol_reply) \
5225 _(one_map_register_fallback_threshold_reply) \
5226 _(one_pitr_set_locator_set_reply) \
5227 _(one_map_request_mode_reply) \
5228 _(one_add_del_map_request_itr_rlocs_reply) \
5229 _(one_eid_table_add_del_map_reply) \
5230 _(one_use_petr_reply) \
5231 _(one_stats_enable_disable_reply) \
5232 _(one_add_del_l2_arp_entry_reply) \
5233 _(one_add_del_ndp_entry_reply) \
5234 _(one_stats_flush_reply) \
5235 _(one_enable_disable_xtr_mode_reply) \
5236 _(one_enable_disable_pitr_mode_reply) \
5237 _(one_enable_disable_petr_mode_reply) \
5238 _(gpe_enable_disable_reply) \
5239 _(gpe_set_encap_mode_reply) \
5240 _(gpe_add_del_iface_reply) \
5241 _(gpe_add_del_native_fwd_rpath_reply) \
5242 _(af_packet_delete_reply) \
5243 _(policer_classify_set_interface_reply) \
5244 _(netmap_create_reply) \
5245 _(netmap_delete_reply) \
5246 _(set_ipfix_exporter_reply) \
5247 _(set_ipfix_classify_stream_reply) \
5248 _(ipfix_classify_table_add_del_reply) \
5249 _(flow_classify_set_interface_reply) \
5250 _(sw_interface_span_enable_disable_reply) \
5251 _(pg_capture_reply) \
5252 _(pg_enable_disable_reply) \
5253 _(ip_source_and_port_range_check_add_del_reply) \
5254 _(ip_source_and_port_range_check_interface_add_del_reply)\
5255 _(delete_subif_reply) \
5256 _(l2_interface_pbb_tag_rewrite_reply) \
5258 _(feature_enable_disable_reply) \
5259 _(sw_interface_tag_add_del_reply) \
5260 _(hw_interface_set_mtu_reply) \
5261 _(p2p_ethernet_add_reply) \
5262 _(p2p_ethernet_del_reply) \
5263 _(lldp_config_reply) \
5264 _(sw_interface_set_lldp_reply) \
5265 _(tcp_configure_src_addresses_reply) \
5266 _(dns_enable_disable_reply) \
5267 _(dns_name_server_add_del_reply) \
5268 _(session_rule_add_del_reply) \
5269 _(ip_container_proxy_add_del_reply) \
5270 _(output_acl_set_interface_reply) \
5271 _(qos_record_enable_disable_reply)
5274 static void vl_api_##n##_t_handler \
5275 (vl_api_##n##_t * mp) \
5277 vat_main_t * vam = &vat_main; \
5278 i32 retval = ntohl(mp->retval); \
5279 if (vam->async_mode) { \
5280 vam->async_errors += (retval < 0); \
5282 vam->retval = retval; \
5283 vam->result_ready = 1; \
5286 foreach_standard_reply_retval_handler;
5290 static void vl_api_##n##_t_handler_json \
5291 (vl_api_##n##_t * mp) \
5293 vat_main_t * vam = &vat_main; \
5294 vat_json_node_t node; \
5295 vat_json_init_object(&node); \
5296 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5297 vat_json_print(vam->ofp, &node); \
5298 vam->retval = ntohl(mp->retval); \
5299 vam->result_ready = 1; \
5301 foreach_standard_reply_retval_handler;
5305 * Table of message reply handlers, must include boilerplate handlers
5309 #define foreach_vpe_api_reply_msg \
5310 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5311 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5312 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5313 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5314 _(CONTROL_PING_REPLY, control_ping_reply) \
5315 _(CLI_REPLY, cli_reply) \
5316 _(CLI_INBAND_REPLY, cli_inband_reply) \
5317 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5318 sw_interface_add_del_address_reply) \
5319 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5320 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5321 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5322 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5323 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5324 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5325 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5326 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5327 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5328 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5329 sw_interface_set_l2_xconnect_reply) \
5330 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5331 sw_interface_set_l2_bridge_reply) \
5332 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5333 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5334 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5335 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5336 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5337 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5338 _(L2_FLAGS_REPLY, l2_flags_reply) \
5339 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5340 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5341 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5342 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5343 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5344 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5345 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5346 _(BOND_CREATE_REPLY, bond_create_reply) \
5347 _(BOND_DELETE_REPLY, bond_delete_reply) \
5348 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5349 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5350 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5351 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5352 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5353 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5354 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5355 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5356 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5357 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5358 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5359 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5360 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5361 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5362 proxy_arp_intfc_enable_disable_reply) \
5363 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5364 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5365 sw_interface_set_unnumbered_reply) \
5366 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5367 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5368 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5369 _(RESET_FIB_REPLY, reset_fib_reply) \
5370 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5371 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5372 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5373 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5374 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5375 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5376 sw_interface_ip6_enable_disable_reply) \
5377 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5378 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5379 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5380 sw_interface_ip6nd_ra_prefix_reply) \
5381 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5382 sw_interface_ip6nd_ra_config_reply) \
5383 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5384 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5385 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5386 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5387 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5388 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5389 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5390 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5391 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5392 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5393 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5394 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5395 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5396 classify_set_interface_ip_table_reply) \
5397 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5398 classify_set_interface_l2_tables_reply) \
5399 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5400 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5401 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5402 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5403 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5404 l2tpv3_interface_enable_disable_reply) \
5405 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5406 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5407 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5408 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5409 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5410 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5411 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5412 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5413 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5414 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5415 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5416 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5417 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5418 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5419 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5420 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5421 _(SHOW_VERSION_REPLY, show_version_reply) \
5422 _(SHOW_THREADS_REPLY, show_threads_reply) \
5423 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5424 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5425 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5426 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5427 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5428 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5429 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5430 _(IP4_ARP_EVENT, ip4_arp_event) \
5431 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5432 _(IP6_ND_EVENT, ip6_nd_event) \
5433 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5434 _(L2_MACS_EVENT, l2_macs_event) \
5435 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5436 _(IP_ADDRESS_DETAILS, ip_address_details) \
5437 _(IP_DETAILS, ip_details) \
5438 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5439 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5440 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5441 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5442 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5443 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5444 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5445 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5446 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5447 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5448 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5449 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5450 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5451 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5452 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5453 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5454 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5455 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5456 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5457 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5458 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5459 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5460 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5461 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5462 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5463 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5464 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5465 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5466 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5467 one_map_register_enable_disable_reply) \
5468 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5469 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5470 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5471 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5472 one_map_register_fallback_threshold_reply) \
5473 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5474 one_rloc_probe_enable_disable_reply) \
5475 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5476 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5477 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5478 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5479 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5480 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5481 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5482 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5483 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5484 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5485 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5486 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5487 _(ONE_STATS_DETAILS, one_stats_details) \
5488 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5489 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5490 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5491 show_one_stats_enable_disable_reply) \
5492 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5493 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5494 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5495 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5496 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5497 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5498 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5499 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5500 one_enable_disable_pitr_mode_reply) \
5501 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5502 one_enable_disable_petr_mode_reply) \
5503 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5504 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5505 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5506 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5507 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5508 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5509 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5510 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5511 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5512 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5513 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5514 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5515 gpe_add_del_native_fwd_rpath_reply) \
5516 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5517 gpe_fwd_entry_path_details) \
5518 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5519 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5520 one_add_del_map_request_itr_rlocs_reply) \
5521 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5522 one_get_map_request_itr_rlocs_reply) \
5523 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5524 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5525 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5526 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5527 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5528 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5529 show_one_map_register_state_reply) \
5530 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5531 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5532 show_one_map_register_fallback_threshold_reply) \
5533 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5534 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5535 _(AF_PACKET_DETAILS, af_packet_details) \
5536 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5537 _(POLICER_DETAILS, policer_details) \
5538 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5539 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5540 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5541 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5542 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5543 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5544 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5545 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5546 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5547 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5548 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5549 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5550 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5551 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5552 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5553 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5554 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5555 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5556 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5557 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5558 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5559 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5560 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5561 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5562 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5563 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5564 ip_source_and_port_range_check_add_del_reply) \
5565 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5566 ip_source_and_port_range_check_interface_add_del_reply) \
5567 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5568 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5569 _(SET_PUNT_REPLY, set_punt_reply) \
5570 _(IP_TABLE_DETAILS, ip_table_details) \
5571 _(IP_ROUTE_DETAILS, ip_route_details) \
5572 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5573 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5574 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5575 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5576 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5577 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5578 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5579 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5580 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5581 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5582 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5583 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5584 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5585 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5586 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5587 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5588 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5589 _(SESSION_RULES_DETAILS, session_rules_details) \
5590 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5591 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5592 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5594 #define foreach_standalone_reply_msg \
5595 _(SW_INTERFACE_EVENT, sw_interface_event)
5603 #define STR_VTR_OP_CASE(op) \
5604 case L2_VTR_ ## op: \
5608 str_vtr_op (u32 vtr_op)
5612 STR_VTR_OP_CASE (DISABLED);
5613 STR_VTR_OP_CASE (PUSH_1);
5614 STR_VTR_OP_CASE (PUSH_2);
5615 STR_VTR_OP_CASE (POP_1);
5616 STR_VTR_OP_CASE (POP_2);
5617 STR_VTR_OP_CASE (TRANSLATE_1_1);
5618 STR_VTR_OP_CASE (TRANSLATE_1_2);
5619 STR_VTR_OP_CASE (TRANSLATE_2_1);
5620 STR_VTR_OP_CASE (TRANSLATE_2_2);
5627 dump_sub_interface_table (vat_main_t * vam)
5629 const sw_interface_subif_t *sub = NULL;
5631 if (vam->json_output)
5634 ("JSON output supported only for VPE API calls and dump_stats_table");
5639 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5640 "Interface", "sw_if_index",
5641 "sub id", "dot1ad", "tags", "outer id",
5642 "inner id", "exact", "default", "outer any", "inner any");
5644 vec_foreach (sub, vam->sw_if_subif_table)
5647 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5648 sub->interface_name,
5650 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5651 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5652 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5653 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5654 if (sub->vtr_op != L2_VTR_DISABLED)
5657 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5658 "tag1: %d tag2: %d ]",
5659 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5660 sub->vtr_tag1, sub->vtr_tag2);
5668 name_sort_cmp (void *a1, void *a2)
5670 name_sort_t *n1 = a1;
5671 name_sort_t *n2 = a2;
5673 return strcmp ((char *) n1->name, (char *) n2->name);
5677 dump_interface_table (vat_main_t * vam)
5680 name_sort_t *nses = 0, *ns;
5682 if (vam->json_output)
5685 ("JSON output supported only for VPE API calls and dump_stats_table");
5690 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5692 vec_add2 (nses, ns, 1);
5693 ns->name = (u8 *)(p->key);
5694 ns->value = (u32) p->value[0];
5698 vec_sort_with_function (nses, name_sort_cmp);
5700 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5701 vec_foreach (ns, nses)
5703 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5710 dump_ip_table (vat_main_t * vam, int is_ipv6)
5712 const ip_details_t *det = NULL;
5713 const ip_address_details_t *address = NULL;
5716 print (vam->ofp, "%-12s", "sw_if_index");
5718 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5725 print (vam->ofp, "%-12d", i);
5726 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5731 vec_foreach (address, det->addr)
5735 is_ipv6 ? format_ip6_address : format_ip4_address,
5736 address->ip, address->prefix_length);
5744 dump_ipv4_table (vat_main_t * vam)
5746 if (vam->json_output)
5749 ("JSON output supported only for VPE API calls and dump_stats_table");
5753 return dump_ip_table (vam, 0);
5757 dump_ipv6_table (vat_main_t * vam)
5759 if (vam->json_output)
5762 ("JSON output supported only for VPE API calls and dump_stats_table");
5766 return dump_ip_table (vam, 1);
5770 * Pass CLI buffers directly in the CLI_INBAND API message,
5771 * instead of an additional shared memory area.
5774 exec_inband (vat_main_t * vam)
5776 vl_api_cli_inband_t *mp;
5777 unformat_input_t *i = vam->input;
5780 if (vec_len (i->buffer) == 0)
5783 if (vam->exec_mode == 0 && unformat (i, "mode"))
5788 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5795 * In order for the CLI command to work, it
5796 * must be a vector ending in \n, not a C-string ending
5799 u32 len = vec_len (vam->input->buffer);
5800 M2 (CLI_INBAND, mp, len);
5801 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5805 /* json responses may or may not include a useful reply... */
5806 if (vec_len (vam->cmd_reply))
5807 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5812 exec (vat_main_t * vam)
5814 return exec_inband (vam);
5818 api_create_loopback (vat_main_t * vam)
5820 unformat_input_t *i = vam->input;
5821 vl_api_create_loopback_t *mp;
5822 vl_api_create_loopback_instance_t *mp_lbi;
5825 u8 is_specified = 0;
5826 u32 user_instance = 0;
5829 clib_memset (mac_address, 0, sizeof (mac_address));
5831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5833 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5835 if (unformat (i, "instance %d", &user_instance))
5843 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5844 mp_lbi->is_specified = is_specified;
5846 mp_lbi->user_instance = htonl (user_instance);
5848 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5853 /* Construct the API message */
5854 M (CREATE_LOOPBACK, mp);
5856 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5865 api_delete_loopback (vat_main_t * vam)
5867 unformat_input_t *i = vam->input;
5868 vl_api_delete_loopback_t *mp;
5869 u32 sw_if_index = ~0;
5872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5874 if (unformat (i, "sw_if_index %d", &sw_if_index))
5880 if (sw_if_index == ~0)
5882 errmsg ("missing sw_if_index");
5886 /* Construct the API message */
5887 M (DELETE_LOOPBACK, mp);
5888 mp->sw_if_index = ntohl (sw_if_index);
5896 api_want_interface_events (vat_main_t * vam)
5898 unformat_input_t *i = vam->input;
5899 vl_api_want_interface_events_t *mp;
5903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5905 if (unformat (i, "enable"))
5907 else if (unformat (i, "disable"))
5915 errmsg ("missing enable|disable");
5919 M (WANT_INTERFACE_EVENTS, mp);
5920 mp->enable_disable = enable;
5922 vam->interface_event_display = enable;
5930 /* Note: non-static, called once to set up the initial intfc table */
5932 api_sw_interface_dump (vat_main_t * vam)
5934 vl_api_sw_interface_dump_t *mp;
5935 vl_api_control_ping_t *mp_ping;
5937 name_sort_t *nses = 0, *ns;
5938 sw_interface_subif_t *sub = NULL;
5941 /* Toss the old name table */
5943 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5945 vec_add2 (nses, ns, 1);
5946 ns->name = (u8 *)(p->key);
5947 ns->value = (u32) p->value[0];
5951 hash_free (vam->sw_if_index_by_interface_name);
5953 vec_foreach (ns, nses) vec_free (ns->name);
5957 vec_foreach (sub, vam->sw_if_subif_table)
5959 vec_free (sub->interface_name);
5961 vec_free (vam->sw_if_subif_table);
5963 /* recreate the interface name hash table */
5964 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5967 * Ask for all interface names. Otherwise, the epic catalog of
5968 * name filters becomes ridiculously long, and vat ends up needing
5969 * to be taught about new interface types.
5971 M (SW_INTERFACE_DUMP, mp);
5974 /* Use a control ping for synchronization */
5975 MPING (CONTROL_PING, mp_ping);
5983 api_sw_interface_set_flags (vat_main_t * vam)
5985 unformat_input_t *i = vam->input;
5986 vl_api_sw_interface_set_flags_t *mp;
5988 u8 sw_if_index_set = 0;
5992 /* Parse args required to build the message */
5993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5995 if (unformat (i, "admin-up"))
5997 else if (unformat (i, "admin-down"))
6000 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6001 sw_if_index_set = 1;
6002 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6003 sw_if_index_set = 1;
6008 if (sw_if_index_set == 0)
6010 errmsg ("missing interface name or sw_if_index");
6014 /* Construct the API message */
6015 M (SW_INTERFACE_SET_FLAGS, mp);
6016 mp->sw_if_index = ntohl (sw_if_index);
6017 mp->admin_up_down = admin_up;
6022 /* Wait for a reply, return the good/bad news... */
6028 api_sw_interface_set_rx_mode (vat_main_t * vam)
6030 unformat_input_t *i = vam->input;
6031 vl_api_sw_interface_set_rx_mode_t *mp;
6033 u8 sw_if_index_set = 0;
6035 u8 queue_id_valid = 0;
6037 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6039 /* Parse args required to build the message */
6040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6042 if (unformat (i, "queue %d", &queue_id))
6044 else if (unformat (i, "polling"))
6045 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6046 else if (unformat (i, "interrupt"))
6047 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6048 else if (unformat (i, "adaptive"))
6049 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6051 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6052 sw_if_index_set = 1;
6053 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6054 sw_if_index_set = 1;
6059 if (sw_if_index_set == 0)
6061 errmsg ("missing interface name or sw_if_index");
6064 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6066 errmsg ("missing rx-mode");
6070 /* Construct the API message */
6071 M (SW_INTERFACE_SET_RX_MODE, mp);
6072 mp->sw_if_index = ntohl (sw_if_index);
6074 mp->queue_id_valid = queue_id_valid;
6075 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6080 /* Wait for a reply, return the good/bad news... */
6086 api_sw_interface_set_rx_placement (vat_main_t * vam)
6088 unformat_input_t *i = vam->input;
6089 vl_api_sw_interface_set_rx_placement_t *mp;
6091 u8 sw_if_index_set = 0;
6094 u32 queue_id, thread_index;
6096 /* Parse args required to build the message */
6097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6099 if (unformat (i, "queue %d", &queue_id))
6101 else if (unformat (i, "main"))
6103 else if (unformat (i, "worker %d", &thread_index))
6106 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6107 sw_if_index_set = 1;
6108 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6109 sw_if_index_set = 1;
6114 if (sw_if_index_set == 0)
6116 errmsg ("missing interface name or sw_if_index");
6122 /* Construct the API message */
6123 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6124 mp->sw_if_index = ntohl (sw_if_index);
6125 mp->worker_id = ntohl (thread_index);
6126 mp->queue_id = ntohl (queue_id);
6127 mp->is_main = is_main;
6131 /* Wait for a reply, return the good/bad news... */
6136 static void vl_api_sw_interface_rx_placement_details_t_handler
6137 (vl_api_sw_interface_rx_placement_details_t * mp)
6139 vat_main_t *vam = &vat_main;
6140 u32 worker_id = ntohl (mp->worker_id);
6143 "\n%-11d %-11s %-6d %-5d %-9s",
6144 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6145 worker_id, ntohl (mp->queue_id),
6147 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6150 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6151 (vl_api_sw_interface_rx_placement_details_t * mp)
6153 vat_main_t *vam = &vat_main;
6154 vat_json_node_t *node = NULL;
6156 if (VAT_JSON_ARRAY != vam->json_tree.type)
6158 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6159 vat_json_init_array (&vam->json_tree);
6161 node = vat_json_array_add (&vam->json_tree);
6163 vat_json_init_object (node);
6164 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6165 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6166 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6167 vat_json_object_add_uint (node, "mode", mp->mode);
6171 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6173 unformat_input_t *i = vam->input;
6174 vl_api_sw_interface_rx_placement_dump_t *mp;
6175 vl_api_control_ping_t *mp_ping;
6178 u8 sw_if_index_set = 0;
6180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6182 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6184 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6191 "\n%-11s %-11s %-6s %-5s %-4s",
6192 "sw_if_index", "main/worker", "thread", "queue", "mode");
6194 /* Dump Interface rx placement */
6195 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6197 if (sw_if_index_set)
6198 mp->sw_if_index = htonl (sw_if_index);
6200 mp->sw_if_index = ~0;
6204 /* Use a control ping for synchronization */
6205 MPING (CONTROL_PING, mp_ping);
6213 api_sw_interface_clear_stats (vat_main_t * vam)
6215 unformat_input_t *i = vam->input;
6216 vl_api_sw_interface_clear_stats_t *mp;
6218 u8 sw_if_index_set = 0;
6221 /* Parse args required to build the message */
6222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6224 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6225 sw_if_index_set = 1;
6226 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6227 sw_if_index_set = 1;
6232 /* Construct the API message */
6233 M (SW_INTERFACE_CLEAR_STATS, mp);
6235 if (sw_if_index_set == 1)
6236 mp->sw_if_index = ntohl (sw_if_index);
6238 mp->sw_if_index = ~0;
6243 /* Wait for a reply, return the good/bad news... */
6249 api_sw_interface_add_del_address (vat_main_t * vam)
6251 unformat_input_t *i = vam->input;
6252 vl_api_sw_interface_add_del_address_t *mp;
6254 u8 sw_if_index_set = 0;
6255 u8 is_add = 1, del_all = 0;
6256 u32 address_length = 0;
6257 u8 v4_address_set = 0;
6258 u8 v6_address_set = 0;
6259 ip4_address_t v4address;
6260 ip6_address_t v6address;
6263 /* Parse args required to build the message */
6264 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6266 if (unformat (i, "del-all"))
6268 else if (unformat (i, "del"))
6271 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6272 sw_if_index_set = 1;
6273 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6274 sw_if_index_set = 1;
6275 else if (unformat (i, "%U/%d",
6276 unformat_ip4_address, &v4address, &address_length))
6278 else if (unformat (i, "%U/%d",
6279 unformat_ip6_address, &v6address, &address_length))
6285 if (sw_if_index_set == 0)
6287 errmsg ("missing interface name or sw_if_index");
6290 if (v4_address_set && v6_address_set)
6292 errmsg ("both v4 and v6 addresses set");
6295 if (!v4_address_set && !v6_address_set && !del_all)
6297 errmsg ("no addresses set");
6301 /* Construct the API message */
6302 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6304 mp->sw_if_index = ntohl (sw_if_index);
6305 mp->is_add = is_add;
6306 mp->del_all = del_all;
6310 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6314 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6316 mp->address_length = address_length;
6321 /* Wait for a reply, return good/bad news */
6327 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6329 unformat_input_t *i = vam->input;
6330 vl_api_sw_interface_set_mpls_enable_t *mp;
6332 u8 sw_if_index_set = 0;
6336 /* Parse args required to build the message */
6337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6340 sw_if_index_set = 1;
6341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6342 sw_if_index_set = 1;
6343 else if (unformat (i, "disable"))
6345 else if (unformat (i, "dis"))
6351 if (sw_if_index_set == 0)
6353 errmsg ("missing interface name or sw_if_index");
6357 /* Construct the API message */
6358 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6360 mp->sw_if_index = ntohl (sw_if_index);
6361 mp->enable = enable;
6366 /* Wait for a reply... */
6372 api_sw_interface_set_table (vat_main_t * vam)
6374 unformat_input_t *i = vam->input;
6375 vl_api_sw_interface_set_table_t *mp;
6376 u32 sw_if_index, vrf_id = 0;
6377 u8 sw_if_index_set = 0;
6381 /* Parse args required to build the message */
6382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6384 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6385 sw_if_index_set = 1;
6386 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6387 sw_if_index_set = 1;
6388 else if (unformat (i, "vrf %d", &vrf_id))
6390 else if (unformat (i, "ipv6"))
6396 if (sw_if_index_set == 0)
6398 errmsg ("missing interface name or sw_if_index");
6402 /* Construct the API message */
6403 M (SW_INTERFACE_SET_TABLE, mp);
6405 mp->sw_if_index = ntohl (sw_if_index);
6406 mp->is_ipv6 = is_ipv6;
6407 mp->vrf_id = ntohl (vrf_id);
6412 /* Wait for a reply... */
6417 static void vl_api_sw_interface_get_table_reply_t_handler
6418 (vl_api_sw_interface_get_table_reply_t * mp)
6420 vat_main_t *vam = &vat_main;
6422 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6424 vam->retval = ntohl (mp->retval);
6425 vam->result_ready = 1;
6429 static void vl_api_sw_interface_get_table_reply_t_handler_json
6430 (vl_api_sw_interface_get_table_reply_t * mp)
6432 vat_main_t *vam = &vat_main;
6433 vat_json_node_t node;
6435 vat_json_init_object (&node);
6436 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6437 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6439 vat_json_print (vam->ofp, &node);
6440 vat_json_free (&node);
6442 vam->retval = ntohl (mp->retval);
6443 vam->result_ready = 1;
6447 api_sw_interface_get_table (vat_main_t * vam)
6449 unformat_input_t *i = vam->input;
6450 vl_api_sw_interface_get_table_t *mp;
6452 u8 sw_if_index_set = 0;
6456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6458 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6459 sw_if_index_set = 1;
6460 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6461 sw_if_index_set = 1;
6462 else if (unformat (i, "ipv6"))
6468 if (sw_if_index_set == 0)
6470 errmsg ("missing interface name or sw_if_index");
6474 M (SW_INTERFACE_GET_TABLE, mp);
6475 mp->sw_if_index = htonl (sw_if_index);
6476 mp->is_ipv6 = is_ipv6;
6484 api_sw_interface_set_vpath (vat_main_t * vam)
6486 unformat_input_t *i = vam->input;
6487 vl_api_sw_interface_set_vpath_t *mp;
6488 u32 sw_if_index = 0;
6489 u8 sw_if_index_set = 0;
6493 /* Parse args required to build the message */
6494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6496 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6497 sw_if_index_set = 1;
6498 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6499 sw_if_index_set = 1;
6500 else if (unformat (i, "enable"))
6502 else if (unformat (i, "disable"))
6508 if (sw_if_index_set == 0)
6510 errmsg ("missing interface name or sw_if_index");
6514 /* Construct the API message */
6515 M (SW_INTERFACE_SET_VPATH, mp);
6517 mp->sw_if_index = ntohl (sw_if_index);
6518 mp->enable = is_enable;
6523 /* Wait for a reply... */
6529 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6531 unformat_input_t *i = vam->input;
6532 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6533 u32 sw_if_index = 0;
6534 u8 sw_if_index_set = 0;
6539 /* Parse args required to build the message */
6540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6542 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6543 sw_if_index_set = 1;
6544 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6545 sw_if_index_set = 1;
6546 else if (unformat (i, "enable"))
6548 else if (unformat (i, "disable"))
6550 else if (unformat (i, "ip4"))
6552 else if (unformat (i, "ip6"))
6558 if (sw_if_index_set == 0)
6560 errmsg ("missing interface name or sw_if_index");
6564 /* Construct the API message */
6565 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6567 mp->sw_if_index = ntohl (sw_if_index);
6568 mp->enable = is_enable;
6569 mp->is_ipv6 = is_ipv6;
6574 /* Wait for a reply... */
6580 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6582 unformat_input_t *i = vam->input;
6583 vl_api_sw_interface_set_geneve_bypass_t *mp;
6584 u32 sw_if_index = 0;
6585 u8 sw_if_index_set = 0;
6590 /* Parse args required to build the message */
6591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6593 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6594 sw_if_index_set = 1;
6595 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6596 sw_if_index_set = 1;
6597 else if (unformat (i, "enable"))
6599 else if (unformat (i, "disable"))
6601 else if (unformat (i, "ip4"))
6603 else if (unformat (i, "ip6"))
6609 if (sw_if_index_set == 0)
6611 errmsg ("missing interface name or sw_if_index");
6615 /* Construct the API message */
6616 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6618 mp->sw_if_index = ntohl (sw_if_index);
6619 mp->enable = is_enable;
6620 mp->is_ipv6 = is_ipv6;
6625 /* Wait for a reply... */
6631 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6633 unformat_input_t *i = vam->input;
6634 vl_api_sw_interface_set_l2_xconnect_t *mp;
6636 u8 rx_sw_if_index_set = 0;
6638 u8 tx_sw_if_index_set = 0;
6642 /* Parse args required to build the message */
6643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6645 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6646 rx_sw_if_index_set = 1;
6647 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6648 tx_sw_if_index_set = 1;
6649 else if (unformat (i, "rx"))
6651 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6653 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6655 rx_sw_if_index_set = 1;
6660 else if (unformat (i, "tx"))
6662 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6664 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6666 tx_sw_if_index_set = 1;
6671 else if (unformat (i, "enable"))
6673 else if (unformat (i, "disable"))
6679 if (rx_sw_if_index_set == 0)
6681 errmsg ("missing rx interface name or rx_sw_if_index");
6685 if (enable && (tx_sw_if_index_set == 0))
6687 errmsg ("missing tx interface name or tx_sw_if_index");
6691 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6693 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6694 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6695 mp->enable = enable;
6703 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6705 unformat_input_t *i = vam->input;
6706 vl_api_sw_interface_set_l2_bridge_t *mp;
6707 vl_api_l2_port_type_t port_type;
6709 u8 rx_sw_if_index_set = 0;
6716 port_type = L2_API_PORT_TYPE_NORMAL;
6718 /* Parse args required to build the message */
6719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6721 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6722 rx_sw_if_index_set = 1;
6723 else if (unformat (i, "bd_id %d", &bd_id))
6727 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6728 rx_sw_if_index_set = 1;
6729 else if (unformat (i, "shg %d", &shg))
6731 else if (unformat (i, "bvi"))
6732 port_type = L2_API_PORT_TYPE_BVI;
6733 else if (unformat (i, "uu-fwd"))
6734 port_type = L2_API_PORT_TYPE_UU_FWD;
6735 else if (unformat (i, "enable"))
6737 else if (unformat (i, "disable"))
6743 if (rx_sw_if_index_set == 0)
6745 errmsg ("missing rx interface name or sw_if_index");
6749 if (enable && (bd_id_set == 0))
6751 errmsg ("missing bridge domain");
6755 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6757 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6758 mp->bd_id = ntohl (bd_id);
6760 mp->port_type = ntohl (port_type);
6761 mp->enable = enable;
6769 api_bridge_domain_dump (vat_main_t * vam)
6771 unformat_input_t *i = vam->input;
6772 vl_api_bridge_domain_dump_t *mp;
6773 vl_api_control_ping_t *mp_ping;
6777 /* Parse args required to build the message */
6778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6780 if (unformat (i, "bd_id %d", &bd_id))
6786 M (BRIDGE_DOMAIN_DUMP, mp);
6787 mp->bd_id = ntohl (bd_id);
6790 /* Use a control ping for synchronization */
6791 MPING (CONTROL_PING, mp_ping);
6799 api_bridge_domain_add_del (vat_main_t * vam)
6801 unformat_input_t *i = vam->input;
6802 vl_api_bridge_domain_add_del_t *mp;
6805 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6810 /* Parse args required to build the message */
6811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6813 if (unformat (i, "bd_id %d", &bd_id))
6815 else if (unformat (i, "flood %d", &flood))
6817 else if (unformat (i, "uu-flood %d", &uu_flood))
6819 else if (unformat (i, "forward %d", &forward))
6821 else if (unformat (i, "learn %d", &learn))
6823 else if (unformat (i, "arp-term %d", &arp_term))
6825 else if (unformat (i, "mac-age %d", &mac_age))
6827 else if (unformat (i, "bd-tag %s", &bd_tag))
6829 else if (unformat (i, "del"))
6832 flood = uu_flood = forward = learn = 0;
6840 errmsg ("missing bridge domain");
6847 errmsg ("mac age must be less than 256 ");
6852 if ((bd_tag) && (vec_len (bd_tag) > 63))
6854 errmsg ("bd-tag cannot be longer than 63");
6859 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6861 mp->bd_id = ntohl (bd_id);
6863 mp->uu_flood = uu_flood;
6864 mp->forward = forward;
6866 mp->arp_term = arp_term;
6867 mp->is_add = is_add;
6868 mp->mac_age = (u8) mac_age;
6871 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6872 mp->bd_tag[vec_len (bd_tag)] = 0;
6883 api_l2fib_flush_bd (vat_main_t * vam)
6885 unformat_input_t *i = vam->input;
6886 vl_api_l2fib_flush_bd_t *mp;
6890 /* Parse args required to build the message */
6891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6893 if (unformat (i, "bd_id %d", &bd_id));
6900 errmsg ("missing bridge domain");
6904 M (L2FIB_FLUSH_BD, mp);
6906 mp->bd_id = htonl (bd_id);
6914 api_l2fib_flush_int (vat_main_t * vam)
6916 unformat_input_t *i = vam->input;
6917 vl_api_l2fib_flush_int_t *mp;
6918 u32 sw_if_index = ~0;
6921 /* Parse args required to build the message */
6922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6924 if (unformat (i, "sw_if_index %d", &sw_if_index));
6926 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6931 if (sw_if_index == ~0)
6933 errmsg ("missing interface name or sw_if_index");
6937 M (L2FIB_FLUSH_INT, mp);
6939 mp->sw_if_index = ntohl (sw_if_index);
6947 api_l2fib_add_del (vat_main_t * vam)
6949 unformat_input_t *i = vam->input;
6950 vl_api_l2fib_add_del_t *mp;
6956 u32 sw_if_index = 0;
6957 u8 sw_if_index_set = 0;
6966 /* Parse args required to build the message */
6967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6969 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6971 else if (unformat (i, "bd_id %d", &bd_id))
6973 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6974 sw_if_index_set = 1;
6975 else if (unformat (i, "sw_if"))
6977 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6980 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6981 sw_if_index_set = 1;
6986 else if (unformat (i, "static"))
6988 else if (unformat (i, "filter"))
6993 else if (unformat (i, "bvi"))
6998 else if (unformat (i, "del"))
7000 else if (unformat (i, "count %d", &count))
7008 errmsg ("missing mac address");
7014 errmsg ("missing bridge domain");
7018 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7020 errmsg ("missing interface name or sw_if_index");
7026 /* Turn on async mode */
7027 vam->async_mode = 1;
7028 vam->async_errors = 0;
7029 before = vat_time_now (vam);
7032 for (j = 0; j < count; j++)
7034 M (L2FIB_ADD_DEL, mp);
7036 clib_memcpy (mp->mac, mac, 6);
7037 mp->bd_id = ntohl (bd_id);
7038 mp->is_add = is_add;
7039 mp->sw_if_index = ntohl (sw_if_index);
7043 mp->static_mac = static_mac;
7044 mp->filter_mac = filter_mac;
7045 mp->bvi_mac = bvi_mac;
7047 increment_mac_address (mac);
7054 vl_api_control_ping_t *mp_ping;
7057 /* Shut off async mode */
7058 vam->async_mode = 0;
7060 MPING (CONTROL_PING, mp_ping);
7063 timeout = vat_time_now (vam) + 1.0;
7064 while (vat_time_now (vam) < timeout)
7065 if (vam->result_ready == 1)
7070 if (vam->retval == -99)
7073 if (vam->async_errors > 0)
7075 errmsg ("%d asynchronous errors", vam->async_errors);
7078 vam->async_errors = 0;
7079 after = vat_time_now (vam);
7081 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7082 count, after - before, count / (after - before));
7088 /* Wait for a reply... */
7092 /* Return the good/bad news */
7093 return (vam->retval);
7097 api_bridge_domain_set_mac_age (vat_main_t * vam)
7099 unformat_input_t *i = vam->input;
7100 vl_api_bridge_domain_set_mac_age_t *mp;
7105 /* Parse args required to build the message */
7106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7108 if (unformat (i, "bd_id %d", &bd_id));
7109 else if (unformat (i, "mac-age %d", &mac_age));
7116 errmsg ("missing bridge domain");
7122 errmsg ("mac age must be less than 256 ");
7126 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7128 mp->bd_id = htonl (bd_id);
7129 mp->mac_age = (u8) mac_age;
7137 api_l2_flags (vat_main_t * vam)
7139 unformat_input_t *i = vam->input;
7140 vl_api_l2_flags_t *mp;
7143 u8 sw_if_index_set = 0;
7147 /* Parse args required to build the message */
7148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7150 if (unformat (i, "sw_if_index %d", &sw_if_index))
7151 sw_if_index_set = 1;
7152 else if (unformat (i, "sw_if"))
7154 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7157 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7158 sw_if_index_set = 1;
7163 else if (unformat (i, "learn"))
7165 else if (unformat (i, "forward"))
7167 else if (unformat (i, "flood"))
7169 else if (unformat (i, "uu-flood"))
7170 flags |= L2_UU_FLOOD;
7171 else if (unformat (i, "arp-term"))
7172 flags |= L2_ARP_TERM;
7173 else if (unformat (i, "off"))
7175 else if (unformat (i, "disable"))
7181 if (sw_if_index_set == 0)
7183 errmsg ("missing interface name or sw_if_index");
7189 mp->sw_if_index = ntohl (sw_if_index);
7190 mp->feature_bitmap = ntohl (flags);
7191 mp->is_set = is_set;
7199 api_bridge_flags (vat_main_t * vam)
7201 unformat_input_t *i = vam->input;
7202 vl_api_bridge_flags_t *mp;
7206 bd_flags_t flags = 0;
7209 /* Parse args required to build the message */
7210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7212 if (unformat (i, "bd_id %d", &bd_id))
7214 else if (unformat (i, "learn"))
7215 flags |= BRIDGE_API_FLAG_LEARN;
7216 else if (unformat (i, "forward"))
7217 flags |= BRIDGE_API_FLAG_FWD;
7218 else if (unformat (i, "flood"))
7219 flags |= BRIDGE_API_FLAG_FLOOD;
7220 else if (unformat (i, "uu-flood"))
7221 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7222 else if (unformat (i, "arp-term"))
7223 flags |= BRIDGE_API_FLAG_ARP_TERM;
7224 else if (unformat (i, "off"))
7226 else if (unformat (i, "disable"))
7234 errmsg ("missing bridge domain");
7238 M (BRIDGE_FLAGS, mp);
7240 mp->bd_id = ntohl (bd_id);
7241 mp->flags = ntohl (flags);
7242 mp->is_set = is_set;
7250 api_bd_ip_mac_add_del (vat_main_t * vam)
7252 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7253 vl_api_mac_address_t mac = { 0 };
7254 unformat_input_t *i = vam->input;
7255 vl_api_bd_ip_mac_add_del_t *mp;
7264 /* Parse args required to build the message */
7265 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7267 if (unformat (i, "bd_id %d", &bd_id))
7271 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7275 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7279 else if (unformat (i, "del"))
7287 errmsg ("missing bridge domain");
7290 else if (ip_set == 0)
7292 errmsg ("missing IP address");
7295 else if (mac_set == 0)
7297 errmsg ("missing MAC address");
7301 M (BD_IP_MAC_ADD_DEL, mp);
7303 mp->entry.bd_id = ntohl (bd_id);
7304 mp->is_add = is_add;
7306 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7307 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7315 api_bd_ip_mac_flush (vat_main_t * vam)
7317 unformat_input_t *i = vam->input;
7318 vl_api_bd_ip_mac_flush_t *mp;
7323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7325 if (unformat (i, "bd_id %d", &bd_id))
7335 errmsg ("missing bridge domain");
7339 M (BD_IP_MAC_FLUSH, mp);
7341 mp->bd_id = ntohl (bd_id);
7348 static void vl_api_bd_ip_mac_details_t_handler
7349 (vl_api_bd_ip_mac_details_t * mp)
7351 vat_main_t *vam = &vat_main;
7355 ntohl (mp->entry.bd_id),
7356 format_vl_api_mac_address, mp->entry.mac,
7357 format_vl_api_address, &mp->entry.ip);
7360 static void vl_api_bd_ip_mac_details_t_handler_json
7361 (vl_api_bd_ip_mac_details_t * mp)
7363 vat_main_t *vam = &vat_main;
7364 vat_json_node_t *node = NULL;
7366 if (VAT_JSON_ARRAY != vam->json_tree.type)
7368 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7369 vat_json_init_array (&vam->json_tree);
7371 node = vat_json_array_add (&vam->json_tree);
7373 vat_json_init_object (node);
7374 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7375 vat_json_object_add_string_copy (node, "mac_address",
7376 format (0, "%U", format_vl_api_mac_address,
7380 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7381 vat_json_object_add_string_copy (node, "ip_address", ip);
7386 api_bd_ip_mac_dump (vat_main_t * vam)
7388 unformat_input_t *i = vam->input;
7389 vl_api_bd_ip_mac_dump_t *mp;
7390 vl_api_control_ping_t *mp_ping;
7395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7397 if (unformat (i, "bd_id %d", &bd_id))
7406 "\n%-5s %-7s %-20s %-30s",
7407 "bd_id", "is_ipv6", "mac_address", "ip_address");
7409 /* Dump Bridge Domain Ip to Mac entries */
7410 M (BD_IP_MAC_DUMP, mp);
7413 mp->bd_id = htonl (bd_id);
7419 /* Use a control ping for synchronization */
7420 MPING (CONTROL_PING, mp_ping);
7428 api_tap_create_v2 (vat_main_t * vam)
7430 unformat_input_t *i = vam->input;
7431 vl_api_tap_create_v2_t *mp;
7435 u8 *host_if_name = 0;
7437 u8 host_mac_addr[6];
7438 u8 host_mac_addr_set = 0;
7439 u8 *host_bridge = 0;
7440 ip4_address_t host_ip4_addr;
7441 ip4_address_t host_ip4_gw;
7442 u8 host_ip4_gw_set = 0;
7443 u32 host_ip4_prefix_len = 0;
7444 ip6_address_t host_ip6_addr;
7445 ip6_address_t host_ip6_gw;
7446 u8 host_ip6_gw_set = 0;
7447 u32 host_ip6_prefix_len = 0;
7449 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7451 clib_memset (mac_address, 0, sizeof (mac_address));
7453 /* Parse args required to build the message */
7454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7456 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7460 else if (unformat (i, "id %u", &id))
7462 else if (unformat (i, "host-if-name %s", &host_if_name))
7464 else if (unformat (i, "host-ns %s", &host_ns))
7466 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7468 host_mac_addr_set = 1;
7469 else if (unformat (i, "host-bridge %s", &host_bridge))
7471 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7472 &host_ip4_addr, &host_ip4_prefix_len))
7474 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7475 &host_ip6_addr, &host_ip6_prefix_len))
7477 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7479 host_ip4_gw_set = 1;
7480 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7482 host_ip6_gw_set = 1;
7483 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7485 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7491 if (vec_len (host_if_name) > 63)
7493 errmsg ("tap name too long. ");
7496 if (vec_len (host_ns) > 63)
7498 errmsg ("host name space too long. ");
7501 if (vec_len (host_bridge) > 63)
7503 errmsg ("host bridge name too long. ");
7506 if (host_ip4_prefix_len > 32)
7508 errmsg ("host ip4 prefix length not valid. ");
7511 if (host_ip6_prefix_len > 128)
7513 errmsg ("host ip6 prefix length not valid. ");
7516 if (!is_pow2 (rx_ring_sz))
7518 errmsg ("rx ring size must be power of 2. ");
7521 if (rx_ring_sz > 32768)
7523 errmsg ("rx ring size must be 32768 or lower. ");
7526 if (!is_pow2 (tx_ring_sz))
7528 errmsg ("tx ring size must be power of 2. ");
7531 if (tx_ring_sz > 32768)
7533 errmsg ("tx ring size must be 32768 or lower. ");
7537 /* Construct the API message */
7538 M (TAP_CREATE_V2, mp);
7540 mp->use_random_mac = random_mac;
7542 mp->id = ntohl (id);
7543 mp->host_namespace_set = host_ns != 0;
7544 mp->host_bridge_set = host_bridge != 0;
7545 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7546 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7547 mp->rx_ring_sz = ntohs (rx_ring_sz);
7548 mp->tx_ring_sz = ntohs (tx_ring_sz);
7550 if (random_mac == 0)
7551 clib_memcpy (mp->mac_address, mac_address, 6);
7552 if (host_mac_addr_set)
7553 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7555 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7557 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7559 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7560 if (host_ip4_prefix_len)
7561 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7562 if (host_ip6_prefix_len)
7563 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7564 if (host_ip4_gw_set)
7565 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7566 if (host_ip6_gw_set)
7567 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7570 vec_free (host_if_name);
7571 vec_free (host_bridge);
7576 /* Wait for a reply... */
7582 api_tap_delete_v2 (vat_main_t * vam)
7584 unformat_input_t *i = vam->input;
7585 vl_api_tap_delete_v2_t *mp;
7586 u32 sw_if_index = ~0;
7587 u8 sw_if_index_set = 0;
7590 /* Parse args required to build the message */
7591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7593 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7594 sw_if_index_set = 1;
7595 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7596 sw_if_index_set = 1;
7601 if (sw_if_index_set == 0)
7603 errmsg ("missing vpp interface name. ");
7607 /* Construct the API message */
7608 M (TAP_DELETE_V2, mp);
7610 mp->sw_if_index = ntohl (sw_if_index);
7615 /* Wait for a reply... */
7621 unformat_pci_addr (unformat_input_t * input, va_list * args)
7630 addr = va_arg (*args, struct pci_addr_t *);
7633 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7636 addr->domain = x[0];
7639 addr->function = x[3];
7645 api_virtio_pci_create (vat_main_t * vam)
7647 unformat_input_t *i = vam->input;
7648 vl_api_virtio_pci_create_t *mp;
7653 u64 features = (u64) ~ (0ULL);
7656 clib_memset (mac_address, 0, sizeof (mac_address));
7658 /* Parse args required to build the message */
7659 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7661 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7665 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7667 else if (unformat (i, "features 0x%llx", &features))
7669 else if (unformat (i, "gso-enabled"))
7677 errmsg ("pci address must be non zero. ");
7681 /* Construct the API message */
7682 M (VIRTIO_PCI_CREATE, mp);
7684 mp->use_random_mac = random_mac;
7686 mp->pci_addr = htonl (pci_addr);
7687 mp->features = clib_host_to_net_u64 (features);
7688 mp->gso_enabled = gso_enabled;
7690 if (random_mac == 0)
7691 clib_memcpy (mp->mac_address, mac_address, 6);
7696 /* Wait for a reply... */
7702 api_virtio_pci_delete (vat_main_t * vam)
7704 unformat_input_t *i = vam->input;
7705 vl_api_virtio_pci_delete_t *mp;
7706 u32 sw_if_index = ~0;
7707 u8 sw_if_index_set = 0;
7710 /* Parse args required to build the message */
7711 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7713 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7714 sw_if_index_set = 1;
7715 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7716 sw_if_index_set = 1;
7721 if (sw_if_index_set == 0)
7723 errmsg ("missing vpp interface name. ");
7727 /* Construct the API message */
7728 M (VIRTIO_PCI_DELETE, mp);
7730 mp->sw_if_index = htonl (sw_if_index);
7735 /* Wait for a reply... */
7741 api_bond_create (vat_main_t * vam)
7743 unformat_input_t *i = vam->input;
7744 vl_api_bond_create_t *mp;
7753 clib_memset (mac_address, 0, sizeof (mac_address));
7756 /* Parse args required to build the message */
7757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7759 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7761 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7762 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7764 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7767 else if (unformat (i, "id %u", &id))
7773 if (mode_is_set == 0)
7775 errmsg ("Missing bond mode. ");
7779 /* Construct the API message */
7780 M (BOND_CREATE, mp);
7782 mp->use_custom_mac = custom_mac;
7786 mp->id = htonl (id);
7789 clib_memcpy (mp->mac_address, mac_address, 6);
7794 /* Wait for a reply... */
7800 api_bond_delete (vat_main_t * vam)
7802 unformat_input_t *i = vam->input;
7803 vl_api_bond_delete_t *mp;
7804 u32 sw_if_index = ~0;
7805 u8 sw_if_index_set = 0;
7808 /* Parse args required to build the message */
7809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7812 sw_if_index_set = 1;
7813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7814 sw_if_index_set = 1;
7819 if (sw_if_index_set == 0)
7821 errmsg ("missing vpp interface name. ");
7825 /* Construct the API message */
7826 M (BOND_DELETE, mp);
7828 mp->sw_if_index = ntohl (sw_if_index);
7833 /* Wait for a reply... */
7839 api_bond_enslave (vat_main_t * vam)
7841 unformat_input_t *i = vam->input;
7842 vl_api_bond_enslave_t *mp;
7843 u32 bond_sw_if_index;
7847 u32 bond_sw_if_index_is_set = 0;
7849 u8 sw_if_index_is_set = 0;
7851 /* Parse args required to build the message */
7852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7854 if (unformat (i, "sw_if_index %d", &sw_if_index))
7855 sw_if_index_is_set = 1;
7856 else if (unformat (i, "bond %u", &bond_sw_if_index))
7857 bond_sw_if_index_is_set = 1;
7858 else if (unformat (i, "passive %d", &is_passive))
7860 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7866 if (bond_sw_if_index_is_set == 0)
7868 errmsg ("Missing bond sw_if_index. ");
7871 if (sw_if_index_is_set == 0)
7873 errmsg ("Missing slave sw_if_index. ");
7877 /* Construct the API message */
7878 M (BOND_ENSLAVE, mp);
7880 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7881 mp->sw_if_index = ntohl (sw_if_index);
7882 mp->is_long_timeout = is_long_timeout;
7883 mp->is_passive = is_passive;
7888 /* Wait for a reply... */
7894 api_bond_detach_slave (vat_main_t * vam)
7896 unformat_input_t *i = vam->input;
7897 vl_api_bond_detach_slave_t *mp;
7898 u32 sw_if_index = ~0;
7899 u8 sw_if_index_set = 0;
7902 /* Parse args required to build the message */
7903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7905 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7906 sw_if_index_set = 1;
7907 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7908 sw_if_index_set = 1;
7913 if (sw_if_index_set == 0)
7915 errmsg ("missing vpp interface name. ");
7919 /* Construct the API message */
7920 M (BOND_DETACH_SLAVE, mp);
7922 mp->sw_if_index = ntohl (sw_if_index);
7927 /* Wait for a reply... */
7933 api_ip_table_add_del (vat_main_t * vam)
7935 unformat_input_t *i = vam->input;
7936 vl_api_ip_table_add_del_t *mp;
7942 /* Parse args required to build the message */
7943 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7945 if (unformat (i, "ipv6"))
7947 else if (unformat (i, "del"))
7949 else if (unformat (i, "add"))
7951 else if (unformat (i, "table %d", &table_id))
7955 clib_warning ("parse error '%U'", format_unformat_error, i);
7962 errmsg ("missing table-ID");
7966 /* Construct the API message */
7967 M (IP_TABLE_ADD_DEL, mp);
7969 mp->table.table_id = ntohl (table_id);
7970 mp->table.is_ip6 = is_ipv6;
7971 mp->is_add = is_add;
7976 /* Wait for a reply... */
7983 unformat_fib_path (unformat_input_t * input, va_list * args)
7985 vat_main_t *vam = va_arg (*args, vat_main_t *);
7986 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7987 u32 weight, preference;
7988 mpls_label_t out_label;
7990 clib_memset (path, 0, sizeof (*path));
7992 path->sw_if_index = ~0;
7996 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7998 if (unformat (input, "%U %U",
7999 unformat_vl_api_ip4_address,
8000 &path->nh.address.ip4,
8001 api_unformat_sw_if_index, vam, &path->sw_if_index))
8003 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8005 else if (unformat (input, "%U %U",
8006 unformat_vl_api_ip6_address,
8007 &path->nh.address.ip6,
8008 api_unformat_sw_if_index, vam, &path->sw_if_index))
8010 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8012 else if (unformat (input, "weight %u", &weight))
8014 path->weight = weight;
8016 else if (unformat (input, "preference %u", &preference))
8018 path->preference = preference;
8020 else if (unformat (input, "%U next-hop-table %d",
8021 unformat_vl_api_ip4_address,
8022 &path->nh.address.ip4, &path->table_id))
8024 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8026 else if (unformat (input, "%U next-hop-table %d",
8027 unformat_vl_api_ip6_address,
8028 &path->nh.address.ip6, &path->table_id))
8030 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8032 else if (unformat (input, "%U",
8033 unformat_vl_api_ip4_address, &path->nh.address.ip4))
8036 * the recursive next-hops are by default in the default table
8039 path->sw_if_index = ~0;
8040 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8042 else if (unformat (input, "%U",
8043 unformat_vl_api_ip6_address, &path->nh.address.ip6))
8046 * the recursive next-hops are by default in the default table
8049 path->sw_if_index = ~0;
8050 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8052 else if (unformat (input, "resolve-via-host"))
8054 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
8056 else if (unformat (input, "resolve-via-attached"))
8058 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
8060 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
8062 path->type = FIB_API_PATH_TYPE_LOCAL;
8063 path->sw_if_index = ~0;
8064 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8066 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
8068 path->type = FIB_API_PATH_TYPE_LOCAL;
8069 path->sw_if_index = ~0;
8070 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8072 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
8074 else if (unformat (input, "via-label %d", &path->nh.via_label))
8076 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8077 path->sw_if_index = ~0;
8079 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8081 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8082 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8084 else if (unformat (input, "local"))
8086 path->type = FIB_API_PATH_TYPE_LOCAL;
8088 else if (unformat (input, "out-labels"))
8090 while (unformat (input, "%d", &out_label))
8092 path->label_stack[path->n_labels].label = out_label;
8093 path->label_stack[path->n_labels].is_uniform = 0;
8094 path->label_stack[path->n_labels].ttl = 64;
8098 else if (unformat (input, "via"))
8100 /* new path, back up and return */
8101 unformat_put_input (input);
8102 unformat_put_input (input);
8103 unformat_put_input (input);
8104 unformat_put_input (input);
8113 path->proto = ntohl (path->proto);
8114 path->type = ntohl (path->type);
8115 path->flags = ntohl (path->flags);
8116 path->table_id = ntohl (path->table_id);
8117 path->sw_if_index = ntohl (path->sw_if_index);
8123 api_ip_route_add_del (vat_main_t * vam)
8125 unformat_input_t *i = vam->input;
8126 vl_api_ip_route_add_del_t *mp;
8129 u8 is_multipath = 0;
8132 vl_api_prefix_t pfx = { };
8133 vl_api_fib_path_t paths[8];
8137 u32 random_add_del = 0;
8138 u32 *random_vector = 0;
8139 u32 random_seed = 0xdeaddabe;
8141 /* Parse args required to build the message */
8142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8144 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8146 else if (unformat (i, "del"))
8148 else if (unformat (i, "add"))
8150 else if (unformat (i, "vrf %d", &vrf_id))
8152 else if (unformat (i, "count %d", &count))
8154 else if (unformat (i, "random"))
8156 else if (unformat (i, "multipath"))
8158 else if (unformat (i, "seed %d", &random_seed))
8162 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8165 if (8 == path_count)
8167 errmsg ("max 8 paths");
8173 clib_warning ("parse error '%U'", format_unformat_error, i);
8180 errmsg ("specify a path; via ...");
8183 if (prefix_set == 0)
8185 errmsg ("missing prefix");
8189 /* Generate a pile of unique, random routes */
8192 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8193 u32 this_random_address;
8196 random_hash = hash_create (count, sizeof (uword));
8198 hash_set (random_hash, i->as_u32, 1);
8199 for (j = 0; j <= count; j++)
8203 this_random_address = random_u32 (&random_seed);
8204 this_random_address =
8205 clib_host_to_net_u32 (this_random_address);
8207 while (hash_get (random_hash, this_random_address));
8208 vec_add1 (random_vector, this_random_address);
8209 hash_set (random_hash, this_random_address, 1);
8211 hash_free (random_hash);
8212 set_ip4_address (&pfx.address, random_vector[0]);
8217 /* Turn on async mode */
8218 vam->async_mode = 1;
8219 vam->async_errors = 0;
8220 before = vat_time_now (vam);
8223 for (j = 0; j < count; j++)
8225 /* Construct the API message */
8226 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8228 mp->is_add = is_add;
8229 mp->is_multipath = is_multipath;
8231 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8232 mp->route.table_id = ntohl (vrf_id);
8233 mp->route.n_paths = path_count;
8235 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8238 set_ip4_address (&pfx.address, random_vector[j + 1]);
8240 increment_address (&pfx.address);
8243 /* If we receive SIGTERM, stop now... */
8248 /* When testing multiple add/del ops, use a control-ping to sync */
8251 vl_api_control_ping_t *mp_ping;
8255 /* Shut off async mode */
8256 vam->async_mode = 0;
8258 MPING (CONTROL_PING, mp_ping);
8261 timeout = vat_time_now (vam) + 1.0;
8262 while (vat_time_now (vam) < timeout)
8263 if (vam->result_ready == 1)
8268 if (vam->retval == -99)
8271 if (vam->async_errors > 0)
8273 errmsg ("%d asynchronous errors", vam->async_errors);
8276 vam->async_errors = 0;
8277 after = vat_time_now (vam);
8279 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8283 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8284 count, after - before, count / (after - before));
8290 /* Wait for a reply... */
8295 /* Return the good/bad news */
8296 return (vam->retval);
8300 api_ip_mroute_add_del (vat_main_t * vam)
8302 unformat_input_t *i = vam->input;
8303 u8 path_set = 0, prefix_set = 0, is_add = 1;
8304 vl_api_ip_mroute_add_del_t *mp;
8305 mfib_entry_flags_t eflags = 0;
8306 vl_api_mfib_path_t path;
8307 vl_api_mprefix_t pfx = { };
8311 /* Parse args required to build the message */
8312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8314 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8317 pfx.grp_address_length = htons (pfx.grp_address_length);
8319 else if (unformat (i, "del"))
8321 else if (unformat (i, "add"))
8323 else if (unformat (i, "vrf %d", &vrf_id))
8325 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8326 path.itf_flags = htonl (path.itf_flags);
8327 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8329 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8333 clib_warning ("parse error '%U'", format_unformat_error, i);
8338 if (prefix_set == 0)
8340 errmsg ("missing addresses\n");
8345 errmsg ("missing path\n");
8349 /* Construct the API message */
8350 M (IP_MROUTE_ADD_DEL, mp);
8352 mp->is_add = is_add;
8353 mp->is_multipath = 1;
8355 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8356 mp->route.table_id = htonl (vrf_id);
8357 mp->route.n_paths = 1;
8358 mp->route.entry_flags = htonl (eflags);
8360 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8364 /* Wait for a reply... */
8370 api_mpls_table_add_del (vat_main_t * vam)
8372 unformat_input_t *i = vam->input;
8373 vl_api_mpls_table_add_del_t *mp;
8378 /* Parse args required to build the message */
8379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8381 if (unformat (i, "table %d", &table_id))
8383 else if (unformat (i, "del"))
8385 else if (unformat (i, "add"))
8389 clib_warning ("parse error '%U'", format_unformat_error, i);
8396 errmsg ("missing table-ID");
8400 /* Construct the API message */
8401 M (MPLS_TABLE_ADD_DEL, mp);
8403 mp->mt_table.mt_table_id = ntohl (table_id);
8404 mp->mt_is_add = is_add;
8409 /* Wait for a reply... */
8416 api_mpls_route_add_del (vat_main_t * vam)
8418 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8419 mpls_label_t local_label = MPLS_LABEL_INVALID;
8420 unformat_input_t *i = vam->input;
8421 vl_api_mpls_route_add_del_t *mp;
8422 vl_api_fib_path_t paths[8];
8426 /* Parse args required to build the message */
8427 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8429 if (unformat (i, "%d", &local_label))
8431 else if (unformat (i, "eos"))
8433 else if (unformat (i, "non-eos"))
8435 else if (unformat (i, "del"))
8437 else if (unformat (i, "add"))
8439 else if (unformat (i, "multipath"))
8441 else if (unformat (i, "count %d", &count))
8445 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8448 if (8 == path_count)
8450 errmsg ("max 8 paths");
8456 clib_warning ("parse error '%U'", format_unformat_error, i);
8463 errmsg ("specify a path; via ...");
8467 if (MPLS_LABEL_INVALID == local_label)
8469 errmsg ("missing label");
8475 /* Turn on async mode */
8476 vam->async_mode = 1;
8477 vam->async_errors = 0;
8478 before = vat_time_now (vam);
8481 for (j = 0; j < count; j++)
8483 /* Construct the API message */
8484 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8486 mp->mr_is_add = is_add;
8487 mp->mr_is_multipath = is_multipath;
8489 mp->mr_route.mr_label = local_label;
8490 mp->mr_route.mr_eos = is_eos;
8491 mp->mr_route.mr_table_id = 0;
8492 mp->mr_route.mr_n_paths = path_count;
8494 clib_memcpy (&mp->mr_route.mr_paths, paths,
8495 sizeof (paths[0]) * path_count);
8501 /* If we receive SIGTERM, stop now... */
8506 /* When testing multiple add/del ops, use a control-ping to sync */
8509 vl_api_control_ping_t *mp_ping;
8513 /* Shut off async mode */
8514 vam->async_mode = 0;
8516 MPING (CONTROL_PING, mp_ping);
8519 timeout = vat_time_now (vam) + 1.0;
8520 while (vat_time_now (vam) < timeout)
8521 if (vam->result_ready == 1)
8526 if (vam->retval == -99)
8529 if (vam->async_errors > 0)
8531 errmsg ("%d asynchronous errors", vam->async_errors);
8534 vam->async_errors = 0;
8535 after = vat_time_now (vam);
8537 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8541 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8542 count, after - before, count / (after - before));
8548 /* Wait for a reply... */
8553 /* Return the good/bad news */
8554 return (vam->retval);
8559 api_mpls_ip_bind_unbind (vat_main_t * vam)
8561 unformat_input_t *i = vam->input;
8562 vl_api_mpls_ip_bind_unbind_t *mp;
8563 u32 ip_table_id = 0;
8565 vl_api_prefix_t pfx;
8567 mpls_label_t local_label = MPLS_LABEL_INVALID;
8570 /* Parse args required to build the message */
8571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8573 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8575 else if (unformat (i, "%d", &local_label))
8577 else if (unformat (i, "table-id %d", &ip_table_id))
8579 else if (unformat (i, "unbind"))
8581 else if (unformat (i, "bind"))
8585 clib_warning ("parse error '%U'", format_unformat_error, i);
8592 errmsg ("IP prefix not set");
8596 if (MPLS_LABEL_INVALID == local_label)
8598 errmsg ("missing label");
8602 /* Construct the API message */
8603 M (MPLS_IP_BIND_UNBIND, mp);
8605 mp->mb_is_bind = is_bind;
8606 mp->mb_ip_table_id = ntohl (ip_table_id);
8607 mp->mb_mpls_table_id = 0;
8608 mp->mb_label = ntohl (local_label);
8609 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8614 /* Wait for a reply... */
8621 api_sr_mpls_policy_add (vat_main_t * vam)
8623 unformat_input_t *i = vam->input;
8624 vl_api_sr_mpls_policy_add_t *mp;
8630 u32 *segments = NULL;
8633 /* Parse args required to build the message */
8634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8636 if (unformat (i, "bsid %d", &bsid))
8638 else if (unformat (i, "weight %d", &weight))
8640 else if (unformat (i, "spray"))
8642 else if (unformat (i, "next %d", &sid))
8645 vec_add1 (segments, htonl (sid));
8649 clib_warning ("parse error '%U'", format_unformat_error, i);
8656 errmsg ("bsid not set");
8660 if (n_segments == 0)
8662 errmsg ("no sid in segment stack");
8666 /* Construct the API message */
8667 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8669 mp->bsid = htonl (bsid);
8670 mp->weight = htonl (weight);
8672 mp->n_segments = n_segments;
8673 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8674 vec_free (segments);
8679 /* Wait for a reply... */
8685 api_sr_mpls_policy_del (vat_main_t * vam)
8687 unformat_input_t *i = vam->input;
8688 vl_api_sr_mpls_policy_del_t *mp;
8692 /* Parse args required to build the message */
8693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8695 if (unformat (i, "bsid %d", &bsid))
8699 clib_warning ("parse error '%U'", format_unformat_error, i);
8706 errmsg ("bsid not set");
8710 /* Construct the API message */
8711 M (SR_MPLS_POLICY_DEL, mp);
8713 mp->bsid = htonl (bsid);
8718 /* Wait for a reply... */
8724 api_bier_table_add_del (vat_main_t * vam)
8726 unformat_input_t *i = vam->input;
8727 vl_api_bier_table_add_del_t *mp;
8729 u32 set = 0, sub_domain = 0, hdr_len = 3;
8730 mpls_label_t local_label = MPLS_LABEL_INVALID;
8733 /* Parse args required to build the message */
8734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8736 if (unformat (i, "sub-domain %d", &sub_domain))
8738 else if (unformat (i, "set %d", &set))
8740 else if (unformat (i, "label %d", &local_label))
8742 else if (unformat (i, "hdr-len %d", &hdr_len))
8744 else if (unformat (i, "add"))
8746 else if (unformat (i, "del"))
8750 clib_warning ("parse error '%U'", format_unformat_error, i);
8755 if (MPLS_LABEL_INVALID == local_label)
8757 errmsg ("missing label\n");
8761 /* Construct the API message */
8762 M (BIER_TABLE_ADD_DEL, mp);
8764 mp->bt_is_add = is_add;
8765 mp->bt_label = ntohl (local_label);
8766 mp->bt_tbl_id.bt_set = set;
8767 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8768 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8773 /* Wait for a reply... */
8780 api_bier_route_add_del (vat_main_t * vam)
8782 unformat_input_t *i = vam->input;
8783 vl_api_bier_route_add_del_t *mp;
8785 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8786 ip4_address_t v4_next_hop_address;
8787 ip6_address_t v6_next_hop_address;
8788 u8 next_hop_set = 0;
8789 u8 next_hop_proto_is_ip4 = 1;
8790 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8793 /* Parse args required to build the message */
8794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8796 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8798 next_hop_proto_is_ip4 = 1;
8801 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8803 next_hop_proto_is_ip4 = 0;
8806 if (unformat (i, "sub-domain %d", &sub_domain))
8808 else if (unformat (i, "set %d", &set))
8810 else if (unformat (i, "hdr-len %d", &hdr_len))
8812 else if (unformat (i, "bp %d", &bp))
8814 else if (unformat (i, "add"))
8816 else if (unformat (i, "del"))
8818 else if (unformat (i, "out-label %d", &next_hop_out_label))
8822 clib_warning ("parse error '%U'", format_unformat_error, i);
8827 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8829 errmsg ("next hop / label set\n");
8834 errmsg ("bit=position not set\n");
8838 /* Construct the API message */
8839 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8841 mp->br_is_add = is_add;
8842 mp->br_route.br_tbl_id.bt_set = set;
8843 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8844 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8845 mp->br_route.br_bp = ntohs (bp);
8846 mp->br_route.br_n_paths = 1;
8847 mp->br_route.br_paths[0].n_labels = 1;
8848 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8849 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8850 FIB_API_PATH_NH_PROTO_IP4 :
8851 FIB_API_PATH_NH_PROTO_IP6);
8853 if (next_hop_proto_is_ip4)
8855 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8856 &v4_next_hop_address, sizeof (v4_next_hop_address));
8860 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8861 &v6_next_hop_address, sizeof (v6_next_hop_address));
8867 /* Wait for a reply... */
8874 api_proxy_arp_add_del (vat_main_t * vam)
8876 unformat_input_t *i = vam->input;
8877 vl_api_proxy_arp_add_del_t *mp;
8880 vl_api_ip4_address_t lo, hi;
8884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8886 if (unformat (i, "vrf %d", &vrf_id))
8888 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
8889 unformat_vl_api_ip4_address, &hi))
8891 else if (unformat (i, "del"))
8895 clib_warning ("parse error '%U'", format_unformat_error, i);
8902 errmsg ("address range not set");
8906 M (PROXY_ARP_ADD_DEL, mp);
8908 mp->proxy.table_id = ntohl (vrf_id);
8909 mp->is_add = is_add;
8910 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
8911 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
8919 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8921 unformat_input_t *i = vam->input;
8922 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8925 u8 sw_if_index_set = 0;
8928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8930 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8931 sw_if_index_set = 1;
8932 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8933 sw_if_index_set = 1;
8934 else if (unformat (i, "enable"))
8936 else if (unformat (i, "disable"))
8940 clib_warning ("parse error '%U'", format_unformat_error, i);
8945 if (sw_if_index_set == 0)
8947 errmsg ("missing interface name or sw_if_index");
8951 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8953 mp->sw_if_index = ntohl (sw_if_index);
8954 mp->enable_disable = enable;
8962 api_mpls_tunnel_add_del (vat_main_t * vam)
8964 unformat_input_t *i = vam->input;
8965 vl_api_mpls_tunnel_add_del_t *mp;
8967 vl_api_fib_path_t paths[8];
8968 u32 sw_if_index = ~0;
8974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8976 if (unformat (i, "add"))
8980 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8982 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8984 else if (unformat (i, "l2-only"))
8988 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8991 if (8 == path_count)
8993 errmsg ("max 8 paths");
8999 clib_warning ("parse error '%U'", format_unformat_error, i);
9004 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
9006 mp->mt_is_add = is_add;
9007 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
9008 mp->mt_tunnel.mt_l2_only = l2_only;
9009 mp->mt_tunnel.mt_is_multicast = 0;
9010 mp->mt_tunnel.mt_n_paths = path_count;
9012 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
9013 sizeof (paths[0]) * path_count);
9021 api_sw_interface_set_unnumbered (vat_main_t * vam)
9023 unformat_input_t *i = vam->input;
9024 vl_api_sw_interface_set_unnumbered_t *mp;
9026 u32 unnum_sw_index = ~0;
9028 u8 sw_if_index_set = 0;
9031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9033 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9034 sw_if_index_set = 1;
9035 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9036 sw_if_index_set = 1;
9037 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9039 else if (unformat (i, "del"))
9043 clib_warning ("parse error '%U'", format_unformat_error, i);
9048 if (sw_if_index_set == 0)
9050 errmsg ("missing interface name or sw_if_index");
9054 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9056 mp->sw_if_index = ntohl (sw_if_index);
9057 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9058 mp->is_add = is_add;
9066 api_ip_neighbor_add_del (vat_main_t * vam)
9068 vl_api_mac_address_t mac_address;
9069 unformat_input_t *i = vam->input;
9070 vl_api_ip_neighbor_add_del_t *mp;
9071 vl_api_address_t ip_address;
9073 u8 sw_if_index_set = 0;
9078 ip_neighbor_flags_t flags;
9080 flags = IP_NEIGHBOR_FLAG_NONE;
9081 clib_memset (&ip_address, 0, sizeof (ip_address));
9082 clib_memset (&mac_address, 0, sizeof (mac_address));
9084 /* Parse args required to build the message */
9085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9087 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9091 else if (unformat (i, "del"))
9094 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9095 sw_if_index_set = 1;
9096 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9097 sw_if_index_set = 1;
9098 else if (unformat (i, "static"))
9099 flags |= IP_NEIGHBOR_FLAG_STATIC;
9100 else if (unformat (i, "no-fib-entry"))
9101 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9102 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9106 clib_warning ("parse error '%U'", format_unformat_error, i);
9111 if (sw_if_index_set == 0)
9113 errmsg ("missing interface name or sw_if_index");
9118 errmsg ("no address set");
9122 /* Construct the API message */
9123 M (IP_NEIGHBOR_ADD_DEL, mp);
9125 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9126 mp->is_add = is_add;
9127 mp->neighbor.flags = htonl (flags);
9129 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9130 sizeof (mac_address));
9132 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9137 /* Wait for a reply, return good/bad news */
9143 api_create_vlan_subif (vat_main_t * vam)
9145 unformat_input_t *i = vam->input;
9146 vl_api_create_vlan_subif_t *mp;
9148 u8 sw_if_index_set = 0;
9153 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9155 if (unformat (i, "sw_if_index %d", &sw_if_index))
9156 sw_if_index_set = 1;
9158 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9159 sw_if_index_set = 1;
9160 else if (unformat (i, "vlan %d", &vlan_id))
9164 clib_warning ("parse error '%U'", format_unformat_error, i);
9169 if (sw_if_index_set == 0)
9171 errmsg ("missing interface name or sw_if_index");
9175 if (vlan_id_set == 0)
9177 errmsg ("missing vlan_id");
9180 M (CREATE_VLAN_SUBIF, mp);
9182 mp->sw_if_index = ntohl (sw_if_index);
9183 mp->vlan_id = ntohl (vlan_id);
9190 #define foreach_create_subif_bit \
9197 _(outer_vlan_id_any) \
9198 _(inner_vlan_id_any)
9201 api_create_subif (vat_main_t * vam)
9203 unformat_input_t *i = vam->input;
9204 vl_api_create_subif_t *mp;
9206 u8 sw_if_index_set = 0;
9213 u32 exact_match = 0;
9214 u32 default_sub = 0;
9215 u32 outer_vlan_id_any = 0;
9216 u32 inner_vlan_id_any = 0;
9218 u16 outer_vlan_id = 0;
9219 u16 inner_vlan_id = 0;
9222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9224 if (unformat (i, "sw_if_index %d", &sw_if_index))
9225 sw_if_index_set = 1;
9227 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9228 sw_if_index_set = 1;
9229 else if (unformat (i, "sub_id %d", &sub_id))
9231 else if (unformat (i, "outer_vlan_id %d", &tmp))
9232 outer_vlan_id = tmp;
9233 else if (unformat (i, "inner_vlan_id %d", &tmp))
9234 inner_vlan_id = tmp;
9236 #define _(a) else if (unformat (i, #a)) a = 1 ;
9237 foreach_create_subif_bit
9241 clib_warning ("parse error '%U'", format_unformat_error, i);
9246 if (sw_if_index_set == 0)
9248 errmsg ("missing interface name or sw_if_index");
9252 if (sub_id_set == 0)
9254 errmsg ("missing sub_id");
9257 M (CREATE_SUBIF, mp);
9259 mp->sw_if_index = ntohl (sw_if_index);
9260 mp->sub_id = ntohl (sub_id);
9262 #define _(a) mp->a = a;
9263 foreach_create_subif_bit;
9266 mp->outer_vlan_id = ntohs (outer_vlan_id);
9267 mp->inner_vlan_id = ntohs (inner_vlan_id);
9275 api_reset_fib (vat_main_t * vam)
9277 unformat_input_t *i = vam->input;
9278 vl_api_reset_fib_t *mp;
9284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9286 if (unformat (i, "vrf %d", &vrf_id))
9288 else if (unformat (i, "ipv6"))
9292 clib_warning ("parse error '%U'", format_unformat_error, i);
9297 if (vrf_id_set == 0)
9299 errmsg ("missing vrf id");
9305 mp->vrf_id = ntohl (vrf_id);
9306 mp->is_ipv6 = is_ipv6;
9314 api_dhcp_proxy_config (vat_main_t * vam)
9316 unformat_input_t *i = vam->input;
9317 vl_api_dhcp_proxy_config_t *mp;
9319 u32 server_vrf_id = 0;
9321 u8 v4_address_set = 0;
9322 u8 v6_address_set = 0;
9323 ip4_address_t v4address;
9324 ip6_address_t v6address;
9325 u8 v4_src_address_set = 0;
9326 u8 v6_src_address_set = 0;
9327 ip4_address_t v4srcaddress;
9328 ip6_address_t v6srcaddress;
9331 /* Parse args required to build the message */
9332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9334 if (unformat (i, "del"))
9336 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9338 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9340 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9342 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9344 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9345 v4_src_address_set = 1;
9346 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9347 v6_src_address_set = 1;
9352 if (v4_address_set && v6_address_set)
9354 errmsg ("both v4 and v6 server addresses set");
9357 if (!v4_address_set && !v6_address_set)
9359 errmsg ("no server addresses set");
9363 if (v4_src_address_set && v6_src_address_set)
9365 errmsg ("both v4 and v6 src addresses set");
9368 if (!v4_src_address_set && !v6_src_address_set)
9370 errmsg ("no src addresses set");
9374 if (!(v4_src_address_set && v4_address_set) &&
9375 !(v6_src_address_set && v6_address_set))
9377 errmsg ("no matching server and src addresses set");
9381 /* Construct the API message */
9382 M (DHCP_PROXY_CONFIG, mp);
9384 mp->is_add = is_add;
9385 mp->rx_vrf_id = ntohl (rx_vrf_id);
9386 mp->server_vrf_id = ntohl (server_vrf_id);
9390 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9391 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9395 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9396 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9402 /* Wait for a reply, return good/bad news */
9407 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9408 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9411 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9413 vat_main_t *vam = &vat_main;
9414 u32 i, count = mp->count;
9415 vl_api_dhcp_server_t *s;
9419 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9420 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9421 ntohl (mp->rx_vrf_id),
9422 format_ip6_address, mp->dhcp_src_address,
9423 mp->vss_type, mp->vss_vpn_ascii_id,
9424 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9427 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9428 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9429 ntohl (mp->rx_vrf_id),
9430 format_ip4_address, mp->dhcp_src_address,
9431 mp->vss_type, mp->vss_vpn_ascii_id,
9432 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9434 for (i = 0; i < count; i++)
9436 s = &mp->servers[i];
9440 " Server Table-ID %d, Server Address %U",
9441 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9444 " Server Table-ID %d, Server Address %U",
9445 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9449 static void vl_api_dhcp_proxy_details_t_handler_json
9450 (vl_api_dhcp_proxy_details_t * mp)
9452 vat_main_t *vam = &vat_main;
9453 vat_json_node_t *node = NULL;
9454 u32 i, count = mp->count;
9456 struct in6_addr ip6;
9457 vl_api_dhcp_server_t *s;
9459 if (VAT_JSON_ARRAY != vam->json_tree.type)
9461 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9462 vat_json_init_array (&vam->json_tree);
9464 node = vat_json_array_add (&vam->json_tree);
9466 vat_json_init_object (node);
9467 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9468 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9469 sizeof (mp->vss_type));
9470 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9471 mp->vss_vpn_ascii_id);
9472 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9473 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9477 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9478 vat_json_object_add_ip6 (node, "src_address", ip6);
9482 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9483 vat_json_object_add_ip4 (node, "src_address", ip4);
9486 for (i = 0; i < count; i++)
9488 s = &mp->servers[i];
9490 vat_json_object_add_uint (node, "server-table-id",
9491 ntohl (s->server_vrf_id));
9495 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9496 vat_json_object_add_ip4 (node, "src_address", ip4);
9500 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9501 vat_json_object_add_ip6 (node, "server_address", ip6);
9507 api_dhcp_proxy_dump (vat_main_t * vam)
9509 unformat_input_t *i = vam->input;
9510 vl_api_control_ping_t *mp_ping;
9511 vl_api_dhcp_proxy_dump_t *mp;
9515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9517 if (unformat (i, "ipv6"))
9521 clib_warning ("parse error '%U'", format_unformat_error, i);
9526 M (DHCP_PROXY_DUMP, mp);
9528 mp->is_ip6 = is_ipv6;
9531 /* Use a control ping for synchronization */
9532 MPING (CONTROL_PING, mp_ping);
9540 api_dhcp_proxy_set_vss (vat_main_t * vam)
9542 unformat_input_t *i = vam->input;
9543 vl_api_dhcp_proxy_set_vss_t *mp;
9547 u8 vss_type = VSS_TYPE_DEFAULT;
9548 u8 *vpn_ascii_id = 0;
9553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9555 if (unformat (i, "tbl_id %d", &tbl_id))
9557 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9558 vss_type = VSS_TYPE_ASCII;
9559 else if (unformat (i, "fib_id %d", &fib_id))
9560 vss_type = VSS_TYPE_VPN_ID;
9561 else if (unformat (i, "oui %d", &oui))
9562 vss_type = VSS_TYPE_VPN_ID;
9563 else if (unformat (i, "ipv6"))
9565 else if (unformat (i, "del"))
9573 errmsg ("missing tbl_id ");
9574 vec_free (vpn_ascii_id);
9578 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9580 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9581 vec_free (vpn_ascii_id);
9585 M (DHCP_PROXY_SET_VSS, mp);
9586 mp->tbl_id = ntohl (tbl_id);
9587 mp->vss_type = vss_type;
9590 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9591 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9593 mp->vpn_index = ntohl (fib_id);
9594 mp->oui = ntohl (oui);
9595 mp->is_ipv6 = is_ipv6;
9596 mp->is_add = is_add;
9601 vec_free (vpn_ascii_id);
9606 api_dhcp_client_config (vat_main_t * vam)
9608 unformat_input_t *i = vam->input;
9609 vl_api_dhcp_client_config_t *mp;
9611 u8 sw_if_index_set = 0;
9614 u8 disable_event = 0;
9617 /* Parse args required to build the message */
9618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9620 if (unformat (i, "del"))
9623 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9624 sw_if_index_set = 1;
9625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9626 sw_if_index_set = 1;
9627 else if (unformat (i, "hostname %s", &hostname))
9629 else if (unformat (i, "disable_event"))
9635 if (sw_if_index_set == 0)
9637 errmsg ("missing interface name or sw_if_index");
9641 if (vec_len (hostname) > 63)
9643 errmsg ("hostname too long");
9645 vec_add1 (hostname, 0);
9647 /* Construct the API message */
9648 M (DHCP_CLIENT_CONFIG, mp);
9650 mp->is_add = is_add;
9651 mp->client.sw_if_index = htonl (sw_if_index);
9652 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9653 vec_free (hostname);
9654 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9655 mp->client.pid = htonl (getpid ());
9660 /* Wait for a reply, return good/bad news */
9666 api_set_ip_flow_hash (vat_main_t * vam)
9668 unformat_input_t *i = vam->input;
9669 vl_api_set_ip_flow_hash_t *mp;
9681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9683 if (unformat (i, "vrf %d", &vrf_id))
9685 else if (unformat (i, "ipv6"))
9687 else if (unformat (i, "src"))
9689 else if (unformat (i, "dst"))
9691 else if (unformat (i, "sport"))
9693 else if (unformat (i, "dport"))
9695 else if (unformat (i, "proto"))
9697 else if (unformat (i, "reverse"))
9702 clib_warning ("parse error '%U'", format_unformat_error, i);
9707 if (vrf_id_set == 0)
9709 errmsg ("missing vrf id");
9713 M (SET_IP_FLOW_HASH, mp);
9719 mp->reverse = reverse;
9720 mp->vrf_id = ntohl (vrf_id);
9721 mp->is_ipv6 = is_ipv6;
9729 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9731 unformat_input_t *i = vam->input;
9732 vl_api_sw_interface_ip6_enable_disable_t *mp;
9734 u8 sw_if_index_set = 0;
9738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9740 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9741 sw_if_index_set = 1;
9742 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9743 sw_if_index_set = 1;
9744 else if (unformat (i, "enable"))
9746 else if (unformat (i, "disable"))
9750 clib_warning ("parse error '%U'", format_unformat_error, i);
9755 if (sw_if_index_set == 0)
9757 errmsg ("missing interface name or sw_if_index");
9761 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9763 mp->sw_if_index = ntohl (sw_if_index);
9764 mp->enable = enable;
9772 api_ip6nd_proxy_add_del (vat_main_t * vam)
9774 unformat_input_t *i = vam->input;
9775 vl_api_ip6nd_proxy_add_del_t *mp;
9776 u32 sw_if_index = ~0;
9777 u8 v6_address_set = 0;
9778 vl_api_ip6_address_t v6address;
9782 /* Parse args required to build the message */
9783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9785 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9787 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9789 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
9791 if (unformat (i, "del"))
9795 clib_warning ("parse error '%U'", format_unformat_error, i);
9800 if (sw_if_index == ~0)
9802 errmsg ("missing interface name or sw_if_index");
9805 if (!v6_address_set)
9807 errmsg ("no address set");
9811 /* Construct the API message */
9812 M (IP6ND_PROXY_ADD_DEL, mp);
9814 mp->is_del = is_del;
9815 mp->sw_if_index = ntohl (sw_if_index);
9816 clib_memcpy (mp->ip, v6address, sizeof (v6address));
9821 /* Wait for a reply, return good/bad news */
9827 api_ip6nd_proxy_dump (vat_main_t * vam)
9829 vl_api_ip6nd_proxy_dump_t *mp;
9830 vl_api_control_ping_t *mp_ping;
9833 M (IP6ND_PROXY_DUMP, mp);
9837 /* Use a control ping for synchronization */
9838 MPING (CONTROL_PING, mp_ping);
9845 static void vl_api_ip6nd_proxy_details_t_handler
9846 (vl_api_ip6nd_proxy_details_t * mp)
9848 vat_main_t *vam = &vat_main;
9850 print (vam->ofp, "host %U sw_if_index %d",
9851 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
9854 static void vl_api_ip6nd_proxy_details_t_handler_json
9855 (vl_api_ip6nd_proxy_details_t * mp)
9857 vat_main_t *vam = &vat_main;
9858 struct in6_addr ip6;
9859 vat_json_node_t *node = NULL;
9861 if (VAT_JSON_ARRAY != vam->json_tree.type)
9863 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9864 vat_json_init_array (&vam->json_tree);
9866 node = vat_json_array_add (&vam->json_tree);
9868 vat_json_init_object (node);
9869 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9871 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
9872 vat_json_object_add_ip6 (node, "host", ip6);
9876 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9878 unformat_input_t *i = vam->input;
9879 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9881 u8 sw_if_index_set = 0;
9882 u8 v6_address_set = 0;
9883 vl_api_prefix_t pfx;
9885 u8 no_advertise = 0;
9887 u8 no_autoconfig = 0;
9890 u32 val_lifetime = 0;
9891 u32 pref_lifetime = 0;
9894 /* Parse args required to build the message */
9895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9897 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9898 sw_if_index_set = 1;
9899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9903 else if (unformat (i, "val_life %d", &val_lifetime))
9905 else if (unformat (i, "pref_life %d", &pref_lifetime))
9907 else if (unformat (i, "def"))
9909 else if (unformat (i, "noadv"))
9911 else if (unformat (i, "offl"))
9913 else if (unformat (i, "noauto"))
9915 else if (unformat (i, "nolink"))
9917 else if (unformat (i, "isno"))
9921 clib_warning ("parse error '%U'", format_unformat_error, i);
9926 if (sw_if_index_set == 0)
9928 errmsg ("missing interface name or sw_if_index");
9931 if (!v6_address_set)
9933 errmsg ("no address set");
9937 /* Construct the API message */
9938 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9940 mp->sw_if_index = ntohl (sw_if_index);
9941 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
9942 mp->use_default = use_default;
9943 mp->no_advertise = no_advertise;
9944 mp->off_link = off_link;
9945 mp->no_autoconfig = no_autoconfig;
9946 mp->no_onlink = no_onlink;
9948 mp->val_lifetime = ntohl (val_lifetime);
9949 mp->pref_lifetime = ntohl (pref_lifetime);
9954 /* Wait for a reply, return good/bad news */
9960 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9962 unformat_input_t *i = vam->input;
9963 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9965 u8 sw_if_index_set = 0;
9970 u8 send_unicast = 0;
9973 u8 default_router = 0;
9974 u32 max_interval = 0;
9975 u32 min_interval = 0;
9977 u32 initial_count = 0;
9978 u32 initial_interval = 0;
9982 /* Parse args required to build the message */
9983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9985 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9986 sw_if_index_set = 1;
9987 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9988 sw_if_index_set = 1;
9989 else if (unformat (i, "maxint %d", &max_interval))
9991 else if (unformat (i, "minint %d", &min_interval))
9993 else if (unformat (i, "life %d", &lifetime))
9995 else if (unformat (i, "count %d", &initial_count))
9997 else if (unformat (i, "interval %d", &initial_interval))
9999 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10001 else if (unformat (i, "managed"))
10003 else if (unformat (i, "other"))
10005 else if (unformat (i, "ll"))
10007 else if (unformat (i, "send"))
10009 else if (unformat (i, "cease"))
10011 else if (unformat (i, "isno"))
10013 else if (unformat (i, "def"))
10014 default_router = 1;
10017 clib_warning ("parse error '%U'", format_unformat_error, i);
10022 if (sw_if_index_set == 0)
10024 errmsg ("missing interface name or sw_if_index");
10028 /* Construct the API message */
10029 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10031 mp->sw_if_index = ntohl (sw_if_index);
10032 mp->max_interval = ntohl (max_interval);
10033 mp->min_interval = ntohl (min_interval);
10034 mp->lifetime = ntohl (lifetime);
10035 mp->initial_count = ntohl (initial_count);
10036 mp->initial_interval = ntohl (initial_interval);
10037 mp->suppress = suppress;
10038 mp->managed = managed;
10040 mp->ll_option = ll_option;
10041 mp->send_unicast = send_unicast;
10044 mp->default_router = default_router;
10049 /* Wait for a reply, return good/bad news */
10055 api_set_arp_neighbor_limit (vat_main_t * vam)
10057 unformat_input_t *i = vam->input;
10058 vl_api_set_arp_neighbor_limit_t *mp;
10064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10066 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10068 else if (unformat (i, "ipv6"))
10072 clib_warning ("parse error '%U'", format_unformat_error, i);
10077 if (limit_set == 0)
10079 errmsg ("missing limit value");
10083 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10085 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10086 mp->is_ipv6 = is_ipv6;
10094 api_l2_patch_add_del (vat_main_t * vam)
10096 unformat_input_t *i = vam->input;
10097 vl_api_l2_patch_add_del_t *mp;
10098 u32 rx_sw_if_index;
10099 u8 rx_sw_if_index_set = 0;
10100 u32 tx_sw_if_index;
10101 u8 tx_sw_if_index_set = 0;
10105 /* Parse args required to build the message */
10106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10108 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10109 rx_sw_if_index_set = 1;
10110 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10111 tx_sw_if_index_set = 1;
10112 else if (unformat (i, "rx"))
10114 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10116 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10118 rx_sw_if_index_set = 1;
10123 else if (unformat (i, "tx"))
10125 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10127 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10129 tx_sw_if_index_set = 1;
10134 else if (unformat (i, "del"))
10140 if (rx_sw_if_index_set == 0)
10142 errmsg ("missing rx interface name or rx_sw_if_index");
10146 if (tx_sw_if_index_set == 0)
10148 errmsg ("missing tx interface name or tx_sw_if_index");
10152 M (L2_PATCH_ADD_DEL, mp);
10154 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10155 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10156 mp->is_add = is_add;
10164 u8 localsid_addr[16];
10173 api_sr_localsid_add_del (vat_main_t * vam)
10175 unformat_input_t *i = vam->input;
10176 vl_api_sr_localsid_add_del_t *mp;
10179 ip6_address_t localsid;
10183 u32 fib_table = ~(u32) 0;
10184 ip6_address_t nh_addr6;
10185 ip4_address_t nh_addr4;
10186 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10187 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10189 bool nexthop_set = 0;
10193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10195 if (unformat (i, "del"))
10197 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10198 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10200 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10202 else if (unformat (i, "behavior %u", &behavior));
10203 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10204 else if (unformat (i, "fib-table %u", &fib_table));
10205 else if (unformat (i, "end.psp %u", &behavior));
10210 M (SR_LOCALSID_ADD_DEL, mp);
10212 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10215 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10216 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10218 mp->behavior = behavior;
10219 mp->sw_if_index = ntohl (sw_if_index);
10220 mp->fib_table = ntohl (fib_table);
10221 mp->end_psp = end_psp;
10222 mp->is_del = is_del;
10230 api_ioam_enable (vat_main_t * vam)
10232 unformat_input_t *input = vam->input;
10233 vl_api_ioam_enable_t *mp;
10235 int has_trace_option = 0;
10236 int has_pot_option = 0;
10237 int has_seqno_option = 0;
10238 int has_analyse_option = 0;
10241 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10243 if (unformat (input, "trace"))
10244 has_trace_option = 1;
10245 else if (unformat (input, "pot"))
10246 has_pot_option = 1;
10247 else if (unformat (input, "seqno"))
10248 has_seqno_option = 1;
10249 else if (unformat (input, "analyse"))
10250 has_analyse_option = 1;
10254 M (IOAM_ENABLE, mp);
10255 mp->id = htons (id);
10256 mp->seqno = has_seqno_option;
10257 mp->analyse = has_analyse_option;
10258 mp->pot_enable = has_pot_option;
10259 mp->trace_enable = has_trace_option;
10268 api_ioam_disable (vat_main_t * vam)
10270 vl_api_ioam_disable_t *mp;
10273 M (IOAM_DISABLE, mp);
10279 #define foreach_tcp_proto_field \
10283 #define foreach_udp_proto_field \
10287 #define foreach_ip4_proto_field \
10299 u16 src_port, dst_port;
10302 #if VPP_API_TEST_BUILTIN == 0
10304 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10306 u8 **maskp = va_arg (*args, u8 **);
10308 u8 found_something = 0;
10311 #define _(a) u8 a=0;
10312 foreach_tcp_proto_field;
10315 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10318 #define _(a) else if (unformat (input, #a)) a=1;
10319 foreach_tcp_proto_field
10325 #define _(a) found_something += a;
10326 foreach_tcp_proto_field;
10329 if (found_something == 0)
10332 vec_validate (mask, sizeof (*tcp) - 1);
10334 tcp = (tcp_header_t *) mask;
10336 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10337 foreach_tcp_proto_field;
10345 unformat_udp_mask (unformat_input_t * input, va_list * args)
10347 u8 **maskp = va_arg (*args, u8 **);
10349 u8 found_something = 0;
10352 #define _(a) u8 a=0;
10353 foreach_udp_proto_field;
10356 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10359 #define _(a) else if (unformat (input, #a)) a=1;
10360 foreach_udp_proto_field
10366 #define _(a) found_something += a;
10367 foreach_udp_proto_field;
10370 if (found_something == 0)
10373 vec_validate (mask, sizeof (*udp) - 1);
10375 udp = (udp_header_t *) mask;
10377 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10378 foreach_udp_proto_field;
10386 unformat_l4_mask (unformat_input_t * input, va_list * args)
10388 u8 **maskp = va_arg (*args, u8 **);
10389 u16 src_port = 0, dst_port = 0;
10390 tcpudp_header_t *tcpudp;
10392 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10394 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10396 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10398 else if (unformat (input, "src_port"))
10400 else if (unformat (input, "dst_port"))
10406 if (!src_port && !dst_port)
10410 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10412 tcpudp = (tcpudp_header_t *) mask;
10413 tcpudp->src_port = src_port;
10414 tcpudp->dst_port = dst_port;
10422 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10424 u8 **maskp = va_arg (*args, u8 **);
10426 u8 found_something = 0;
10429 #define _(a) u8 a=0;
10430 foreach_ip4_proto_field;
10436 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10438 if (unformat (input, "version"))
10440 else if (unformat (input, "hdr_length"))
10442 else if (unformat (input, "src"))
10444 else if (unformat (input, "dst"))
10446 else if (unformat (input, "proto"))
10449 #define _(a) else if (unformat (input, #a)) a=1;
10450 foreach_ip4_proto_field
10456 #define _(a) found_something += a;
10457 foreach_ip4_proto_field;
10460 if (found_something == 0)
10463 vec_validate (mask, sizeof (*ip) - 1);
10465 ip = (ip4_header_t *) mask;
10467 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10468 foreach_ip4_proto_field;
10471 ip->ip_version_and_header_length = 0;
10474 ip->ip_version_and_header_length |= 0xF0;
10477 ip->ip_version_and_header_length |= 0x0F;
10483 #define foreach_ip6_proto_field \
10486 _(payload_length) \
10491 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10493 u8 **maskp = va_arg (*args, u8 **);
10495 u8 found_something = 0;
10497 u32 ip_version_traffic_class_and_flow_label;
10499 #define _(a) u8 a=0;
10500 foreach_ip6_proto_field;
10503 u8 traffic_class = 0;
10506 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10508 if (unformat (input, "version"))
10510 else if (unformat (input, "traffic-class"))
10512 else if (unformat (input, "flow-label"))
10514 else if (unformat (input, "src"))
10516 else if (unformat (input, "dst"))
10518 else if (unformat (input, "proto"))
10521 #define _(a) else if (unformat (input, #a)) a=1;
10522 foreach_ip6_proto_field
10528 #define _(a) found_something += a;
10529 foreach_ip6_proto_field;
10532 if (found_something == 0)
10535 vec_validate (mask, sizeof (*ip) - 1);
10537 ip = (ip6_header_t *) mask;
10539 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10540 foreach_ip6_proto_field;
10543 ip_version_traffic_class_and_flow_label = 0;
10546 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10549 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10552 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10554 ip->ip_version_traffic_class_and_flow_label =
10555 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10562 unformat_l3_mask (unformat_input_t * input, va_list * args)
10564 u8 **maskp = va_arg (*args, u8 **);
10566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10568 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10570 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10579 unformat_l2_mask (unformat_input_t * input, va_list * args)
10581 u8 **maskp = va_arg (*args, u8 **);
10588 u8 ignore_tag1 = 0;
10589 u8 ignore_tag2 = 0;
10596 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10598 if (unformat (input, "src"))
10600 else if (unformat (input, "dst"))
10602 else if (unformat (input, "proto"))
10604 else if (unformat (input, "tag1"))
10606 else if (unformat (input, "tag2"))
10608 else if (unformat (input, "ignore-tag1"))
10610 else if (unformat (input, "ignore-tag2"))
10612 else if (unformat (input, "cos1"))
10614 else if (unformat (input, "cos2"))
10616 else if (unformat (input, "dot1q"))
10618 else if (unformat (input, "dot1ad"))
10623 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10624 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10627 if (tag1 || ignore_tag1 || cos1 || dot1q)
10629 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10632 vec_validate (mask, len - 1);
10635 clib_memset (mask, 0xff, 6);
10638 clib_memset (mask + 6, 0xff, 6);
10640 if (tag2 || dot1ad)
10642 /* inner vlan tag */
10651 mask[21] = mask[20] = 0xff;
10672 mask[16] = mask[17] = 0xff;
10682 mask[12] = mask[13] = 0xff;
10689 unformat_classify_mask (unformat_input_t * input, va_list * args)
10691 u8 **maskp = va_arg (*args, u8 **);
10692 u32 *skipp = va_arg (*args, u32 *);
10693 u32 *matchp = va_arg (*args, u32 *);
10701 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10703 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10705 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10707 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10709 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10723 if (mask || l2 || l3 || l4)
10725 if (l2 || l3 || l4)
10727 /* "With a free Ethernet header in every package" */
10729 vec_validate (l2, 13);
10733 vec_append (mask, l3);
10738 vec_append (mask, l4);
10743 /* Scan forward looking for the first significant mask octet */
10744 for (i = 0; i < vec_len (mask); i++)
10748 /* compute (skip, match) params */
10749 *skipp = i / sizeof (u32x4);
10750 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10752 /* Pad mask to an even multiple of the vector size */
10753 while (vec_len (mask) % sizeof (u32x4))
10754 vec_add1 (mask, 0);
10756 match = vec_len (mask) / sizeof (u32x4);
10758 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10760 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10761 if (*tmp || *(tmp + 1))
10766 clib_warning ("BUG: match 0");
10768 _vec_len (mask) = match * sizeof (u32x4);
10778 #endif /* VPP_API_TEST_BUILTIN */
10780 #define foreach_l2_next \
10782 _(ethernet, ETHERNET_INPUT) \
10783 _(ip4, IP4_INPUT) \
10787 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10789 u32 *miss_next_indexp = va_arg (*args, u32 *);
10790 u32 next_index = 0;
10794 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10798 if (unformat (input, "%d", &tmp))
10807 *miss_next_indexp = next_index;
10811 #define foreach_ip_next \
10814 _(rewrite, REWRITE)
10817 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10819 u32 *miss_next_indexp = va_arg (*args, u32 *);
10820 u32 next_index = 0;
10824 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10828 if (unformat (input, "%d", &tmp))
10837 *miss_next_indexp = next_index;
10841 #define foreach_acl_next \
10845 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10847 u32 *miss_next_indexp = va_arg (*args, u32 *);
10848 u32 next_index = 0;
10852 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10856 if (unformat (input, "permit"))
10861 else if (unformat (input, "%d", &tmp))
10870 *miss_next_indexp = next_index;
10875 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10877 u32 *r = va_arg (*args, u32 *);
10879 if (unformat (input, "conform-color"))
10880 *r = POLICE_CONFORM;
10881 else if (unformat (input, "exceed-color"))
10882 *r = POLICE_EXCEED;
10890 api_classify_add_del_table (vat_main_t * vam)
10892 unformat_input_t *i = vam->input;
10893 vl_api_classify_add_del_table_t *mp;
10900 u32 table_index = ~0;
10901 u32 next_table_index = ~0;
10902 u32 miss_next_index = ~0;
10903 u32 memory_size = 32 << 20;
10905 u32 current_data_flag = 0;
10906 int current_data_offset = 0;
10909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10911 if (unformat (i, "del"))
10913 else if (unformat (i, "del-chain"))
10918 else if (unformat (i, "buckets %d", &nbuckets))
10920 else if (unformat (i, "memory_size %d", &memory_size))
10922 else if (unformat (i, "skip %d", &skip))
10924 else if (unformat (i, "match %d", &match))
10926 else if (unformat (i, "table %d", &table_index))
10928 else if (unformat (i, "mask %U", unformat_classify_mask,
10929 &mask, &skip, &match))
10931 else if (unformat (i, "next-table %d", &next_table_index))
10933 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10936 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10939 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10942 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10944 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10950 if (is_add && mask == 0)
10952 errmsg ("Mask required");
10956 if (is_add && skip == ~0)
10958 errmsg ("skip count required");
10962 if (is_add && match == ~0)
10964 errmsg ("match count required");
10968 if (!is_add && table_index == ~0)
10970 errmsg ("table index required for delete");
10974 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10976 mp->is_add = is_add;
10977 mp->del_chain = del_chain;
10978 mp->table_index = ntohl (table_index);
10979 mp->nbuckets = ntohl (nbuckets);
10980 mp->memory_size = ntohl (memory_size);
10981 mp->skip_n_vectors = ntohl (skip);
10982 mp->match_n_vectors = ntohl (match);
10983 mp->next_table_index = ntohl (next_table_index);
10984 mp->miss_next_index = ntohl (miss_next_index);
10985 mp->current_data_flag = ntohl (current_data_flag);
10986 mp->current_data_offset = ntohl (current_data_offset);
10987 mp->mask_len = ntohl (vec_len (mask));
10988 clib_memcpy (mp->mask, mask, vec_len (mask));
10997 #if VPP_API_TEST_BUILTIN == 0
10999 unformat_l4_match (unformat_input_t * input, va_list * args)
11001 u8 **matchp = va_arg (*args, u8 **);
11003 u8 *proto_header = 0;
11009 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11011 if (unformat (input, "src_port %d", &src_port))
11013 else if (unformat (input, "dst_port %d", &dst_port))
11019 h.src_port = clib_host_to_net_u16 (src_port);
11020 h.dst_port = clib_host_to_net_u16 (dst_port);
11021 vec_validate (proto_header, sizeof (h) - 1);
11022 memcpy (proto_header, &h, sizeof (h));
11024 *matchp = proto_header;
11030 unformat_ip4_match (unformat_input_t * input, va_list * args)
11032 u8 **matchp = va_arg (*args, u8 **);
11037 int hdr_length = 0;
11038 u32 hdr_length_val;
11039 int src = 0, dst = 0;
11040 ip4_address_t src_val, dst_val;
11047 int fragment_id = 0;
11048 u32 fragment_id_val;
11054 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11056 if (unformat (input, "version %d", &version_val))
11058 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11060 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11062 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11064 else if (unformat (input, "proto %d", &proto_val))
11066 else if (unformat (input, "tos %d", &tos_val))
11068 else if (unformat (input, "length %d", &length_val))
11070 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11072 else if (unformat (input, "ttl %d", &ttl_val))
11074 else if (unformat (input, "checksum %d", &checksum_val))
11080 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11081 + ttl + checksum == 0)
11085 * Aligned because we use the real comparison functions
11087 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11089 ip = (ip4_header_t *) match;
11091 /* These are realistically matched in practice */
11093 ip->src_address.as_u32 = src_val.as_u32;
11096 ip->dst_address.as_u32 = dst_val.as_u32;
11099 ip->protocol = proto_val;
11102 /* These are not, but they're included for completeness */
11104 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11107 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11113 ip->length = clib_host_to_net_u16 (length_val);
11119 ip->checksum = clib_host_to_net_u16 (checksum_val);
11126 unformat_ip6_match (unformat_input_t * input, va_list * args)
11128 u8 **matchp = va_arg (*args, u8 **);
11133 u8 traffic_class = 0;
11134 u32 traffic_class_val = 0;
11137 int src = 0, dst = 0;
11138 ip6_address_t src_val, dst_val;
11141 int payload_length = 0;
11142 u32 payload_length_val;
11145 u32 ip_version_traffic_class_and_flow_label;
11147 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11149 if (unformat (input, "version %d", &version_val))
11151 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11153 else if (unformat (input, "flow_label %d", &flow_label_val))
11155 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11157 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11159 else if (unformat (input, "proto %d", &proto_val))
11161 else if (unformat (input, "payload_length %d", &payload_length_val))
11162 payload_length = 1;
11163 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11169 if (version + traffic_class + flow_label + src + dst + proto +
11170 payload_length + hop_limit == 0)
11174 * Aligned because we use the real comparison functions
11176 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11178 ip = (ip6_header_t *) match;
11181 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11184 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11187 ip->protocol = proto_val;
11189 ip_version_traffic_class_and_flow_label = 0;
11192 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11195 ip_version_traffic_class_and_flow_label |=
11196 (traffic_class_val & 0xFF) << 20;
11199 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11201 ip->ip_version_traffic_class_and_flow_label =
11202 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11204 if (payload_length)
11205 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11208 ip->hop_limit = hop_limit_val;
11215 unformat_l3_match (unformat_input_t * input, va_list * args)
11217 u8 **matchp = va_arg (*args, u8 **);
11219 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11221 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11223 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11232 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11234 u8 *tagp = va_arg (*args, u8 *);
11237 if (unformat (input, "%d", &tag))
11239 tagp[0] = (tag >> 8) & 0x0F;
11240 tagp[1] = tag & 0xFF;
11248 unformat_l2_match (unformat_input_t * input, va_list * args)
11250 u8 **matchp = va_arg (*args, u8 **);
11263 u8 ignore_tag1 = 0;
11264 u8 ignore_tag2 = 0;
11270 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11272 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11275 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11277 else if (unformat (input, "proto %U",
11278 unformat_ethernet_type_host_byte_order, &proto_val))
11280 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11282 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11284 else if (unformat (input, "ignore-tag1"))
11286 else if (unformat (input, "ignore-tag2"))
11288 else if (unformat (input, "cos1 %d", &cos1_val))
11290 else if (unformat (input, "cos2 %d", &cos2_val))
11295 if ((src + dst + proto + tag1 + tag2 +
11296 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11299 if (tag1 || ignore_tag1 || cos1)
11301 if (tag2 || ignore_tag2 || cos2)
11304 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11307 clib_memcpy (match, dst_val, 6);
11310 clib_memcpy (match + 6, src_val, 6);
11314 /* inner vlan tag */
11315 match[19] = tag2_val[1];
11316 match[18] = tag2_val[0];
11318 match[18] |= (cos2_val & 0x7) << 5;
11321 match[21] = proto_val & 0xff;
11322 match[20] = proto_val >> 8;
11326 match[15] = tag1_val[1];
11327 match[14] = tag1_val[0];
11330 match[14] |= (cos1_val & 0x7) << 5;
11336 match[15] = tag1_val[1];
11337 match[14] = tag1_val[0];
11340 match[17] = proto_val & 0xff;
11341 match[16] = proto_val >> 8;
11344 match[14] |= (cos1_val & 0x7) << 5;
11350 match[18] |= (cos2_val & 0x7) << 5;
11352 match[14] |= (cos1_val & 0x7) << 5;
11355 match[13] = proto_val & 0xff;
11356 match[12] = proto_val >> 8;
11364 unformat_qos_source (unformat_input_t * input, va_list * args)
11366 int *qs = va_arg (*args, int *);
11368 if (unformat (input, "ip"))
11369 *qs = QOS_SOURCE_IP;
11370 else if (unformat (input, "mpls"))
11371 *qs = QOS_SOURCE_MPLS;
11372 else if (unformat (input, "ext"))
11373 *qs = QOS_SOURCE_EXT;
11374 else if (unformat (input, "vlan"))
11375 *qs = QOS_SOURCE_VLAN;
11384 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11386 u8 **matchp = va_arg (*args, u8 **);
11387 u32 skip_n_vectors = va_arg (*args, u32);
11388 u32 match_n_vectors = va_arg (*args, u32);
11395 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11397 if (unformat (input, "hex %U", unformat_hex_string, &match))
11399 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11401 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11403 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11417 if (match || l2 || l3 || l4)
11419 if (l2 || l3 || l4)
11421 /* "Win a free Ethernet header in every packet" */
11423 vec_validate_aligned (l2, 13, sizeof (u32x4));
11427 vec_append_aligned (match, l3, sizeof (u32x4));
11432 vec_append_aligned (match, l4, sizeof (u32x4));
11437 /* Make sure the vector is big enough even if key is all 0's */
11438 vec_validate_aligned
11439 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11442 /* Set size, include skipped vectors */
11443 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11454 api_classify_add_del_session (vat_main_t * vam)
11456 unformat_input_t *i = vam->input;
11457 vl_api_classify_add_del_session_t *mp;
11459 u32 table_index = ~0;
11460 u32 hit_next_index = ~0;
11461 u32 opaque_index = ~0;
11464 u32 skip_n_vectors = 0;
11465 u32 match_n_vectors = 0;
11471 * Warning: you have to supply skip_n and match_n
11472 * because the API client cant simply look at the classify
11476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11478 if (unformat (i, "del"))
11480 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11483 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11486 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11489 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11491 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11493 else if (unformat (i, "opaque-index %d", &opaque_index))
11495 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11497 else if (unformat (i, "match_n %d", &match_n_vectors))
11499 else if (unformat (i, "match %U", api_unformat_classify_match,
11500 &match, skip_n_vectors, match_n_vectors))
11502 else if (unformat (i, "advance %d", &advance))
11504 else if (unformat (i, "table-index %d", &table_index))
11506 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11508 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11510 else if (unformat (i, "action %d", &action))
11512 else if (unformat (i, "metadata %d", &metadata))
11518 if (table_index == ~0)
11520 errmsg ("Table index required");
11524 if (is_add && match == 0)
11526 errmsg ("Match value required");
11530 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11532 mp->is_add = is_add;
11533 mp->table_index = ntohl (table_index);
11534 mp->hit_next_index = ntohl (hit_next_index);
11535 mp->opaque_index = ntohl (opaque_index);
11536 mp->advance = ntohl (advance);
11537 mp->action = action;
11538 mp->metadata = ntohl (metadata);
11539 mp->match_len = ntohl (vec_len (match));
11540 clib_memcpy (mp->match, match, vec_len (match));
11549 api_classify_set_interface_ip_table (vat_main_t * vam)
11551 unformat_input_t *i = vam->input;
11552 vl_api_classify_set_interface_ip_table_t *mp;
11554 int sw_if_index_set;
11555 u32 table_index = ~0;
11559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11561 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11562 sw_if_index_set = 1;
11563 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11564 sw_if_index_set = 1;
11565 else if (unformat (i, "table %d", &table_index))
11569 clib_warning ("parse error '%U'", format_unformat_error, i);
11574 if (sw_if_index_set == 0)
11576 errmsg ("missing interface name or sw_if_index");
11581 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11583 mp->sw_if_index = ntohl (sw_if_index);
11584 mp->table_index = ntohl (table_index);
11585 mp->is_ipv6 = is_ipv6;
11593 api_classify_set_interface_l2_tables (vat_main_t * vam)
11595 unformat_input_t *i = vam->input;
11596 vl_api_classify_set_interface_l2_tables_t *mp;
11598 int sw_if_index_set;
11599 u32 ip4_table_index = ~0;
11600 u32 ip6_table_index = ~0;
11601 u32 other_table_index = ~0;
11605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11607 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11608 sw_if_index_set = 1;
11609 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11610 sw_if_index_set = 1;
11611 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11613 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11615 else if (unformat (i, "other-table %d", &other_table_index))
11617 else if (unformat (i, "is-input %d", &is_input))
11621 clib_warning ("parse error '%U'", format_unformat_error, i);
11626 if (sw_if_index_set == 0)
11628 errmsg ("missing interface name or sw_if_index");
11633 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11635 mp->sw_if_index = ntohl (sw_if_index);
11636 mp->ip4_table_index = ntohl (ip4_table_index);
11637 mp->ip6_table_index = ntohl (ip6_table_index);
11638 mp->other_table_index = ntohl (other_table_index);
11639 mp->is_input = (u8) is_input;
11647 api_set_ipfix_exporter (vat_main_t * vam)
11649 unformat_input_t *i = vam->input;
11650 vl_api_set_ipfix_exporter_t *mp;
11651 ip4_address_t collector_address;
11652 u8 collector_address_set = 0;
11653 u32 collector_port = ~0;
11654 ip4_address_t src_address;
11655 u8 src_address_set = 0;
11658 u32 template_interval = ~0;
11659 u8 udp_checksum = 0;
11662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11664 if (unformat (i, "collector_address %U", unformat_ip4_address,
11665 &collector_address))
11666 collector_address_set = 1;
11667 else if (unformat (i, "collector_port %d", &collector_port))
11669 else if (unformat (i, "src_address %U", unformat_ip4_address,
11671 src_address_set = 1;
11672 else if (unformat (i, "vrf_id %d", &vrf_id))
11674 else if (unformat (i, "path_mtu %d", &path_mtu))
11676 else if (unformat (i, "template_interval %d", &template_interval))
11678 else if (unformat (i, "udp_checksum"))
11684 if (collector_address_set == 0)
11686 errmsg ("collector_address required");
11690 if (src_address_set == 0)
11692 errmsg ("src_address required");
11696 M (SET_IPFIX_EXPORTER, mp);
11698 memcpy (mp->collector_address, collector_address.data,
11699 sizeof (collector_address.data));
11700 mp->collector_port = htons ((u16) collector_port);
11701 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11702 mp->vrf_id = htonl (vrf_id);
11703 mp->path_mtu = htonl (path_mtu);
11704 mp->template_interval = htonl (template_interval);
11705 mp->udp_checksum = udp_checksum;
11713 api_set_ipfix_classify_stream (vat_main_t * vam)
11715 unformat_input_t *i = vam->input;
11716 vl_api_set_ipfix_classify_stream_t *mp;
11718 u32 src_port = UDP_DST_PORT_ipfix;
11721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11723 if (unformat (i, "domain %d", &domain_id))
11725 else if (unformat (i, "src_port %d", &src_port))
11729 errmsg ("unknown input `%U'", format_unformat_error, i);
11734 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11736 mp->domain_id = htonl (domain_id);
11737 mp->src_port = htons ((u16) src_port);
11745 api_ipfix_classify_table_add_del (vat_main_t * vam)
11747 unformat_input_t *i = vam->input;
11748 vl_api_ipfix_classify_table_add_del_t *mp;
11750 u32 classify_table_index = ~0;
11752 u8 transport_protocol = 255;
11755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11757 if (unformat (i, "add"))
11759 else if (unformat (i, "del"))
11761 else if (unformat (i, "table %d", &classify_table_index))
11763 else if (unformat (i, "ip4"))
11765 else if (unformat (i, "ip6"))
11767 else if (unformat (i, "tcp"))
11768 transport_protocol = 6;
11769 else if (unformat (i, "udp"))
11770 transport_protocol = 17;
11773 errmsg ("unknown input `%U'", format_unformat_error, i);
11780 errmsg ("expecting: add|del");
11783 if (classify_table_index == ~0)
11785 errmsg ("classifier table not specified");
11788 if (ip_version == 0)
11790 errmsg ("IP version not specified");
11794 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11796 mp->is_add = is_add;
11797 mp->table_id = htonl (classify_table_index);
11798 mp->ip_version = ip_version;
11799 mp->transport_protocol = transport_protocol;
11807 api_get_node_index (vat_main_t * vam)
11809 unformat_input_t *i = vam->input;
11810 vl_api_get_node_index_t *mp;
11814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11816 if (unformat (i, "node %s", &name))
11823 errmsg ("node name required");
11826 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11828 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11832 M (GET_NODE_INDEX, mp);
11833 clib_memcpy (mp->node_name, name, vec_len (name));
11842 api_get_next_index (vat_main_t * vam)
11844 unformat_input_t *i = vam->input;
11845 vl_api_get_next_index_t *mp;
11846 u8 *node_name = 0, *next_node_name = 0;
11849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11851 if (unformat (i, "node-name %s", &node_name))
11853 else if (unformat (i, "next-node-name %s", &next_node_name))
11857 if (node_name == 0)
11859 errmsg ("node name required");
11862 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11864 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11868 if (next_node_name == 0)
11870 errmsg ("next node name required");
11873 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11875 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11879 M (GET_NEXT_INDEX, mp);
11880 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11881 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11882 vec_free (node_name);
11883 vec_free (next_node_name);
11891 api_add_node_next (vat_main_t * vam)
11893 unformat_input_t *i = vam->input;
11894 vl_api_add_node_next_t *mp;
11899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11901 if (unformat (i, "node %s", &name))
11903 else if (unformat (i, "next %s", &next))
11910 errmsg ("node name required");
11913 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11915 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11920 errmsg ("next node required");
11923 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11925 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11929 M (ADD_NODE_NEXT, mp);
11930 clib_memcpy (mp->node_name, name, vec_len (name));
11931 clib_memcpy (mp->next_name, next, vec_len (next));
11941 api_l2tpv3_create_tunnel (vat_main_t * vam)
11943 unformat_input_t *i = vam->input;
11944 ip6_address_t client_address, our_address;
11945 int client_address_set = 0;
11946 int our_address_set = 0;
11947 u32 local_session_id = 0;
11948 u32 remote_session_id = 0;
11949 u64 local_cookie = 0;
11950 u64 remote_cookie = 0;
11951 u8 l2_sublayer_present = 0;
11952 vl_api_l2tpv3_create_tunnel_t *mp;
11955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11957 if (unformat (i, "client_address %U", unformat_ip6_address,
11959 client_address_set = 1;
11960 else if (unformat (i, "our_address %U", unformat_ip6_address,
11962 our_address_set = 1;
11963 else if (unformat (i, "local_session_id %d", &local_session_id))
11965 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11967 else if (unformat (i, "local_cookie %lld", &local_cookie))
11969 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11971 else if (unformat (i, "l2-sublayer-present"))
11972 l2_sublayer_present = 1;
11977 if (client_address_set == 0)
11979 errmsg ("client_address required");
11983 if (our_address_set == 0)
11985 errmsg ("our_address required");
11989 M (L2TPV3_CREATE_TUNNEL, mp);
11991 clib_memcpy (mp->client_address, client_address.as_u8,
11992 sizeof (mp->client_address));
11994 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11996 mp->local_session_id = ntohl (local_session_id);
11997 mp->remote_session_id = ntohl (remote_session_id);
11998 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11999 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12000 mp->l2_sublayer_present = l2_sublayer_present;
12009 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12011 unformat_input_t *i = vam->input;
12013 u8 sw_if_index_set = 0;
12014 u64 new_local_cookie = 0;
12015 u64 new_remote_cookie = 0;
12016 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12021 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12022 sw_if_index_set = 1;
12023 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12024 sw_if_index_set = 1;
12025 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12027 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12033 if (sw_if_index_set == 0)
12035 errmsg ("missing interface name or sw_if_index");
12039 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12041 mp->sw_if_index = ntohl (sw_if_index);
12042 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12043 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12051 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12053 unformat_input_t *i = vam->input;
12054 vl_api_l2tpv3_interface_enable_disable_t *mp;
12056 u8 sw_if_index_set = 0;
12057 u8 enable_disable = 1;
12060 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12062 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12063 sw_if_index_set = 1;
12064 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12065 sw_if_index_set = 1;
12066 else if (unformat (i, "enable"))
12067 enable_disable = 1;
12068 else if (unformat (i, "disable"))
12069 enable_disable = 0;
12074 if (sw_if_index_set == 0)
12076 errmsg ("missing interface name or sw_if_index");
12080 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12082 mp->sw_if_index = ntohl (sw_if_index);
12083 mp->enable_disable = enable_disable;
12091 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12093 unformat_input_t *i = vam->input;
12094 vl_api_l2tpv3_set_lookup_key_t *mp;
12098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12100 if (unformat (i, "lookup_v6_src"))
12101 key = L2T_LOOKUP_SRC_ADDRESS;
12102 else if (unformat (i, "lookup_v6_dst"))
12103 key = L2T_LOOKUP_DST_ADDRESS;
12104 else if (unformat (i, "lookup_session_id"))
12105 key = L2T_LOOKUP_SESSION_ID;
12110 if (key == (u8) ~ 0)
12112 errmsg ("l2tp session lookup key unset");
12116 M (L2TPV3_SET_LOOKUP_KEY, mp);
12125 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12126 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12128 vat_main_t *vam = &vat_main;
12130 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12131 format_ip6_address, mp->our_address,
12132 format_ip6_address, mp->client_address,
12133 clib_net_to_host_u32 (mp->sw_if_index));
12136 " local cookies %016llx %016llx remote cookie %016llx",
12137 clib_net_to_host_u64 (mp->local_cookie[0]),
12138 clib_net_to_host_u64 (mp->local_cookie[1]),
12139 clib_net_to_host_u64 (mp->remote_cookie));
12141 print (vam->ofp, " local session-id %d remote session-id %d",
12142 clib_net_to_host_u32 (mp->local_session_id),
12143 clib_net_to_host_u32 (mp->remote_session_id));
12145 print (vam->ofp, " l2 specific sublayer %s\n",
12146 mp->l2_sublayer_present ? "preset" : "absent");
12150 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12151 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12153 vat_main_t *vam = &vat_main;
12154 vat_json_node_t *node = NULL;
12155 struct in6_addr addr;
12157 if (VAT_JSON_ARRAY != vam->json_tree.type)
12159 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12160 vat_json_init_array (&vam->json_tree);
12162 node = vat_json_array_add (&vam->json_tree);
12164 vat_json_init_object (node);
12166 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12167 vat_json_object_add_ip6 (node, "our_address", addr);
12168 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12169 vat_json_object_add_ip6 (node, "client_address", addr);
12171 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12172 vat_json_init_array (lc);
12173 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12174 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12175 vat_json_object_add_uint (node, "remote_cookie",
12176 clib_net_to_host_u64 (mp->remote_cookie));
12178 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12179 vat_json_object_add_uint (node, "local_session_id",
12180 clib_net_to_host_u32 (mp->local_session_id));
12181 vat_json_object_add_uint (node, "remote_session_id",
12182 clib_net_to_host_u32 (mp->remote_session_id));
12183 vat_json_object_add_string_copy (node, "l2_sublayer",
12184 mp->l2_sublayer_present ? (u8 *) "present"
12185 : (u8 *) "absent");
12189 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12191 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12192 vl_api_control_ping_t *mp_ping;
12195 /* Get list of l2tpv3-tunnel interfaces */
12196 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12199 /* Use a control ping for synchronization */
12200 MPING (CONTROL_PING, mp_ping);
12208 static void vl_api_sw_interface_tap_v2_details_t_handler
12209 (vl_api_sw_interface_tap_v2_details_t * mp)
12211 vat_main_t *vam = &vat_main;
12213 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12214 mp->host_ip4_prefix_len);
12215 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12216 mp->host_ip6_prefix_len);
12219 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12220 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12221 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12222 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12223 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12229 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12230 (vl_api_sw_interface_tap_v2_details_t * mp)
12232 vat_main_t *vam = &vat_main;
12233 vat_json_node_t *node = NULL;
12235 if (VAT_JSON_ARRAY != vam->json_tree.type)
12237 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12238 vat_json_init_array (&vam->json_tree);
12240 node = vat_json_array_add (&vam->json_tree);
12242 vat_json_init_object (node);
12243 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12244 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12245 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12246 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12247 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12248 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12249 vat_json_object_add_string_copy (node, "host_mac_addr",
12250 format (0, "%U", format_ethernet_address,
12251 &mp->host_mac_addr));
12252 vat_json_object_add_string_copy (node, "host_namespace",
12253 mp->host_namespace);
12254 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12255 vat_json_object_add_string_copy (node, "host_ip4_addr",
12256 format (0, "%U/%d", format_ip4_address,
12258 mp->host_ip4_prefix_len));
12259 vat_json_object_add_string_copy (node, "host_ip6_addr",
12260 format (0, "%U/%d", format_ip6_address,
12262 mp->host_ip6_prefix_len));
12267 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12269 vl_api_sw_interface_tap_v2_dump_t *mp;
12270 vl_api_control_ping_t *mp_ping;
12274 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12275 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12276 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12279 /* Get list of tap interfaces */
12280 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12283 /* Use a control ping for synchronization */
12284 MPING (CONTROL_PING, mp_ping);
12291 static void vl_api_sw_interface_virtio_pci_details_t_handler
12292 (vl_api_sw_interface_virtio_pci_details_t * mp)
12294 vat_main_t *vam = &vat_main;
12308 addr.as_u32 = ntohl (mp->pci_addr);
12309 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12310 addr.slot, addr.function);
12313 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12314 pci_addr, ntohl (mp->sw_if_index),
12315 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12316 format_ethernet_address, mp->mac_addr,
12317 clib_net_to_host_u64 (mp->features));
12318 vec_free (pci_addr);
12321 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12322 (vl_api_sw_interface_virtio_pci_details_t * mp)
12324 vat_main_t *vam = &vat_main;
12325 vat_json_node_t *node = NULL;
12327 if (VAT_JSON_ARRAY != vam->json_tree.type)
12329 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12330 vat_json_init_array (&vam->json_tree);
12332 node = vat_json_array_add (&vam->json_tree);
12334 vat_json_init_object (node);
12335 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12336 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12337 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12338 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12339 vat_json_object_add_uint (node, "features",
12340 clib_net_to_host_u64 (mp->features));
12341 vat_json_object_add_string_copy (node, "mac_addr",
12342 format (0, "%U", format_ethernet_address,
12347 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12349 vl_api_sw_interface_virtio_pci_dump_t *mp;
12350 vl_api_control_ping_t *mp_ping;
12354 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12355 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12356 "mac_addr", "features");
12358 /* Get list of tap interfaces */
12359 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12362 /* Use a control ping for synchronization */
12363 MPING (CONTROL_PING, mp_ping);
12371 api_vxlan_offload_rx (vat_main_t * vam)
12373 unformat_input_t *line_input = vam->input;
12374 vl_api_vxlan_offload_rx_t *mp;
12375 u32 hw_if_index = ~0, rx_if_index = ~0;
12379 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12381 if (unformat (line_input, "del"))
12383 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12386 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12388 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12391 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12395 errmsg ("parse error '%U'", format_unformat_error, line_input);
12400 if (hw_if_index == ~0)
12402 errmsg ("no hw interface");
12406 if (rx_if_index == ~0)
12408 errmsg ("no rx tunnel");
12412 M (VXLAN_OFFLOAD_RX, mp);
12414 mp->hw_if_index = ntohl (hw_if_index);
12415 mp->sw_if_index = ntohl (rx_if_index);
12416 mp->enable = is_add;
12423 static uword unformat_vxlan_decap_next
12424 (unformat_input_t * input, va_list * args)
12426 u32 *result = va_arg (*args, u32 *);
12429 if (unformat (input, "l2"))
12430 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12431 else if (unformat (input, "%d", &tmp))
12439 api_vxlan_add_del_tunnel (vat_main_t * vam)
12441 unformat_input_t *line_input = vam->input;
12442 vl_api_vxlan_add_del_tunnel_t *mp;
12443 ip46_address_t src, dst;
12445 u8 ipv4_set = 0, ipv6_set = 0;
12450 u32 mcast_sw_if_index = ~0;
12451 u32 encap_vrf_id = 0;
12452 u32 decap_next_index = ~0;
12456 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12457 clib_memset (&src, 0, sizeof src);
12458 clib_memset (&dst, 0, sizeof dst);
12460 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12462 if (unformat (line_input, "del"))
12464 else if (unformat (line_input, "instance %d", &instance))
12467 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12473 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12479 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12485 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12490 else if (unformat (line_input, "group %U %U",
12491 unformat_ip4_address, &dst.ip4,
12492 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12494 grp_set = dst_set = 1;
12497 else if (unformat (line_input, "group %U",
12498 unformat_ip4_address, &dst.ip4))
12500 grp_set = dst_set = 1;
12503 else if (unformat (line_input, "group %U %U",
12504 unformat_ip6_address, &dst.ip6,
12505 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12507 grp_set = dst_set = 1;
12510 else if (unformat (line_input, "group %U",
12511 unformat_ip6_address, &dst.ip6))
12513 grp_set = dst_set = 1;
12517 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12519 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12521 else if (unformat (line_input, "decap-next %U",
12522 unformat_vxlan_decap_next, &decap_next_index))
12524 else if (unformat (line_input, "vni %d", &vni))
12528 errmsg ("parse error '%U'", format_unformat_error, line_input);
12535 errmsg ("tunnel src address not specified");
12540 errmsg ("tunnel dst address not specified");
12544 if (grp_set && !ip46_address_is_multicast (&dst))
12546 errmsg ("tunnel group address not multicast");
12549 if (grp_set && mcast_sw_if_index == ~0)
12551 errmsg ("tunnel nonexistent multicast device");
12554 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12556 errmsg ("tunnel dst address must be unicast");
12561 if (ipv4_set && ipv6_set)
12563 errmsg ("both IPv4 and IPv6 addresses specified");
12567 if ((vni == 0) || (vni >> 24))
12569 errmsg ("vni not specified or out of range");
12573 M (VXLAN_ADD_DEL_TUNNEL, mp);
12577 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12578 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12582 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12583 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12586 mp->instance = htonl (instance);
12587 mp->encap_vrf_id = ntohl (encap_vrf_id);
12588 mp->decap_next_index = ntohl (decap_next_index);
12589 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12590 mp->vni = ntohl (vni);
12591 mp->is_add = is_add;
12592 mp->is_ipv6 = ipv6_set;
12599 static void vl_api_vxlan_tunnel_details_t_handler
12600 (vl_api_vxlan_tunnel_details_t * mp)
12602 vat_main_t *vam = &vat_main;
12603 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12604 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12606 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12607 ntohl (mp->sw_if_index),
12608 ntohl (mp->instance),
12609 format_ip46_address, &src, IP46_TYPE_ANY,
12610 format_ip46_address, &dst, IP46_TYPE_ANY,
12611 ntohl (mp->encap_vrf_id),
12612 ntohl (mp->decap_next_index), ntohl (mp->vni),
12613 ntohl (mp->mcast_sw_if_index));
12616 static void vl_api_vxlan_tunnel_details_t_handler_json
12617 (vl_api_vxlan_tunnel_details_t * mp)
12619 vat_main_t *vam = &vat_main;
12620 vat_json_node_t *node = NULL;
12622 if (VAT_JSON_ARRAY != vam->json_tree.type)
12624 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12625 vat_json_init_array (&vam->json_tree);
12627 node = vat_json_array_add (&vam->json_tree);
12629 vat_json_init_object (node);
12630 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12632 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12636 struct in6_addr ip6;
12638 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12639 vat_json_object_add_ip6 (node, "src_address", ip6);
12640 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12641 vat_json_object_add_ip6 (node, "dst_address", ip6);
12645 struct in_addr ip4;
12647 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12648 vat_json_object_add_ip4 (node, "src_address", ip4);
12649 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12650 vat_json_object_add_ip4 (node, "dst_address", ip4);
12652 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12653 vat_json_object_add_uint (node, "decap_next_index",
12654 ntohl (mp->decap_next_index));
12655 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12656 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12657 vat_json_object_add_uint (node, "mcast_sw_if_index",
12658 ntohl (mp->mcast_sw_if_index));
12662 api_vxlan_tunnel_dump (vat_main_t * vam)
12664 unformat_input_t *i = vam->input;
12665 vl_api_vxlan_tunnel_dump_t *mp;
12666 vl_api_control_ping_t *mp_ping;
12668 u8 sw_if_index_set = 0;
12671 /* Parse args required to build the message */
12672 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12674 if (unformat (i, "sw_if_index %d", &sw_if_index))
12675 sw_if_index_set = 1;
12680 if (sw_if_index_set == 0)
12685 if (!vam->json_output)
12687 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12688 "sw_if_index", "instance", "src_address", "dst_address",
12689 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12692 /* Get list of vxlan-tunnel interfaces */
12693 M (VXLAN_TUNNEL_DUMP, mp);
12695 mp->sw_if_index = htonl (sw_if_index);
12699 /* Use a control ping for synchronization */
12700 MPING (CONTROL_PING, mp_ping);
12707 static uword unformat_geneve_decap_next
12708 (unformat_input_t * input, va_list * args)
12710 u32 *result = va_arg (*args, u32 *);
12713 if (unformat (input, "l2"))
12714 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12715 else if (unformat (input, "%d", &tmp))
12723 api_geneve_add_del_tunnel (vat_main_t * vam)
12725 unformat_input_t *line_input = vam->input;
12726 vl_api_geneve_add_del_tunnel_t *mp;
12727 ip46_address_t src, dst;
12729 u8 ipv4_set = 0, ipv6_set = 0;
12733 u32 mcast_sw_if_index = ~0;
12734 u32 encap_vrf_id = 0;
12735 u32 decap_next_index = ~0;
12739 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12740 clib_memset (&src, 0, sizeof src);
12741 clib_memset (&dst, 0, sizeof dst);
12743 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12745 if (unformat (line_input, "del"))
12748 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12754 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12760 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12766 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12771 else if (unformat (line_input, "group %U %U",
12772 unformat_ip4_address, &dst.ip4,
12773 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12775 grp_set = dst_set = 1;
12778 else if (unformat (line_input, "group %U",
12779 unformat_ip4_address, &dst.ip4))
12781 grp_set = dst_set = 1;
12784 else if (unformat (line_input, "group %U %U",
12785 unformat_ip6_address, &dst.ip6,
12786 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12788 grp_set = dst_set = 1;
12791 else if (unformat (line_input, "group %U",
12792 unformat_ip6_address, &dst.ip6))
12794 grp_set = dst_set = 1;
12798 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12800 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12802 else if (unformat (line_input, "decap-next %U",
12803 unformat_geneve_decap_next, &decap_next_index))
12805 else if (unformat (line_input, "vni %d", &vni))
12809 errmsg ("parse error '%U'", format_unformat_error, line_input);
12816 errmsg ("tunnel src address not specified");
12821 errmsg ("tunnel dst address not specified");
12825 if (grp_set && !ip46_address_is_multicast (&dst))
12827 errmsg ("tunnel group address not multicast");
12830 if (grp_set && mcast_sw_if_index == ~0)
12832 errmsg ("tunnel nonexistent multicast device");
12835 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12837 errmsg ("tunnel dst address must be unicast");
12842 if (ipv4_set && ipv6_set)
12844 errmsg ("both IPv4 and IPv6 addresses specified");
12848 if ((vni == 0) || (vni >> 24))
12850 errmsg ("vni not specified or out of range");
12854 M (GENEVE_ADD_DEL_TUNNEL, mp);
12858 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12859 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12863 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12864 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12866 mp->encap_vrf_id = ntohl (encap_vrf_id);
12867 mp->decap_next_index = ntohl (decap_next_index);
12868 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12869 mp->vni = ntohl (vni);
12870 mp->is_add = is_add;
12871 mp->is_ipv6 = ipv6_set;
12878 static void vl_api_geneve_tunnel_details_t_handler
12879 (vl_api_geneve_tunnel_details_t * mp)
12881 vat_main_t *vam = &vat_main;
12882 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12883 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12885 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12886 ntohl (mp->sw_if_index),
12887 format_ip46_address, &src, IP46_TYPE_ANY,
12888 format_ip46_address, &dst, IP46_TYPE_ANY,
12889 ntohl (mp->encap_vrf_id),
12890 ntohl (mp->decap_next_index), ntohl (mp->vni),
12891 ntohl (mp->mcast_sw_if_index));
12894 static void vl_api_geneve_tunnel_details_t_handler_json
12895 (vl_api_geneve_tunnel_details_t * mp)
12897 vat_main_t *vam = &vat_main;
12898 vat_json_node_t *node = NULL;
12900 if (VAT_JSON_ARRAY != vam->json_tree.type)
12902 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12903 vat_json_init_array (&vam->json_tree);
12905 node = vat_json_array_add (&vam->json_tree);
12907 vat_json_init_object (node);
12908 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12911 struct in6_addr ip6;
12913 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12914 vat_json_object_add_ip6 (node, "src_address", ip6);
12915 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12916 vat_json_object_add_ip6 (node, "dst_address", ip6);
12920 struct in_addr ip4;
12922 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12923 vat_json_object_add_ip4 (node, "src_address", ip4);
12924 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12925 vat_json_object_add_ip4 (node, "dst_address", ip4);
12927 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12928 vat_json_object_add_uint (node, "decap_next_index",
12929 ntohl (mp->decap_next_index));
12930 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12931 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12932 vat_json_object_add_uint (node, "mcast_sw_if_index",
12933 ntohl (mp->mcast_sw_if_index));
12937 api_geneve_tunnel_dump (vat_main_t * vam)
12939 unformat_input_t *i = vam->input;
12940 vl_api_geneve_tunnel_dump_t *mp;
12941 vl_api_control_ping_t *mp_ping;
12943 u8 sw_if_index_set = 0;
12946 /* Parse args required to build the message */
12947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12949 if (unformat (i, "sw_if_index %d", &sw_if_index))
12950 sw_if_index_set = 1;
12955 if (sw_if_index_set == 0)
12960 if (!vam->json_output)
12962 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12963 "sw_if_index", "local_address", "remote_address",
12964 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12967 /* Get list of geneve-tunnel interfaces */
12968 M (GENEVE_TUNNEL_DUMP, mp);
12970 mp->sw_if_index = htonl (sw_if_index);
12974 /* Use a control ping for synchronization */
12975 M (CONTROL_PING, mp_ping);
12983 api_gre_tunnel_add_del (vat_main_t * vam)
12985 unformat_input_t *line_input = vam->input;
12986 vl_api_address_t src = { }, dst =
12989 vl_api_gre_tunnel_add_del_t *mp;
12990 vl_api_gre_tunnel_type_t t_type;
12994 u32 outer_fib_id = 0;
12995 u32 session_id = 0;
12999 t_type = GRE_API_TUNNEL_TYPE_L3;
13001 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13003 if (unformat (line_input, "del"))
13005 else if (unformat (line_input, "instance %d", &instance))
13007 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13011 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13015 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13017 else if (unformat (line_input, "teb"))
13018 t_type = GRE_API_TUNNEL_TYPE_TEB;
13019 else if (unformat (line_input, "erspan %d", &session_id))
13020 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13023 errmsg ("parse error '%U'", format_unformat_error, line_input);
13030 errmsg ("tunnel src address not specified");
13035 errmsg ("tunnel dst address not specified");
13039 M (GRE_TUNNEL_ADD_DEL, mp);
13041 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13042 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13044 mp->tunnel.instance = htonl (instance);
13045 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13046 mp->is_add = is_add;
13047 mp->tunnel.session_id = htons ((u16) session_id);
13048 mp->tunnel.type = htonl (t_type);
13055 static void vl_api_gre_tunnel_details_t_handler
13056 (vl_api_gre_tunnel_details_t * mp)
13058 vat_main_t *vam = &vat_main;
13060 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13061 ntohl (mp->tunnel.sw_if_index),
13062 ntohl (mp->tunnel.instance),
13063 format_vl_api_address, &mp->tunnel.src,
13064 format_vl_api_address, &mp->tunnel.dst,
13065 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13066 ntohl (mp->tunnel.session_id));
13069 static void vl_api_gre_tunnel_details_t_handler_json
13070 (vl_api_gre_tunnel_details_t * mp)
13072 vat_main_t *vam = &vat_main;
13073 vat_json_node_t *node = NULL;
13075 if (VAT_JSON_ARRAY != vam->json_tree.type)
13077 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13078 vat_json_init_array (&vam->json_tree);
13080 node = vat_json_array_add (&vam->json_tree);
13082 vat_json_init_object (node);
13083 vat_json_object_add_uint (node, "sw_if_index",
13084 ntohl (mp->tunnel.sw_if_index));
13085 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13087 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13088 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13089 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13090 vat_json_object_add_uint (node, "outer_fib_id",
13091 ntohl (mp->tunnel.outer_fib_id));
13092 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13096 api_gre_tunnel_dump (vat_main_t * vam)
13098 unformat_input_t *i = vam->input;
13099 vl_api_gre_tunnel_dump_t *mp;
13100 vl_api_control_ping_t *mp_ping;
13102 u8 sw_if_index_set = 0;
13105 /* Parse args required to build the message */
13106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13108 if (unformat (i, "sw_if_index %d", &sw_if_index))
13109 sw_if_index_set = 1;
13114 if (sw_if_index_set == 0)
13119 if (!vam->json_output)
13121 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13122 "sw_if_index", "instance", "src_address", "dst_address",
13123 "tunnel_type", "outer_fib_id", "session_id");
13126 /* Get list of gre-tunnel interfaces */
13127 M (GRE_TUNNEL_DUMP, mp);
13129 mp->sw_if_index = htonl (sw_if_index);
13133 /* Use a control ping for synchronization */
13134 MPING (CONTROL_PING, mp_ping);
13142 api_l2_fib_clear_table (vat_main_t * vam)
13144 // unformat_input_t * i = vam->input;
13145 vl_api_l2_fib_clear_table_t *mp;
13148 M (L2_FIB_CLEAR_TABLE, mp);
13156 api_l2_interface_efp_filter (vat_main_t * vam)
13158 unformat_input_t *i = vam->input;
13159 vl_api_l2_interface_efp_filter_t *mp;
13162 u8 sw_if_index_set = 0;
13165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13167 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13168 sw_if_index_set = 1;
13169 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13170 sw_if_index_set = 1;
13171 else if (unformat (i, "enable"))
13173 else if (unformat (i, "disable"))
13177 clib_warning ("parse error '%U'", format_unformat_error, i);
13182 if (sw_if_index_set == 0)
13184 errmsg ("missing sw_if_index");
13188 M (L2_INTERFACE_EFP_FILTER, mp);
13190 mp->sw_if_index = ntohl (sw_if_index);
13191 mp->enable_disable = enable;
13198 #define foreach_vtr_op \
13199 _("disable", L2_VTR_DISABLED) \
13200 _("push-1", L2_VTR_PUSH_1) \
13201 _("push-2", L2_VTR_PUSH_2) \
13202 _("pop-1", L2_VTR_POP_1) \
13203 _("pop-2", L2_VTR_POP_2) \
13204 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13205 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13206 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13207 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13210 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13212 unformat_input_t *i = vam->input;
13213 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13215 u8 sw_if_index_set = 0;
13218 u32 push_dot1q = 1;
13223 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13225 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13226 sw_if_index_set = 1;
13227 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13228 sw_if_index_set = 1;
13229 else if (unformat (i, "vtr_op %d", &vtr_op))
13231 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13234 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13236 else if (unformat (i, "tag1 %d", &tag1))
13238 else if (unformat (i, "tag2 %d", &tag2))
13242 clib_warning ("parse error '%U'", format_unformat_error, i);
13247 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13249 errmsg ("missing vtr operation or sw_if_index");
13253 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13254 mp->sw_if_index = ntohl (sw_if_index);
13255 mp->vtr_op = ntohl (vtr_op);
13256 mp->push_dot1q = ntohl (push_dot1q);
13257 mp->tag1 = ntohl (tag1);
13258 mp->tag2 = ntohl (tag2);
13266 api_create_vhost_user_if (vat_main_t * vam)
13268 unformat_input_t *i = vam->input;
13269 vl_api_create_vhost_user_if_t *mp;
13272 u8 file_name_set = 0;
13273 u32 custom_dev_instance = ~0;
13275 u8 use_custom_mac = 0;
13276 u8 disable_mrg_rxbuf = 0;
13277 u8 disable_indirect_desc = 0;
13281 /* Shut up coverity */
13282 clib_memset (hwaddr, 0, sizeof (hwaddr));
13284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13286 if (unformat (i, "socket %s", &file_name))
13290 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13292 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13293 use_custom_mac = 1;
13294 else if (unformat (i, "server"))
13296 else if (unformat (i, "disable_mrg_rxbuf"))
13297 disable_mrg_rxbuf = 1;
13298 else if (unformat (i, "disable_indirect_desc"))
13299 disable_indirect_desc = 1;
13300 else if (unformat (i, "tag %s", &tag))
13306 if (file_name_set == 0)
13308 errmsg ("missing socket file name");
13312 if (vec_len (file_name) > 255)
13314 errmsg ("socket file name too long");
13317 vec_add1 (file_name, 0);
13319 M (CREATE_VHOST_USER_IF, mp);
13321 mp->is_server = is_server;
13322 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13323 mp->disable_indirect_desc = disable_indirect_desc;
13324 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13325 vec_free (file_name);
13326 if (custom_dev_instance != ~0)
13329 mp->custom_dev_instance = ntohl (custom_dev_instance);
13332 mp->use_custom_mac = use_custom_mac;
13333 clib_memcpy (mp->mac_address, hwaddr, 6);
13335 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13344 api_modify_vhost_user_if (vat_main_t * vam)
13346 unformat_input_t *i = vam->input;
13347 vl_api_modify_vhost_user_if_t *mp;
13350 u8 file_name_set = 0;
13351 u32 custom_dev_instance = ~0;
13352 u8 sw_if_index_set = 0;
13353 u32 sw_if_index = (u32) ~ 0;
13356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13358 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13359 sw_if_index_set = 1;
13360 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13361 sw_if_index_set = 1;
13362 else if (unformat (i, "socket %s", &file_name))
13366 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13368 else if (unformat (i, "server"))
13374 if (sw_if_index_set == 0)
13376 errmsg ("missing sw_if_index or interface name");
13380 if (file_name_set == 0)
13382 errmsg ("missing socket file name");
13386 if (vec_len (file_name) > 255)
13388 errmsg ("socket file name too long");
13391 vec_add1 (file_name, 0);
13393 M (MODIFY_VHOST_USER_IF, mp);
13395 mp->sw_if_index = ntohl (sw_if_index);
13396 mp->is_server = is_server;
13397 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13398 vec_free (file_name);
13399 if (custom_dev_instance != ~0)
13402 mp->custom_dev_instance = ntohl (custom_dev_instance);
13411 api_delete_vhost_user_if (vat_main_t * vam)
13413 unformat_input_t *i = vam->input;
13414 vl_api_delete_vhost_user_if_t *mp;
13415 u32 sw_if_index = ~0;
13416 u8 sw_if_index_set = 0;
13419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13422 sw_if_index_set = 1;
13423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13424 sw_if_index_set = 1;
13429 if (sw_if_index_set == 0)
13431 errmsg ("missing sw_if_index or interface name");
13436 M (DELETE_VHOST_USER_IF, mp);
13438 mp->sw_if_index = ntohl (sw_if_index);
13445 static void vl_api_sw_interface_vhost_user_details_t_handler
13446 (vl_api_sw_interface_vhost_user_details_t * mp)
13448 vat_main_t *vam = &vat_main;
13450 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13451 (char *) mp->interface_name,
13452 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13453 clib_net_to_host_u64 (mp->features), mp->is_server,
13454 ntohl (mp->num_regions), (char *) mp->sock_filename);
13455 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13458 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13459 (vl_api_sw_interface_vhost_user_details_t * mp)
13461 vat_main_t *vam = &vat_main;
13462 vat_json_node_t *node = NULL;
13464 if (VAT_JSON_ARRAY != vam->json_tree.type)
13466 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13467 vat_json_init_array (&vam->json_tree);
13469 node = vat_json_array_add (&vam->json_tree);
13471 vat_json_init_object (node);
13472 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13473 vat_json_object_add_string_copy (node, "interface_name",
13474 mp->interface_name);
13475 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13476 ntohl (mp->virtio_net_hdr_sz));
13477 vat_json_object_add_uint (node, "features",
13478 clib_net_to_host_u64 (mp->features));
13479 vat_json_object_add_uint (node, "is_server", mp->is_server);
13480 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13481 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13482 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13486 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13488 vl_api_sw_interface_vhost_user_dump_t *mp;
13489 vl_api_control_ping_t *mp_ping;
13492 "Interface name idx hdr_sz features server regions filename");
13494 /* Get list of vhost-user interfaces */
13495 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13498 /* Use a control ping for synchronization */
13499 MPING (CONTROL_PING, mp_ping);
13507 api_show_version (vat_main_t * vam)
13509 vl_api_show_version_t *mp;
13512 M (SHOW_VERSION, mp);
13521 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13523 unformat_input_t *line_input = vam->input;
13524 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13525 ip4_address_t local4, remote4;
13526 ip6_address_t local6, remote6;
13528 u8 ipv4_set = 0, ipv6_set = 0;
13532 u32 mcast_sw_if_index = ~0;
13533 u32 encap_vrf_id = 0;
13534 u32 decap_vrf_id = 0;
13540 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13541 clib_memset (&local4, 0, sizeof local4);
13542 clib_memset (&remote4, 0, sizeof remote4);
13543 clib_memset (&local6, 0, sizeof local6);
13544 clib_memset (&remote6, 0, sizeof remote6);
13546 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13548 if (unformat (line_input, "del"))
13550 else if (unformat (line_input, "local %U",
13551 unformat_ip4_address, &local4))
13556 else if (unformat (line_input, "remote %U",
13557 unformat_ip4_address, &remote4))
13562 else if (unformat (line_input, "local %U",
13563 unformat_ip6_address, &local6))
13568 else if (unformat (line_input, "remote %U",
13569 unformat_ip6_address, &remote6))
13574 else if (unformat (line_input, "group %U %U",
13575 unformat_ip4_address, &remote4,
13576 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13578 grp_set = remote_set = 1;
13581 else if (unformat (line_input, "group %U",
13582 unformat_ip4_address, &remote4))
13584 grp_set = remote_set = 1;
13587 else if (unformat (line_input, "group %U %U",
13588 unformat_ip6_address, &remote6,
13589 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13591 grp_set = remote_set = 1;
13594 else if (unformat (line_input, "group %U",
13595 unformat_ip6_address, &remote6))
13597 grp_set = remote_set = 1;
13601 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13603 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13605 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13607 else if (unformat (line_input, "vni %d", &vni))
13609 else if (unformat (line_input, "next-ip4"))
13611 else if (unformat (line_input, "next-ip6"))
13613 else if (unformat (line_input, "next-ethernet"))
13615 else if (unformat (line_input, "next-nsh"))
13619 errmsg ("parse error '%U'", format_unformat_error, line_input);
13624 if (local_set == 0)
13626 errmsg ("tunnel local address not specified");
13629 if (remote_set == 0)
13631 errmsg ("tunnel remote address not specified");
13634 if (grp_set && mcast_sw_if_index == ~0)
13636 errmsg ("tunnel nonexistent multicast device");
13639 if (ipv4_set && ipv6_set)
13641 errmsg ("both IPv4 and IPv6 addresses specified");
13647 errmsg ("vni not specified");
13651 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13656 clib_memcpy (&mp->local, &local6, sizeof (local6));
13657 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13661 clib_memcpy (&mp->local, &local4, sizeof (local4));
13662 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13665 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13666 mp->encap_vrf_id = ntohl (encap_vrf_id);
13667 mp->decap_vrf_id = ntohl (decap_vrf_id);
13668 mp->protocol = protocol;
13669 mp->vni = ntohl (vni);
13670 mp->is_add = is_add;
13671 mp->is_ipv6 = ipv6_set;
13678 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13679 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13681 vat_main_t *vam = &vat_main;
13682 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13683 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13685 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13686 ntohl (mp->sw_if_index),
13687 format_ip46_address, &local, IP46_TYPE_ANY,
13688 format_ip46_address, &remote, IP46_TYPE_ANY,
13689 ntohl (mp->vni), mp->protocol,
13690 ntohl (mp->mcast_sw_if_index),
13691 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13695 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13696 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13698 vat_main_t *vam = &vat_main;
13699 vat_json_node_t *node = NULL;
13700 struct in_addr ip4;
13701 struct in6_addr ip6;
13703 if (VAT_JSON_ARRAY != vam->json_tree.type)
13705 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13706 vat_json_init_array (&vam->json_tree);
13708 node = vat_json_array_add (&vam->json_tree);
13710 vat_json_init_object (node);
13711 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13714 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13715 vat_json_object_add_ip6 (node, "local", ip6);
13716 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13717 vat_json_object_add_ip6 (node, "remote", ip6);
13721 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13722 vat_json_object_add_ip4 (node, "local", ip4);
13723 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13724 vat_json_object_add_ip4 (node, "remote", ip4);
13726 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13727 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13728 vat_json_object_add_uint (node, "mcast_sw_if_index",
13729 ntohl (mp->mcast_sw_if_index));
13730 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13731 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13732 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13736 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13738 unformat_input_t *i = vam->input;
13739 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13740 vl_api_control_ping_t *mp_ping;
13742 u8 sw_if_index_set = 0;
13745 /* Parse args required to build the message */
13746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13748 if (unformat (i, "sw_if_index %d", &sw_if_index))
13749 sw_if_index_set = 1;
13754 if (sw_if_index_set == 0)
13759 if (!vam->json_output)
13761 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13762 "sw_if_index", "local", "remote", "vni",
13763 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13766 /* Get list of vxlan-tunnel interfaces */
13767 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13769 mp->sw_if_index = htonl (sw_if_index);
13773 /* Use a control ping for synchronization */
13774 MPING (CONTROL_PING, mp_ping);
13781 static void vl_api_l2_fib_table_details_t_handler
13782 (vl_api_l2_fib_table_details_t * mp)
13784 vat_main_t *vam = &vat_main;
13786 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13788 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13789 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13793 static void vl_api_l2_fib_table_details_t_handler_json
13794 (vl_api_l2_fib_table_details_t * mp)
13796 vat_main_t *vam = &vat_main;
13797 vat_json_node_t *node = NULL;
13799 if (VAT_JSON_ARRAY != vam->json_tree.type)
13801 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13802 vat_json_init_array (&vam->json_tree);
13804 node = vat_json_array_add (&vam->json_tree);
13806 vat_json_init_object (node);
13807 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13808 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13809 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13810 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13811 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13812 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13816 api_l2_fib_table_dump (vat_main_t * vam)
13818 unformat_input_t *i = vam->input;
13819 vl_api_l2_fib_table_dump_t *mp;
13820 vl_api_control_ping_t *mp_ping;
13825 /* Parse args required to build the message */
13826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13828 if (unformat (i, "bd_id %d", &bd_id))
13834 if (bd_id_set == 0)
13836 errmsg ("missing bridge domain");
13840 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13842 /* Get list of l2 fib entries */
13843 M (L2_FIB_TABLE_DUMP, mp);
13845 mp->bd_id = ntohl (bd_id);
13848 /* Use a control ping for synchronization */
13849 MPING (CONTROL_PING, mp_ping);
13858 api_interface_name_renumber (vat_main_t * vam)
13860 unformat_input_t *line_input = vam->input;
13861 vl_api_interface_name_renumber_t *mp;
13862 u32 sw_if_index = ~0;
13863 u32 new_show_dev_instance = ~0;
13866 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13868 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13871 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13873 else if (unformat (line_input, "new_show_dev_instance %d",
13874 &new_show_dev_instance))
13880 if (sw_if_index == ~0)
13882 errmsg ("missing interface name or sw_if_index");
13886 if (new_show_dev_instance == ~0)
13888 errmsg ("missing new_show_dev_instance");
13892 M (INTERFACE_NAME_RENUMBER, mp);
13894 mp->sw_if_index = ntohl (sw_if_index);
13895 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13903 api_ip_probe_neighbor (vat_main_t * vam)
13905 unformat_input_t *i = vam->input;
13906 vl_api_ip_probe_neighbor_t *mp;
13907 vl_api_address_t dst_adr = { };
13913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13915 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13917 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13919 else if (unformat (i, "address %U", unformat_vl_api_address, &dst_adr))
13927 errmsg ("missing interface");
13933 errmsg ("missing addresses");
13937 M (IP_PROBE_NEIGHBOR, mp);
13939 mp->sw_if_index = ntohl (sw_if_index);
13940 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
13948 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
13950 unformat_input_t *i = vam->input;
13951 vl_api_ip_scan_neighbor_enable_disable_t *mp;
13952 u8 mode = IP_SCAN_V46_NEIGHBORS;
13953 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
13956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13958 if (unformat (i, "ip4"))
13959 mode = IP_SCAN_V4_NEIGHBORS;
13960 else if (unformat (i, "ip6"))
13961 mode = IP_SCAN_V6_NEIGHBORS;
13962 if (unformat (i, "both"))
13963 mode = IP_SCAN_V46_NEIGHBORS;
13964 else if (unformat (i, "disable"))
13965 mode = IP_SCAN_DISABLED;
13966 else if (unformat (i, "interval %d", &interval))
13968 else if (unformat (i, "max-time %d", &time))
13970 else if (unformat (i, "max-update %d", &update))
13972 else if (unformat (i, "delay %d", &delay))
13974 else if (unformat (i, "stale %d", &stale))
13980 if (interval > 255)
13982 errmsg ("interval cannot exceed 255 minutes.");
13987 errmsg ("max-time cannot exceed 255 usec.");
13992 errmsg ("max-update cannot exceed 255.");
13997 errmsg ("delay cannot exceed 255 msec.");
14002 errmsg ("stale cannot exceed 255 minutes.");
14006 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14008 mp->scan_interval = interval;
14009 mp->max_proc_time = time;
14010 mp->max_update = update;
14011 mp->scan_int_delay = delay;
14012 mp->stale_threshold = stale;
14020 api_want_ip4_arp_events (vat_main_t * vam)
14022 unformat_input_t *line_input = vam->input;
14023 vl_api_want_ip4_arp_events_t *mp;
14024 ip4_address_t address;
14025 int address_set = 0;
14026 u32 enable_disable = 1;
14029 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14031 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14033 else if (unformat (line_input, "del"))
14034 enable_disable = 0;
14039 if (address_set == 0)
14041 errmsg ("missing addresses");
14045 M (WANT_IP4_ARP_EVENTS, mp);
14046 mp->enable_disable = enable_disable;
14047 mp->pid = htonl (getpid ());
14048 clib_memcpy (mp->ip, &address, sizeof (address));
14056 api_want_ip6_nd_events (vat_main_t * vam)
14058 unformat_input_t *line_input = vam->input;
14059 vl_api_want_ip6_nd_events_t *mp;
14060 vl_api_ip6_address_t address;
14061 int address_set = 0;
14062 u32 enable_disable = 1;
14065 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14068 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14070 else if (unformat (line_input, "del"))
14071 enable_disable = 0;
14076 if (address_set == 0)
14078 errmsg ("missing addresses");
14082 M (WANT_IP6_ND_EVENTS, mp);
14083 mp->enable_disable = enable_disable;
14084 mp->pid = htonl (getpid ());
14085 clib_memcpy (&mp->ip, &address, sizeof (address));
14093 api_want_l2_macs_events (vat_main_t * vam)
14095 unformat_input_t *line_input = vam->input;
14096 vl_api_want_l2_macs_events_t *mp;
14097 u8 enable_disable = 1;
14098 u32 scan_delay = 0;
14099 u32 max_macs_in_event = 0;
14100 u32 learn_limit = 0;
14103 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14105 if (unformat (line_input, "learn-limit %d", &learn_limit))
14107 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14109 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14111 else if (unformat (line_input, "disable"))
14112 enable_disable = 0;
14117 M (WANT_L2_MACS_EVENTS, mp);
14118 mp->enable_disable = enable_disable;
14119 mp->pid = htonl (getpid ());
14120 mp->learn_limit = htonl (learn_limit);
14121 mp->scan_delay = (u8) scan_delay;
14122 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14129 api_input_acl_set_interface (vat_main_t * vam)
14131 unformat_input_t *i = vam->input;
14132 vl_api_input_acl_set_interface_t *mp;
14134 int sw_if_index_set;
14135 u32 ip4_table_index = ~0;
14136 u32 ip6_table_index = ~0;
14137 u32 l2_table_index = ~0;
14141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14143 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14144 sw_if_index_set = 1;
14145 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14146 sw_if_index_set = 1;
14147 else if (unformat (i, "del"))
14149 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14151 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14153 else if (unformat (i, "l2-table %d", &l2_table_index))
14157 clib_warning ("parse error '%U'", format_unformat_error, i);
14162 if (sw_if_index_set == 0)
14164 errmsg ("missing interface name or sw_if_index");
14168 M (INPUT_ACL_SET_INTERFACE, mp);
14170 mp->sw_if_index = ntohl (sw_if_index);
14171 mp->ip4_table_index = ntohl (ip4_table_index);
14172 mp->ip6_table_index = ntohl (ip6_table_index);
14173 mp->l2_table_index = ntohl (l2_table_index);
14174 mp->is_add = is_add;
14182 api_output_acl_set_interface (vat_main_t * vam)
14184 unformat_input_t *i = vam->input;
14185 vl_api_output_acl_set_interface_t *mp;
14187 int sw_if_index_set;
14188 u32 ip4_table_index = ~0;
14189 u32 ip6_table_index = ~0;
14190 u32 l2_table_index = ~0;
14194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14196 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14197 sw_if_index_set = 1;
14198 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14199 sw_if_index_set = 1;
14200 else if (unformat (i, "del"))
14202 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14204 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14206 else if (unformat (i, "l2-table %d", &l2_table_index))
14210 clib_warning ("parse error '%U'", format_unformat_error, i);
14215 if (sw_if_index_set == 0)
14217 errmsg ("missing interface name or sw_if_index");
14221 M (OUTPUT_ACL_SET_INTERFACE, mp);
14223 mp->sw_if_index = ntohl (sw_if_index);
14224 mp->ip4_table_index = ntohl (ip4_table_index);
14225 mp->ip6_table_index = ntohl (ip6_table_index);
14226 mp->l2_table_index = ntohl (l2_table_index);
14227 mp->is_add = is_add;
14235 api_ip_address_dump (vat_main_t * vam)
14237 unformat_input_t *i = vam->input;
14238 vl_api_ip_address_dump_t *mp;
14239 vl_api_control_ping_t *mp_ping;
14240 u32 sw_if_index = ~0;
14241 u8 sw_if_index_set = 0;
14246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14248 if (unformat (i, "sw_if_index %d", &sw_if_index))
14249 sw_if_index_set = 1;
14251 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14252 sw_if_index_set = 1;
14253 else if (unformat (i, "ipv4"))
14255 else if (unformat (i, "ipv6"))
14261 if (ipv4_set && ipv6_set)
14263 errmsg ("ipv4 and ipv6 flags cannot be both set");
14267 if ((!ipv4_set) && (!ipv6_set))
14269 errmsg ("no ipv4 nor ipv6 flag set");
14273 if (sw_if_index_set == 0)
14275 errmsg ("missing interface name or sw_if_index");
14279 vam->current_sw_if_index = sw_if_index;
14280 vam->is_ipv6 = ipv6_set;
14282 M (IP_ADDRESS_DUMP, mp);
14283 mp->sw_if_index = ntohl (sw_if_index);
14284 mp->is_ipv6 = ipv6_set;
14287 /* Use a control ping for synchronization */
14288 MPING (CONTROL_PING, mp_ping);
14296 api_ip_dump (vat_main_t * vam)
14298 vl_api_ip_dump_t *mp;
14299 vl_api_control_ping_t *mp_ping;
14300 unformat_input_t *in = vam->input;
14307 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14309 if (unformat (in, "ipv4"))
14311 else if (unformat (in, "ipv6"))
14317 if (ipv4_set && ipv6_set)
14319 errmsg ("ipv4 and ipv6 flags cannot be both set");
14323 if ((!ipv4_set) && (!ipv6_set))
14325 errmsg ("no ipv4 nor ipv6 flag set");
14329 is_ipv6 = ipv6_set;
14330 vam->is_ipv6 = is_ipv6;
14332 /* free old data */
14333 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14335 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14337 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14340 mp->is_ipv6 = ipv6_set;
14343 /* Use a control ping for synchronization */
14344 MPING (CONTROL_PING, mp_ping);
14352 api_ipsec_spd_add_del (vat_main_t * vam)
14354 unformat_input_t *i = vam->input;
14355 vl_api_ipsec_spd_add_del_t *mp;
14360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14362 if (unformat (i, "spd_id %d", &spd_id))
14364 else if (unformat (i, "del"))
14368 clib_warning ("parse error '%U'", format_unformat_error, i);
14374 errmsg ("spd_id must be set");
14378 M (IPSEC_SPD_ADD_DEL, mp);
14380 mp->spd_id = ntohl (spd_id);
14381 mp->is_add = is_add;
14389 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14391 unformat_input_t *i = vam->input;
14392 vl_api_ipsec_interface_add_del_spd_t *mp;
14394 u8 sw_if_index_set = 0;
14395 u32 spd_id = (u32) ~ 0;
14399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14401 if (unformat (i, "del"))
14403 else if (unformat (i, "spd_id %d", &spd_id))
14406 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14407 sw_if_index_set = 1;
14408 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14409 sw_if_index_set = 1;
14412 clib_warning ("parse error '%U'", format_unformat_error, i);
14418 if (spd_id == (u32) ~ 0)
14420 errmsg ("spd_id must be set");
14424 if (sw_if_index_set == 0)
14426 errmsg ("missing interface name or sw_if_index");
14430 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14432 mp->spd_id = ntohl (spd_id);
14433 mp->sw_if_index = ntohl (sw_if_index);
14434 mp->is_add = is_add;
14442 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14444 unformat_input_t *i = vam->input;
14445 vl_api_ipsec_spd_entry_add_del_t *mp;
14446 u8 is_add = 1, is_outbound = 0;
14447 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14449 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14450 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14451 vl_api_address_t laddr_start = { }, laddr_stop =
14460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14462 if (unformat (i, "del"))
14464 if (unformat (i, "outbound"))
14466 if (unformat (i, "inbound"))
14468 else if (unformat (i, "spd_id %d", &spd_id))
14470 else if (unformat (i, "sa_id %d", &sa_id))
14472 else if (unformat (i, "priority %d", &priority))
14474 else if (unformat (i, "protocol %d", &protocol))
14476 else if (unformat (i, "lport_start %d", &lport_start))
14478 else if (unformat (i, "lport_stop %d", &lport_stop))
14480 else if (unformat (i, "rport_start %d", &rport_start))
14482 else if (unformat (i, "rport_stop %d", &rport_stop))
14484 else if (unformat (i, "laddr_start %U",
14485 unformat_vl_api_address, &laddr_start))
14487 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14490 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14493 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14497 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14499 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14501 clib_warning ("unsupported action: 'resolve'");
14507 clib_warning ("parse error '%U'", format_unformat_error, i);
14513 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14515 mp->is_add = is_add;
14517 mp->entry.spd_id = ntohl (spd_id);
14518 mp->entry.priority = ntohl (priority);
14519 mp->entry.is_outbound = is_outbound;
14521 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14522 sizeof (vl_api_address_t));
14523 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14524 sizeof (vl_api_address_t));
14525 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14526 sizeof (vl_api_address_t));
14527 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14528 sizeof (vl_api_address_t));
14530 mp->entry.protocol = (u8) protocol;
14531 mp->entry.local_port_start = ntohs ((u16) lport_start);
14532 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14533 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14534 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14535 mp->entry.policy = (u8) policy;
14536 mp->entry.sa_id = ntohl (sa_id);
14544 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14546 unformat_input_t *i = vam->input;
14547 vl_api_ipsec_sad_entry_add_del_t *mp;
14548 u32 sad_id = 0, spi = 0;
14549 u8 *ck = 0, *ik = 0;
14552 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14553 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14554 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14555 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14556 vl_api_address_t tun_src, tun_dst;
14559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14561 if (unformat (i, "del"))
14563 else if (unformat (i, "sad_id %d", &sad_id))
14565 else if (unformat (i, "spi %d", &spi))
14567 else if (unformat (i, "esp"))
14568 protocol = IPSEC_API_PROTO_ESP;
14570 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14572 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14573 if (ADDRESS_IP6 == tun_src.af)
14574 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14577 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14579 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14580 if (ADDRESS_IP6 == tun_src.af)
14581 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14584 if (unformat (i, "crypto_alg %U",
14585 unformat_ipsec_api_crypto_alg, &crypto_alg))
14587 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14589 else if (unformat (i, "integ_alg %U",
14590 unformat_ipsec_api_integ_alg, &integ_alg))
14592 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14596 clib_warning ("parse error '%U'", format_unformat_error, i);
14602 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14604 mp->is_add = is_add;
14605 mp->entry.sad_id = ntohl (sad_id);
14606 mp->entry.protocol = protocol;
14607 mp->entry.spi = ntohl (spi);
14608 mp->entry.flags = flags;
14610 mp->entry.crypto_algorithm = crypto_alg;
14611 mp->entry.integrity_algorithm = integ_alg;
14612 mp->entry.crypto_key.length = vec_len (ck);
14613 mp->entry.integrity_key.length = vec_len (ik);
14615 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14616 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14618 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14619 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14622 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14624 clib_memcpy (mp->entry.integrity_key.data, ik,
14625 mp->entry.integrity_key.length);
14627 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14629 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14630 sizeof (mp->entry.tunnel_src));
14631 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14632 sizeof (mp->entry.tunnel_dst));
14641 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14643 unformat_input_t *i = vam->input;
14644 vl_api_ipsec_tunnel_if_add_del_t *mp;
14645 u32 local_spi = 0, remote_spi = 0;
14646 u32 crypto_alg = 0, integ_alg = 0;
14647 u8 *lck = NULL, *rck = NULL;
14648 u8 *lik = NULL, *rik = NULL;
14649 vl_api_address_t local_ip = { 0 };
14650 vl_api_address_t remote_ip = { 0 };
14654 u8 anti_replay = 0;
14660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14662 if (unformat (i, "del"))
14664 else if (unformat (i, "esn"))
14666 else if (unformat (i, "anti-replay"))
14668 else if (unformat (i, "count %d", &count))
14670 else if (unformat (i, "local_spi %d", &local_spi))
14672 else if (unformat (i, "remote_spi %d", &remote_spi))
14675 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14678 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14680 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14683 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14685 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14687 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14691 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
14693 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
14695 errmsg ("unsupported crypto-alg: '%U'\n",
14696 format_ipsec_crypto_alg, crypto_alg);
14702 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
14704 if (integ_alg >= IPSEC_INTEG_N_ALG)
14706 errmsg ("unsupported integ-alg: '%U'\n",
14707 format_ipsec_integ_alg, integ_alg);
14711 else if (unformat (i, "instance %u", &instance))
14715 errmsg ("parse error '%U'\n", format_unformat_error, i);
14722 /* Turn on async mode */
14723 vam->async_mode = 1;
14724 vam->async_errors = 0;
14725 before = vat_time_now (vam);
14728 for (jj = 0; jj < count; jj++)
14730 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14732 mp->is_add = is_add;
14734 mp->anti_replay = anti_replay;
14737 increment_address (&remote_ip);
14739 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
14740 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
14742 mp->local_spi = htonl (local_spi + jj);
14743 mp->remote_spi = htonl (remote_spi + jj);
14744 mp->crypto_alg = (u8) crypto_alg;
14746 mp->local_crypto_key_len = 0;
14749 mp->local_crypto_key_len = vec_len (lck);
14750 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14751 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14752 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14755 mp->remote_crypto_key_len = 0;
14758 mp->remote_crypto_key_len = vec_len (rck);
14759 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14760 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14761 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14764 mp->integ_alg = (u8) integ_alg;
14766 mp->local_integ_key_len = 0;
14769 mp->local_integ_key_len = vec_len (lik);
14770 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14771 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14772 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14775 mp->remote_integ_key_len = 0;
14778 mp->remote_integ_key_len = vec_len (rik);
14779 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14780 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14781 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14786 mp->renumber = renumber;
14787 mp->show_instance = ntohl (instance);
14792 /* When testing multiple add/del ops, use a control-ping to sync */
14795 vl_api_control_ping_t *mp_ping;
14799 /* Shut off async mode */
14800 vam->async_mode = 0;
14802 MPING (CONTROL_PING, mp_ping);
14805 timeout = vat_time_now (vam) + 1.0;
14806 while (vat_time_now (vam) < timeout)
14807 if (vam->result_ready == 1)
14812 if (vam->retval == -99)
14813 errmsg ("timeout");
14815 if (vam->async_errors > 0)
14817 errmsg ("%d asynchronous errors", vam->async_errors);
14820 vam->async_errors = 0;
14821 after = vat_time_now (vam);
14823 /* slim chance, but we might have eaten SIGTERM on the first iteration */
14827 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
14828 count, after - before, count / (after - before));
14832 /* Wait for a reply... */
14841 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14843 vat_main_t *vam = &vat_main;
14845 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14846 "crypto_key %U integ_alg %u integ_key %U flags %x "
14847 "tunnel_src_addr %U tunnel_dst_addr %U "
14848 "salt %u seq_outbound %lu last_seq_inbound %lu "
14849 "replay_window %lu\n",
14850 ntohl (mp->entry.sad_id),
14851 ntohl (mp->sw_if_index),
14852 ntohl (mp->entry.spi),
14853 ntohl (mp->entry.protocol),
14854 ntohl (mp->entry.crypto_algorithm),
14855 format_hex_bytes, mp->entry.crypto_key.data,
14856 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
14857 format_hex_bytes, mp->entry.integrity_key.data,
14858 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
14859 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
14860 &mp->entry.tunnel_dst, ntohl (mp->salt),
14861 clib_net_to_host_u64 (mp->seq_outbound),
14862 clib_net_to_host_u64 (mp->last_seq_inbound),
14863 clib_net_to_host_u64 (mp->replay_window));
14866 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14867 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14869 static void vl_api_ipsec_sa_details_t_handler_json
14870 (vl_api_ipsec_sa_details_t * mp)
14872 vat_main_t *vam = &vat_main;
14873 vat_json_node_t *node = NULL;
14874 vl_api_ipsec_sad_flags_t flags;
14876 if (VAT_JSON_ARRAY != vam->json_tree.type)
14878 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14879 vat_json_init_array (&vam->json_tree);
14881 node = vat_json_array_add (&vam->json_tree);
14883 vat_json_init_object (node);
14884 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
14885 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14886 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
14887 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
14888 vat_json_object_add_uint (node, "crypto_alg",
14889 ntohl (mp->entry.crypto_algorithm));
14890 vat_json_object_add_uint (node, "integ_alg",
14891 ntohl (mp->entry.integrity_algorithm));
14892 flags = ntohl (mp->entry.flags);
14893 vat_json_object_add_uint (node, "use_esn",
14894 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
14895 vat_json_object_add_uint (node, "use_anti_replay",
14896 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
14897 vat_json_object_add_uint (node, "is_tunnel",
14898 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
14899 vat_json_object_add_uint (node, "is_tunnel_ip6",
14900 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
14901 vat_json_object_add_uint (node, "udp_encap",
14902 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
14903 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
14904 mp->entry.crypto_key.length);
14905 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
14906 mp->entry.integrity_key.length);
14907 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
14908 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
14909 vat_json_object_add_uint (node, "replay_window",
14910 clib_net_to_host_u64 (mp->replay_window));
14914 api_ipsec_sa_dump (vat_main_t * vam)
14916 unformat_input_t *i = vam->input;
14917 vl_api_ipsec_sa_dump_t *mp;
14918 vl_api_control_ping_t *mp_ping;
14922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14924 if (unformat (i, "sa_id %d", &sa_id))
14928 clib_warning ("parse error '%U'", format_unformat_error, i);
14933 M (IPSEC_SA_DUMP, mp);
14935 mp->sa_id = ntohl (sa_id);
14939 /* Use a control ping for synchronization */
14940 M (CONTROL_PING, mp_ping);
14948 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14950 unformat_input_t *i = vam->input;
14951 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14952 u32 sw_if_index = ~0;
14954 u8 is_outbound = (u8) ~ 0;
14957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14959 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14961 else if (unformat (i, "sa_id %d", &sa_id))
14963 else if (unformat (i, "outbound"))
14965 else if (unformat (i, "inbound"))
14969 clib_warning ("parse error '%U'", format_unformat_error, i);
14974 if (sw_if_index == ~0)
14976 errmsg ("interface must be specified");
14982 errmsg ("SA ID must be specified");
14986 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14988 mp->sw_if_index = htonl (sw_if_index);
14989 mp->sa_id = htonl (sa_id);
14990 mp->is_outbound = is_outbound;
14999 api_get_first_msg_id (vat_main_t * vam)
15001 vl_api_get_first_msg_id_t *mp;
15002 unformat_input_t *i = vam->input;
15007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15009 if (unformat (i, "client %s", &name))
15017 errmsg ("missing client name");
15020 vec_add1 (name, 0);
15022 if (vec_len (name) > 63)
15024 errmsg ("client name too long");
15028 M (GET_FIRST_MSG_ID, mp);
15029 clib_memcpy (mp->name, name, vec_len (name));
15036 api_cop_interface_enable_disable (vat_main_t * vam)
15038 unformat_input_t *line_input = vam->input;
15039 vl_api_cop_interface_enable_disable_t *mp;
15040 u32 sw_if_index = ~0;
15041 u8 enable_disable = 1;
15044 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15046 if (unformat (line_input, "disable"))
15047 enable_disable = 0;
15048 if (unformat (line_input, "enable"))
15049 enable_disable = 1;
15050 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15051 vam, &sw_if_index))
15053 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15059 if (sw_if_index == ~0)
15061 errmsg ("missing interface name or sw_if_index");
15065 /* Construct the API message */
15066 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15067 mp->sw_if_index = ntohl (sw_if_index);
15068 mp->enable_disable = enable_disable;
15072 /* Wait for the reply */
15078 api_cop_whitelist_enable_disable (vat_main_t * vam)
15080 unformat_input_t *line_input = vam->input;
15081 vl_api_cop_whitelist_enable_disable_t *mp;
15082 u32 sw_if_index = ~0;
15083 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15087 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15089 if (unformat (line_input, "ip4"))
15091 else if (unformat (line_input, "ip6"))
15093 else if (unformat (line_input, "default"))
15095 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15096 vam, &sw_if_index))
15098 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15100 else if (unformat (line_input, "fib-id %d", &fib_id))
15106 if (sw_if_index == ~0)
15108 errmsg ("missing interface name or sw_if_index");
15112 /* Construct the API message */
15113 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15114 mp->sw_if_index = ntohl (sw_if_index);
15115 mp->fib_id = ntohl (fib_id);
15118 mp->default_cop = default_cop;
15122 /* Wait for the reply */
15128 api_get_node_graph (vat_main_t * vam)
15130 vl_api_get_node_graph_t *mp;
15133 M (GET_NODE_GRAPH, mp);
15137 /* Wait for the reply */
15143 /** Used for parsing LISP eids */
15144 typedef CLIB_PACKED(struct{
15145 u8 addr[16]; /**< eid address */
15146 u32 len; /**< prefix length if IP */
15147 u8 type; /**< type of eid */
15152 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15154 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15156 clib_memset (a, 0, sizeof (a[0]));
15158 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15160 a->type = 0; /* ipv4 type */
15162 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15164 a->type = 1; /* ipv6 type */
15166 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15168 a->type = 2; /* mac type */
15170 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15172 a->type = 3; /* NSH type */
15173 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15174 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15181 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15190 lisp_eid_size_vat (u8 type)
15207 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15209 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15213 api_one_add_del_locator_set (vat_main_t * vam)
15215 unformat_input_t *input = vam->input;
15216 vl_api_one_add_del_locator_set_t *mp;
15218 u8 *locator_set_name = NULL;
15219 u8 locator_set_name_set = 0;
15220 vl_api_local_locator_t locator, *locators = 0;
15221 u32 sw_if_index, priority, weight;
15225 /* Parse args required to build the message */
15226 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15228 if (unformat (input, "del"))
15232 else if (unformat (input, "locator-set %s", &locator_set_name))
15234 locator_set_name_set = 1;
15236 else if (unformat (input, "sw_if_index %u p %u w %u",
15237 &sw_if_index, &priority, &weight))
15239 locator.sw_if_index = htonl (sw_if_index);
15240 locator.priority = priority;
15241 locator.weight = weight;
15242 vec_add1 (locators, locator);
15246 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15247 &sw_if_index, &priority, &weight))
15249 locator.sw_if_index = htonl (sw_if_index);
15250 locator.priority = priority;
15251 locator.weight = weight;
15252 vec_add1 (locators, locator);
15258 if (locator_set_name_set == 0)
15260 errmsg ("missing locator-set name");
15261 vec_free (locators);
15265 if (vec_len (locator_set_name) > 64)
15267 errmsg ("locator-set name too long");
15268 vec_free (locator_set_name);
15269 vec_free (locators);
15272 vec_add1 (locator_set_name, 0);
15274 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15276 /* Construct the API message */
15277 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15279 mp->is_add = is_add;
15280 clib_memcpy (mp->locator_set_name, locator_set_name,
15281 vec_len (locator_set_name));
15282 vec_free (locator_set_name);
15284 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15286 clib_memcpy (mp->locators, locators, data_len);
15287 vec_free (locators);
15292 /* Wait for a reply... */
15297 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15300 api_one_add_del_locator (vat_main_t * vam)
15302 unformat_input_t *input = vam->input;
15303 vl_api_one_add_del_locator_t *mp;
15304 u32 tmp_if_index = ~0;
15305 u32 sw_if_index = ~0;
15306 u8 sw_if_index_set = 0;
15307 u8 sw_if_index_if_name_set = 0;
15309 u8 priority_set = 0;
15313 u8 *locator_set_name = NULL;
15314 u8 locator_set_name_set = 0;
15317 /* Parse args required to build the message */
15318 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15320 if (unformat (input, "del"))
15324 else if (unformat (input, "locator-set %s", &locator_set_name))
15326 locator_set_name_set = 1;
15328 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15331 sw_if_index_if_name_set = 1;
15332 sw_if_index = tmp_if_index;
15334 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15336 sw_if_index_set = 1;
15337 sw_if_index = tmp_if_index;
15339 else if (unformat (input, "p %d", &priority))
15343 else if (unformat (input, "w %d", &weight))
15351 if (locator_set_name_set == 0)
15353 errmsg ("missing locator-set name");
15357 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15359 errmsg ("missing sw_if_index");
15360 vec_free (locator_set_name);
15364 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15366 errmsg ("cannot use both params interface name and sw_if_index");
15367 vec_free (locator_set_name);
15371 if (priority_set == 0)
15373 errmsg ("missing locator-set priority");
15374 vec_free (locator_set_name);
15378 if (weight_set == 0)
15380 errmsg ("missing locator-set weight");
15381 vec_free (locator_set_name);
15385 if (vec_len (locator_set_name) > 64)
15387 errmsg ("locator-set name too long");
15388 vec_free (locator_set_name);
15391 vec_add1 (locator_set_name, 0);
15393 /* Construct the API message */
15394 M (ONE_ADD_DEL_LOCATOR, mp);
15396 mp->is_add = is_add;
15397 mp->sw_if_index = ntohl (sw_if_index);
15398 mp->priority = priority;
15399 mp->weight = weight;
15400 clib_memcpy (mp->locator_set_name, locator_set_name,
15401 vec_len (locator_set_name));
15402 vec_free (locator_set_name);
15407 /* Wait for a reply... */
15412 #define api_lisp_add_del_locator api_one_add_del_locator
15415 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15417 u32 *key_id = va_arg (*args, u32 *);
15420 if (unformat (input, "%s", &s))
15422 if (!strcmp ((char *) s, "sha1"))
15423 key_id[0] = HMAC_SHA_1_96;
15424 else if (!strcmp ((char *) s, "sha256"))
15425 key_id[0] = HMAC_SHA_256_128;
15428 clib_warning ("invalid key_id: '%s'", s);
15429 key_id[0] = HMAC_NO_KEY;
15440 api_one_add_del_local_eid (vat_main_t * vam)
15442 unformat_input_t *input = vam->input;
15443 vl_api_one_add_del_local_eid_t *mp;
15446 lisp_eid_vat_t _eid, *eid = &_eid;
15447 u8 *locator_set_name = 0;
15448 u8 locator_set_name_set = 0;
15454 /* Parse args required to build the message */
15455 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15457 if (unformat (input, "del"))
15461 else if (unformat (input, "vni %d", &vni))
15465 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15469 else if (unformat (input, "locator-set %s", &locator_set_name))
15471 locator_set_name_set = 1;
15473 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15475 else if (unformat (input, "secret-key %_%v%_", &key))
15481 if (locator_set_name_set == 0)
15483 errmsg ("missing locator-set name");
15489 errmsg ("EID address not set!");
15490 vec_free (locator_set_name);
15494 if (key && (0 == key_id))
15496 errmsg ("invalid key_id!");
15500 if (vec_len (key) > 64)
15502 errmsg ("key too long");
15507 if (vec_len (locator_set_name) > 64)
15509 errmsg ("locator-set name too long");
15510 vec_free (locator_set_name);
15513 vec_add1 (locator_set_name, 0);
15515 /* Construct the API message */
15516 M (ONE_ADD_DEL_LOCAL_EID, mp);
15518 mp->is_add = is_add;
15519 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15520 mp->eid_type = eid->type;
15521 mp->prefix_len = eid->len;
15522 mp->vni = clib_host_to_net_u32 (vni);
15523 mp->key_id = clib_host_to_net_u16 (key_id);
15524 clib_memcpy (mp->locator_set_name, locator_set_name,
15525 vec_len (locator_set_name));
15526 clib_memcpy (mp->key, key, vec_len (key));
15528 vec_free (locator_set_name);
15534 /* Wait for a reply... */
15539 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15542 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15544 u32 dp_table = 0, vni = 0;;
15545 unformat_input_t *input = vam->input;
15546 vl_api_gpe_add_del_fwd_entry_t *mp;
15548 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15549 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15550 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15551 u32 action = ~0, w;
15552 ip4_address_t rmt_rloc4, lcl_rloc4;
15553 ip6_address_t rmt_rloc6, lcl_rloc6;
15554 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15557 clib_memset (&rloc, 0, sizeof (rloc));
15559 /* Parse args required to build the message */
15560 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15562 if (unformat (input, "del"))
15564 else if (unformat (input, "add"))
15566 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15570 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15574 else if (unformat (input, "vrf %d", &dp_table))
15576 else if (unformat (input, "bd %d", &dp_table))
15578 else if (unformat (input, "vni %d", &vni))
15580 else if (unformat (input, "w %d", &w))
15584 errmsg ("No RLOC configured for setting priority/weight!");
15587 curr_rloc->weight = w;
15589 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15590 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15594 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15596 vec_add1 (lcl_locs, rloc);
15598 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15599 vec_add1 (rmt_locs, rloc);
15600 /* weight saved in rmt loc */
15601 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15603 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15604 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15607 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15609 vec_add1 (lcl_locs, rloc);
15611 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15612 vec_add1 (rmt_locs, rloc);
15613 /* weight saved in rmt loc */
15614 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15616 else if (unformat (input, "action %d", &action))
15622 clib_warning ("parse error '%U'", format_unformat_error, input);
15629 errmsg ("remote eid addresses not set");
15633 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15635 errmsg ("eid types don't match");
15639 if (0 == rmt_locs && (u32) ~ 0 == action)
15641 errmsg ("action not set for negative mapping");
15645 /* Construct the API message */
15646 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15647 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15649 mp->is_add = is_add;
15650 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15651 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15652 mp->eid_type = rmt_eid->type;
15653 mp->dp_table = clib_host_to_net_u32 (dp_table);
15654 mp->vni = clib_host_to_net_u32 (vni);
15655 mp->rmt_len = rmt_eid->len;
15656 mp->lcl_len = lcl_eid->len;
15657 mp->action = action;
15659 if (0 != rmt_locs && 0 != lcl_locs)
15661 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15662 clib_memcpy (mp->locs, lcl_locs,
15663 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15665 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15666 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15667 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15669 vec_free (lcl_locs);
15670 vec_free (rmt_locs);
15675 /* Wait for a reply... */
15681 api_one_add_del_map_server (vat_main_t * vam)
15683 unformat_input_t *input = vam->input;
15684 vl_api_one_add_del_map_server_t *mp;
15688 ip4_address_t ipv4;
15689 ip6_address_t ipv6;
15692 /* Parse args required to build the message */
15693 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15695 if (unformat (input, "del"))
15699 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15703 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15711 if (ipv4_set && ipv6_set)
15713 errmsg ("both eid v4 and v6 addresses set");
15717 if (!ipv4_set && !ipv6_set)
15719 errmsg ("eid addresses not set");
15723 /* Construct the API message */
15724 M (ONE_ADD_DEL_MAP_SERVER, mp);
15726 mp->is_add = is_add;
15730 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15735 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15741 /* Wait for a reply... */
15746 #define api_lisp_add_del_map_server api_one_add_del_map_server
15749 api_one_add_del_map_resolver (vat_main_t * vam)
15751 unformat_input_t *input = vam->input;
15752 vl_api_one_add_del_map_resolver_t *mp;
15756 ip4_address_t ipv4;
15757 ip6_address_t ipv6;
15760 /* Parse args required to build the message */
15761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15763 if (unformat (input, "del"))
15767 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15771 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15779 if (ipv4_set && ipv6_set)
15781 errmsg ("both eid v4 and v6 addresses set");
15785 if (!ipv4_set && !ipv6_set)
15787 errmsg ("eid addresses not set");
15791 /* Construct the API message */
15792 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15794 mp->is_add = is_add;
15798 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15803 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15809 /* Wait for a reply... */
15814 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15817 api_lisp_gpe_enable_disable (vat_main_t * vam)
15819 unformat_input_t *input = vam->input;
15820 vl_api_gpe_enable_disable_t *mp;
15825 /* Parse args required to build the message */
15826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15828 if (unformat (input, "enable"))
15833 else if (unformat (input, "disable"))
15844 errmsg ("Value not set");
15848 /* Construct the API message */
15849 M (GPE_ENABLE_DISABLE, mp);
15856 /* Wait for a reply... */
15862 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15864 unformat_input_t *input = vam->input;
15865 vl_api_one_rloc_probe_enable_disable_t *mp;
15870 /* Parse args required to build the message */
15871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15873 if (unformat (input, "enable"))
15878 else if (unformat (input, "disable"))
15886 errmsg ("Value not set");
15890 /* Construct the API message */
15891 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15893 mp->is_enabled = is_en;
15898 /* Wait for a reply... */
15903 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15906 api_one_map_register_enable_disable (vat_main_t * vam)
15908 unformat_input_t *input = vam->input;
15909 vl_api_one_map_register_enable_disable_t *mp;
15914 /* Parse args required to build the message */
15915 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15917 if (unformat (input, "enable"))
15922 else if (unformat (input, "disable"))
15930 errmsg ("Value not set");
15934 /* Construct the API message */
15935 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15937 mp->is_enabled = is_en;
15942 /* Wait for a reply... */
15947 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15950 api_one_enable_disable (vat_main_t * vam)
15952 unformat_input_t *input = vam->input;
15953 vl_api_one_enable_disable_t *mp;
15958 /* Parse args required to build the message */
15959 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15961 if (unformat (input, "enable"))
15966 else if (unformat (input, "disable"))
15976 errmsg ("Value not set");
15980 /* Construct the API message */
15981 M (ONE_ENABLE_DISABLE, mp);
15988 /* Wait for a reply... */
15993 #define api_lisp_enable_disable api_one_enable_disable
15996 api_one_enable_disable_xtr_mode (vat_main_t * vam)
15998 unformat_input_t *input = vam->input;
15999 vl_api_one_enable_disable_xtr_mode_t *mp;
16004 /* Parse args required to build the message */
16005 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16007 if (unformat (input, "enable"))
16012 else if (unformat (input, "disable"))
16022 errmsg ("Value not set");
16026 /* Construct the API message */
16027 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16034 /* Wait for a reply... */
16040 api_one_show_xtr_mode (vat_main_t * vam)
16042 vl_api_one_show_xtr_mode_t *mp;
16045 /* Construct the API message */
16046 M (ONE_SHOW_XTR_MODE, mp);
16051 /* Wait for a reply... */
16057 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16059 unformat_input_t *input = vam->input;
16060 vl_api_one_enable_disable_pitr_mode_t *mp;
16065 /* Parse args required to build the message */
16066 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16068 if (unformat (input, "enable"))
16073 else if (unformat (input, "disable"))
16083 errmsg ("Value not set");
16087 /* Construct the API message */
16088 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16095 /* Wait for a reply... */
16101 api_one_show_pitr_mode (vat_main_t * vam)
16103 vl_api_one_show_pitr_mode_t *mp;
16106 /* Construct the API message */
16107 M (ONE_SHOW_PITR_MODE, mp);
16112 /* Wait for a reply... */
16118 api_one_enable_disable_petr_mode (vat_main_t * vam)
16120 unformat_input_t *input = vam->input;
16121 vl_api_one_enable_disable_petr_mode_t *mp;
16126 /* Parse args required to build the message */
16127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16129 if (unformat (input, "enable"))
16134 else if (unformat (input, "disable"))
16144 errmsg ("Value not set");
16148 /* Construct the API message */
16149 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16156 /* Wait for a reply... */
16162 api_one_show_petr_mode (vat_main_t * vam)
16164 vl_api_one_show_petr_mode_t *mp;
16167 /* Construct the API message */
16168 M (ONE_SHOW_PETR_MODE, mp);
16173 /* Wait for a reply... */
16179 api_show_one_map_register_state (vat_main_t * vam)
16181 vl_api_show_one_map_register_state_t *mp;
16184 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16189 /* wait for reply */
16194 #define api_show_lisp_map_register_state api_show_one_map_register_state
16197 api_show_one_rloc_probe_state (vat_main_t * vam)
16199 vl_api_show_one_rloc_probe_state_t *mp;
16202 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16207 /* wait for reply */
16212 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16215 api_one_add_del_ndp_entry (vat_main_t * vam)
16217 vl_api_one_add_del_ndp_entry_t *mp;
16218 unformat_input_t *input = vam->input;
16223 u8 mac[6] = { 0, };
16224 u8 ip6[16] = { 0, };
16228 /* Parse args required to build the message */
16229 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16231 if (unformat (input, "del"))
16233 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16235 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16237 else if (unformat (input, "bd %d", &bd))
16241 errmsg ("parse error '%U'", format_unformat_error, input);
16246 if (!bd_set || !ip_set || (!mac_set && is_add))
16248 errmsg ("Missing BD, IP or MAC!");
16252 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16253 mp->is_add = is_add;
16254 clib_memcpy (mp->mac, mac, 6);
16255 mp->bd = clib_host_to_net_u32 (bd);
16256 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16261 /* wait for reply */
16267 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16269 vl_api_one_add_del_l2_arp_entry_t *mp;
16270 unformat_input_t *input = vam->input;
16275 u8 mac[6] = { 0, };
16276 u32 ip4 = 0, bd = ~0;
16279 /* Parse args required to build the message */
16280 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16282 if (unformat (input, "del"))
16284 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16286 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16288 else if (unformat (input, "bd %d", &bd))
16292 errmsg ("parse error '%U'", format_unformat_error, input);
16297 if (!bd_set || !ip_set || (!mac_set && is_add))
16299 errmsg ("Missing BD, IP or MAC!");
16303 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16304 mp->is_add = is_add;
16305 clib_memcpy (mp->mac, mac, 6);
16306 mp->bd = clib_host_to_net_u32 (bd);
16312 /* wait for reply */
16318 api_one_ndp_bd_get (vat_main_t * vam)
16320 vl_api_one_ndp_bd_get_t *mp;
16323 M (ONE_NDP_BD_GET, mp);
16328 /* wait for reply */
16334 api_one_ndp_entries_get (vat_main_t * vam)
16336 vl_api_one_ndp_entries_get_t *mp;
16337 unformat_input_t *input = vam->input;
16342 /* Parse args required to build the message */
16343 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16345 if (unformat (input, "bd %d", &bd))
16349 errmsg ("parse error '%U'", format_unformat_error, input);
16356 errmsg ("Expected bridge domain!");
16360 M (ONE_NDP_ENTRIES_GET, mp);
16361 mp->bd = clib_host_to_net_u32 (bd);
16366 /* wait for reply */
16372 api_one_l2_arp_bd_get (vat_main_t * vam)
16374 vl_api_one_l2_arp_bd_get_t *mp;
16377 M (ONE_L2_ARP_BD_GET, mp);
16382 /* wait for reply */
16388 api_one_l2_arp_entries_get (vat_main_t * vam)
16390 vl_api_one_l2_arp_entries_get_t *mp;
16391 unformat_input_t *input = vam->input;
16396 /* Parse args required to build the message */
16397 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16399 if (unformat (input, "bd %d", &bd))
16403 errmsg ("parse error '%U'", format_unformat_error, input);
16410 errmsg ("Expected bridge domain!");
16414 M (ONE_L2_ARP_ENTRIES_GET, mp);
16415 mp->bd = clib_host_to_net_u32 (bd);
16420 /* wait for reply */
16426 api_one_stats_enable_disable (vat_main_t * vam)
16428 vl_api_one_stats_enable_disable_t *mp;
16429 unformat_input_t *input = vam->input;
16434 /* Parse args required to build the message */
16435 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16437 if (unformat (input, "enable"))
16442 else if (unformat (input, "disable"))
16452 errmsg ("Value not set");
16456 M (ONE_STATS_ENABLE_DISABLE, mp);
16462 /* wait for reply */
16468 api_show_one_stats_enable_disable (vat_main_t * vam)
16470 vl_api_show_one_stats_enable_disable_t *mp;
16473 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16478 /* wait for reply */
16484 api_show_one_map_request_mode (vat_main_t * vam)
16486 vl_api_show_one_map_request_mode_t *mp;
16489 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16494 /* wait for reply */
16499 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16502 api_one_map_request_mode (vat_main_t * vam)
16504 unformat_input_t *input = vam->input;
16505 vl_api_one_map_request_mode_t *mp;
16509 /* Parse args required to build the message */
16510 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16512 if (unformat (input, "dst-only"))
16514 else if (unformat (input, "src-dst"))
16518 errmsg ("parse error '%U'", format_unformat_error, input);
16523 M (ONE_MAP_REQUEST_MODE, mp);
16530 /* wait for reply */
16535 #define api_lisp_map_request_mode api_one_map_request_mode
16538 * Enable/disable ONE proxy ITR.
16540 * @param vam vpp API test context
16541 * @return return code
16544 api_one_pitr_set_locator_set (vat_main_t * vam)
16546 u8 ls_name_set = 0;
16547 unformat_input_t *input = vam->input;
16548 vl_api_one_pitr_set_locator_set_t *mp;
16553 /* Parse args required to build the message */
16554 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16556 if (unformat (input, "del"))
16558 else if (unformat (input, "locator-set %s", &ls_name))
16562 errmsg ("parse error '%U'", format_unformat_error, input);
16569 errmsg ("locator-set name not set!");
16573 M (ONE_PITR_SET_LOCATOR_SET, mp);
16575 mp->is_add = is_add;
16576 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16577 vec_free (ls_name);
16582 /* wait for reply */
16587 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16590 api_one_nsh_set_locator_set (vat_main_t * vam)
16592 u8 ls_name_set = 0;
16593 unformat_input_t *input = vam->input;
16594 vl_api_one_nsh_set_locator_set_t *mp;
16599 /* Parse args required to build the message */
16600 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16602 if (unformat (input, "del"))
16604 else if (unformat (input, "ls %s", &ls_name))
16608 errmsg ("parse error '%U'", format_unformat_error, input);
16613 if (!ls_name_set && is_add)
16615 errmsg ("locator-set name not set!");
16619 M (ONE_NSH_SET_LOCATOR_SET, mp);
16621 mp->is_add = is_add;
16622 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16623 vec_free (ls_name);
16628 /* wait for reply */
16634 api_show_one_pitr (vat_main_t * vam)
16636 vl_api_show_one_pitr_t *mp;
16639 if (!vam->json_output)
16641 print (vam->ofp, "%=20s", "lisp status:");
16644 M (SHOW_ONE_PITR, mp);
16648 /* Wait for a reply... */
16653 #define api_show_lisp_pitr api_show_one_pitr
16656 api_one_use_petr (vat_main_t * vam)
16658 unformat_input_t *input = vam->input;
16659 vl_api_one_use_petr_t *mp;
16664 clib_memset (&ip, 0, sizeof (ip));
16666 /* Parse args required to build the message */
16667 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16669 if (unformat (input, "disable"))
16672 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16675 ip_addr_version (&ip) = IP4;
16678 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16681 ip_addr_version (&ip) = IP6;
16685 errmsg ("parse error '%U'", format_unformat_error, input);
16690 M (ONE_USE_PETR, mp);
16692 mp->is_add = is_add;
16695 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
16697 clib_memcpy (mp->address, &ip, 4);
16699 clib_memcpy (mp->address, &ip, 16);
16705 /* wait for reply */
16710 #define api_lisp_use_petr api_one_use_petr
16713 api_show_one_nsh_mapping (vat_main_t * vam)
16715 vl_api_show_one_use_petr_t *mp;
16718 if (!vam->json_output)
16720 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16723 M (SHOW_ONE_NSH_MAPPING, mp);
16727 /* Wait for a reply... */
16733 api_show_one_use_petr (vat_main_t * vam)
16735 vl_api_show_one_use_petr_t *mp;
16738 if (!vam->json_output)
16740 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16743 M (SHOW_ONE_USE_PETR, mp);
16747 /* Wait for a reply... */
16752 #define api_show_lisp_use_petr api_show_one_use_petr
16755 * Add/delete mapping between vni and vrf
16758 api_one_eid_table_add_del_map (vat_main_t * vam)
16760 unformat_input_t *input = vam->input;
16761 vl_api_one_eid_table_add_del_map_t *mp;
16762 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16763 u32 vni, vrf, bd_index;
16766 /* Parse args required to build the message */
16767 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16769 if (unformat (input, "del"))
16771 else if (unformat (input, "vrf %d", &vrf))
16773 else if (unformat (input, "bd_index %d", &bd_index))
16775 else if (unformat (input, "vni %d", &vni))
16781 if (!vni_set || (!vrf_set && !bd_index_set))
16783 errmsg ("missing arguments!");
16787 if (vrf_set && bd_index_set)
16789 errmsg ("error: both vrf and bd entered!");
16793 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16795 mp->is_add = is_add;
16796 mp->vni = htonl (vni);
16797 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16798 mp->is_l2 = bd_index_set;
16803 /* wait for reply */
16808 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16811 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16813 u32 *action = va_arg (*args, u32 *);
16816 if (unformat (input, "%s", &s))
16818 if (!strcmp ((char *) s, "no-action"))
16820 else if (!strcmp ((char *) s, "natively-forward"))
16822 else if (!strcmp ((char *) s, "send-map-request"))
16824 else if (!strcmp ((char *) s, "drop"))
16828 clib_warning ("invalid action: '%s'", s);
16840 * Add/del remote mapping to/from ONE control plane
16842 * @param vam vpp API test context
16843 * @return return code
16846 api_one_add_del_remote_mapping (vat_main_t * vam)
16848 unformat_input_t *input = vam->input;
16849 vl_api_one_add_del_remote_mapping_t *mp;
16851 lisp_eid_vat_t _eid, *eid = &_eid;
16852 lisp_eid_vat_t _seid, *seid = &_seid;
16853 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
16854 u32 action = ~0, p, w, data_len;
16855 ip4_address_t rloc4;
16856 ip6_address_t rloc6;
16857 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
16860 clib_memset (&rloc, 0, sizeof (rloc));
16862 /* Parse args required to build the message */
16863 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16865 if (unformat (input, "del-all"))
16869 else if (unformat (input, "del"))
16873 else if (unformat (input, "add"))
16877 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16881 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
16885 else if (unformat (input, "vni %d", &vni))
16889 else if (unformat (input, "p %d w %d", &p, &w))
16893 errmsg ("No RLOC configured for setting priority/weight!");
16896 curr_rloc->priority = p;
16897 curr_rloc->weight = w;
16899 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
16902 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
16903 vec_add1 (rlocs, rloc);
16904 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16906 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
16909 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
16910 vec_add1 (rlocs, rloc);
16911 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16913 else if (unformat (input, "action %U",
16914 unformat_negative_mapping_action, &action))
16920 clib_warning ("parse error '%U'", format_unformat_error, input);
16927 errmsg ("missing params!");
16931 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16933 errmsg ("no action set for negative map-reply!");
16937 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16939 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16940 mp->is_add = is_add;
16941 mp->vni = htonl (vni);
16942 mp->action = (u8) action;
16943 mp->is_src_dst = seid_set;
16944 mp->eid_len = eid->len;
16945 mp->seid_len = seid->len;
16946 mp->del_all = del_all;
16947 mp->eid_type = eid->type;
16948 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16949 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
16951 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
16952 clib_memcpy (mp->rlocs, rlocs, data_len);
16958 /* Wait for a reply... */
16963 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
16966 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
16967 * forwarding entries in data-plane accordingly.
16969 * @param vam vpp API test context
16970 * @return return code
16973 api_one_add_del_adjacency (vat_main_t * vam)
16975 unformat_input_t *input = vam->input;
16976 vl_api_one_add_del_adjacency_t *mp;
16978 ip4_address_t leid4, reid4;
16979 ip6_address_t leid6, reid6;
16980 u8 reid_mac[6] = { 0 };
16981 u8 leid_mac[6] = { 0 };
16982 u8 reid_type, leid_type;
16983 u32 leid_len = 0, reid_len = 0, len;
16987 leid_type = reid_type = (u8) ~ 0;
16989 /* Parse args required to build the message */
16990 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16992 if (unformat (input, "del"))
16996 else if (unformat (input, "add"))
17000 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17003 reid_type = 0; /* ipv4 */
17006 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17009 reid_type = 1; /* ipv6 */
17012 else if (unformat (input, "reid %U", unformat_ethernet_address,
17015 reid_type = 2; /* mac */
17017 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17020 leid_type = 0; /* ipv4 */
17023 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17026 leid_type = 1; /* ipv6 */
17029 else if (unformat (input, "leid %U", unformat_ethernet_address,
17032 leid_type = 2; /* mac */
17034 else if (unformat (input, "vni %d", &vni))
17040 errmsg ("parse error '%U'", format_unformat_error, input);
17045 if ((u8) ~ 0 == reid_type)
17047 errmsg ("missing params!");
17051 if (leid_type != reid_type)
17053 errmsg ("remote and local EIDs are of different types!");
17057 M (ONE_ADD_DEL_ADJACENCY, mp);
17058 mp->is_add = is_add;
17059 mp->vni = htonl (vni);
17060 mp->leid_len = leid_len;
17061 mp->reid_len = reid_len;
17062 mp->eid_type = reid_type;
17064 switch (mp->eid_type)
17067 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17068 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17071 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17072 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17075 clib_memcpy (mp->leid, leid_mac, 6);
17076 clib_memcpy (mp->reid, reid_mac, 6);
17079 errmsg ("unknown EID type %d!", mp->eid_type);
17086 /* Wait for a reply... */
17091 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17094 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17096 u32 *mode = va_arg (*args, u32 *);
17098 if (unformat (input, "lisp"))
17100 else if (unformat (input, "vxlan"))
17109 api_gpe_get_encap_mode (vat_main_t * vam)
17111 vl_api_gpe_get_encap_mode_t *mp;
17114 /* Construct the API message */
17115 M (GPE_GET_ENCAP_MODE, mp);
17120 /* Wait for a reply... */
17126 api_gpe_set_encap_mode (vat_main_t * vam)
17128 unformat_input_t *input = vam->input;
17129 vl_api_gpe_set_encap_mode_t *mp;
17133 /* Parse args required to build the message */
17134 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17136 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17142 /* Construct the API message */
17143 M (GPE_SET_ENCAP_MODE, mp);
17150 /* Wait for a reply... */
17156 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17158 unformat_input_t *input = vam->input;
17159 vl_api_gpe_add_del_iface_t *mp;
17160 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17161 u32 dp_table = 0, vni = 0;
17164 /* Parse args required to build the message */
17165 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17167 if (unformat (input, "up"))
17172 else if (unformat (input, "down"))
17177 else if (unformat (input, "table_id %d", &dp_table))
17181 else if (unformat (input, "bd_id %d", &dp_table))
17186 else if (unformat (input, "vni %d", &vni))
17194 if (action_set == 0)
17196 errmsg ("Action not set");
17199 if (dp_table_set == 0 || vni_set == 0)
17201 errmsg ("vni and dp_table must be set");
17205 /* Construct the API message */
17206 M (GPE_ADD_DEL_IFACE, mp);
17208 mp->is_add = is_add;
17209 mp->dp_table = clib_host_to_net_u32 (dp_table);
17211 mp->vni = clib_host_to_net_u32 (vni);
17216 /* Wait for a reply... */
17222 api_one_map_register_fallback_threshold (vat_main_t * vam)
17224 unformat_input_t *input = vam->input;
17225 vl_api_one_map_register_fallback_threshold_t *mp;
17230 /* Parse args required to build the message */
17231 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17233 if (unformat (input, "%u", &value))
17237 clib_warning ("parse error '%U'", format_unformat_error, input);
17244 errmsg ("fallback threshold value is missing!");
17248 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17249 mp->value = clib_host_to_net_u32 (value);
17254 /* Wait for a reply... */
17260 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17262 vl_api_show_one_map_register_fallback_threshold_t *mp;
17265 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17270 /* Wait for a reply... */
17276 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17278 u32 *proto = va_arg (*args, u32 *);
17280 if (unformat (input, "udp"))
17282 else if (unformat (input, "api"))
17291 api_one_set_transport_protocol (vat_main_t * vam)
17293 unformat_input_t *input = vam->input;
17294 vl_api_one_set_transport_protocol_t *mp;
17299 /* Parse args required to build the message */
17300 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17302 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17306 clib_warning ("parse error '%U'", format_unformat_error, input);
17313 errmsg ("Transport protocol missing!");
17317 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17318 mp->protocol = (u8) protocol;
17323 /* Wait for a reply... */
17329 api_one_get_transport_protocol (vat_main_t * vam)
17331 vl_api_one_get_transport_protocol_t *mp;
17334 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17339 /* Wait for a reply... */
17345 api_one_map_register_set_ttl (vat_main_t * vam)
17347 unformat_input_t *input = vam->input;
17348 vl_api_one_map_register_set_ttl_t *mp;
17353 /* Parse args required to build the message */
17354 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17356 if (unformat (input, "%u", &ttl))
17360 clib_warning ("parse error '%U'", format_unformat_error, input);
17367 errmsg ("TTL value missing!");
17371 M (ONE_MAP_REGISTER_SET_TTL, mp);
17372 mp->ttl = clib_host_to_net_u32 (ttl);
17377 /* Wait for a reply... */
17383 api_show_one_map_register_ttl (vat_main_t * vam)
17385 vl_api_show_one_map_register_ttl_t *mp;
17388 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17393 /* Wait for a reply... */
17399 * Add/del map request itr rlocs from ONE control plane and updates
17401 * @param vam vpp API test context
17402 * @return return code
17405 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17407 unformat_input_t *input = vam->input;
17408 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17409 u8 *locator_set_name = 0;
17410 u8 locator_set_name_set = 0;
17414 /* Parse args required to build the message */
17415 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17417 if (unformat (input, "del"))
17421 else if (unformat (input, "%_%v%_", &locator_set_name))
17423 locator_set_name_set = 1;
17427 clib_warning ("parse error '%U'", format_unformat_error, input);
17432 if (is_add && !locator_set_name_set)
17434 errmsg ("itr-rloc is not set!");
17438 if (is_add && vec_len (locator_set_name) > 64)
17440 errmsg ("itr-rloc locator-set name too long");
17441 vec_free (locator_set_name);
17445 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17446 mp->is_add = is_add;
17449 clib_memcpy (mp->locator_set_name, locator_set_name,
17450 vec_len (locator_set_name));
17454 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17456 vec_free (locator_set_name);
17461 /* Wait for a reply... */
17466 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17469 api_one_locator_dump (vat_main_t * vam)
17471 unformat_input_t *input = vam->input;
17472 vl_api_one_locator_dump_t *mp;
17473 vl_api_control_ping_t *mp_ping;
17474 u8 is_index_set = 0, is_name_set = 0;
17479 /* Parse args required to build the message */
17480 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17482 if (unformat (input, "ls_name %_%v%_", &ls_name))
17486 else if (unformat (input, "ls_index %d", &ls_index))
17492 errmsg ("parse error '%U'", format_unformat_error, input);
17497 if (!is_index_set && !is_name_set)
17499 errmsg ("error: expected one of index or name!");
17503 if (is_index_set && is_name_set)
17505 errmsg ("error: only one param expected!");
17509 if (vec_len (ls_name) > 62)
17511 errmsg ("error: locator set name too long!");
17515 if (!vam->json_output)
17517 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17520 M (ONE_LOCATOR_DUMP, mp);
17521 mp->is_index_set = is_index_set;
17524 mp->ls_index = clib_host_to_net_u32 (ls_index);
17527 vec_add1 (ls_name, 0);
17528 strncpy ((char *) mp->ls_name, (char *) ls_name,
17529 sizeof (mp->ls_name) - 1);
17535 /* Use a control ping for synchronization */
17536 MPING (CONTROL_PING, mp_ping);
17539 /* Wait for a reply... */
17544 #define api_lisp_locator_dump api_one_locator_dump
17547 api_one_locator_set_dump (vat_main_t * vam)
17549 vl_api_one_locator_set_dump_t *mp;
17550 vl_api_control_ping_t *mp_ping;
17551 unformat_input_t *input = vam->input;
17555 /* Parse args required to build the message */
17556 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17558 if (unformat (input, "local"))
17562 else if (unformat (input, "remote"))
17568 errmsg ("parse error '%U'", format_unformat_error, input);
17573 if (!vam->json_output)
17575 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17578 M (ONE_LOCATOR_SET_DUMP, mp);
17580 mp->filter = filter;
17585 /* Use a control ping for synchronization */
17586 MPING (CONTROL_PING, mp_ping);
17589 /* Wait for a reply... */
17594 #define api_lisp_locator_set_dump api_one_locator_set_dump
17597 api_one_eid_table_map_dump (vat_main_t * vam)
17601 unformat_input_t *input = vam->input;
17602 vl_api_one_eid_table_map_dump_t *mp;
17603 vl_api_control_ping_t *mp_ping;
17606 /* Parse args required to build the message */
17607 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17609 if (unformat (input, "l2"))
17614 else if (unformat (input, "l3"))
17621 errmsg ("parse error '%U'", format_unformat_error, input);
17628 errmsg ("expected one of 'l2' or 'l3' parameter!");
17632 if (!vam->json_output)
17634 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17637 M (ONE_EID_TABLE_MAP_DUMP, mp);
17643 /* Use a control ping for synchronization */
17644 MPING (CONTROL_PING, mp_ping);
17647 /* Wait for a reply... */
17652 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17655 api_one_eid_table_vni_dump (vat_main_t * vam)
17657 vl_api_one_eid_table_vni_dump_t *mp;
17658 vl_api_control_ping_t *mp_ping;
17661 if (!vam->json_output)
17663 print (vam->ofp, "VNI");
17666 M (ONE_EID_TABLE_VNI_DUMP, mp);
17671 /* Use a control ping for synchronization */
17672 MPING (CONTROL_PING, mp_ping);
17675 /* Wait for a reply... */
17680 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17683 api_one_eid_table_dump (vat_main_t * vam)
17685 unformat_input_t *i = vam->input;
17686 vl_api_one_eid_table_dump_t *mp;
17687 vl_api_control_ping_t *mp_ping;
17688 struct in_addr ip4;
17689 struct in6_addr ip6;
17691 u8 eid_type = ~0, eid_set = 0;
17692 u32 prefix_length = ~0, t, vni = 0;
17695 lisp_nsh_api_t nsh;
17697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17699 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17705 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17711 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17716 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17721 else if (unformat (i, "vni %d", &t))
17725 else if (unformat (i, "local"))
17729 else if (unformat (i, "remote"))
17735 errmsg ("parse error '%U'", format_unformat_error, i);
17740 if (!vam->json_output)
17742 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17743 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17746 M (ONE_EID_TABLE_DUMP, mp);
17748 mp->filter = filter;
17752 mp->vni = htonl (vni);
17753 mp->eid_type = eid_type;
17757 mp->prefix_length = prefix_length;
17758 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17761 mp->prefix_length = prefix_length;
17762 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17765 clib_memcpy (mp->eid, mac, sizeof (mac));
17768 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17771 errmsg ("unknown EID type %d!", eid_type);
17779 /* Use a control ping for synchronization */
17780 MPING (CONTROL_PING, mp_ping);
17783 /* Wait for a reply... */
17788 #define api_lisp_eid_table_dump api_one_eid_table_dump
17791 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17793 unformat_input_t *i = vam->input;
17794 vl_api_gpe_fwd_entries_get_t *mp;
17799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17801 if (unformat (i, "vni %d", &vni))
17807 errmsg ("parse error '%U'", format_unformat_error, i);
17814 errmsg ("vni not set!");
17818 if (!vam->json_output)
17820 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
17824 M (GPE_FWD_ENTRIES_GET, mp);
17825 mp->vni = clib_host_to_net_u32 (vni);
17830 /* Wait for a reply... */
17835 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
17836 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
17837 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
17838 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
17839 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
17840 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
17841 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
17842 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
17845 api_one_adjacencies_get (vat_main_t * vam)
17847 unformat_input_t *i = vam->input;
17848 vl_api_one_adjacencies_get_t *mp;
17853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17855 if (unformat (i, "vni %d", &vni))
17861 errmsg ("parse error '%U'", format_unformat_error, i);
17868 errmsg ("vni not set!");
17872 if (!vam->json_output)
17874 print (vam->ofp, "%s %40s", "leid", "reid");
17877 M (ONE_ADJACENCIES_GET, mp);
17878 mp->vni = clib_host_to_net_u32 (vni);
17883 /* Wait for a reply... */
17888 #define api_lisp_adjacencies_get api_one_adjacencies_get
17891 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
17893 unformat_input_t *i = vam->input;
17894 vl_api_gpe_native_fwd_rpaths_get_t *mp;
17896 u8 ip_family_set = 0, is_ip4 = 1;
17898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17900 if (unformat (i, "ip4"))
17905 else if (unformat (i, "ip6"))
17912 errmsg ("parse error '%U'", format_unformat_error, i);
17917 if (!ip_family_set)
17919 errmsg ("ip family not set!");
17923 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
17924 mp->is_ip4 = is_ip4;
17929 /* Wait for a reply... */
17935 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
17937 vl_api_gpe_fwd_entry_vnis_get_t *mp;
17940 if (!vam->json_output)
17942 print (vam->ofp, "VNIs");
17945 M (GPE_FWD_ENTRY_VNIS_GET, mp);
17950 /* Wait for a reply... */
17956 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
17958 unformat_input_t *i = vam->input;
17959 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
17961 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
17962 struct in_addr ip4;
17963 struct in6_addr ip6;
17964 u32 table_id = 0, nh_sw_if_index = ~0;
17966 clib_memset (&ip4, 0, sizeof (ip4));
17967 clib_memset (&ip6, 0, sizeof (ip6));
17969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17971 if (unformat (i, "del"))
17973 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
17974 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17979 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
17980 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17985 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
17989 nh_sw_if_index = ~0;
17991 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
17995 nh_sw_if_index = ~0;
17997 else if (unformat (i, "table %d", &table_id))
18001 errmsg ("parse error '%U'", format_unformat_error, i);
18008 errmsg ("nh addr not set!");
18012 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18013 mp->is_add = is_add;
18014 mp->table_id = clib_host_to_net_u32 (table_id);
18015 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18016 mp->is_ip4 = is_ip4;
18018 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18020 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18025 /* Wait for a reply... */
18031 api_one_map_server_dump (vat_main_t * vam)
18033 vl_api_one_map_server_dump_t *mp;
18034 vl_api_control_ping_t *mp_ping;
18037 if (!vam->json_output)
18039 print (vam->ofp, "%=20s", "Map server");
18042 M (ONE_MAP_SERVER_DUMP, mp);
18046 /* Use a control ping for synchronization */
18047 MPING (CONTROL_PING, mp_ping);
18050 /* Wait for a reply... */
18055 #define api_lisp_map_server_dump api_one_map_server_dump
18058 api_one_map_resolver_dump (vat_main_t * vam)
18060 vl_api_one_map_resolver_dump_t *mp;
18061 vl_api_control_ping_t *mp_ping;
18064 if (!vam->json_output)
18066 print (vam->ofp, "%=20s", "Map resolver");
18069 M (ONE_MAP_RESOLVER_DUMP, mp);
18073 /* Use a control ping for synchronization */
18074 MPING (CONTROL_PING, mp_ping);
18077 /* Wait for a reply... */
18082 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18085 api_one_stats_flush (vat_main_t * vam)
18087 vl_api_one_stats_flush_t *mp;
18090 M (ONE_STATS_FLUSH, mp);
18097 api_one_stats_dump (vat_main_t * vam)
18099 vl_api_one_stats_dump_t *mp;
18100 vl_api_control_ping_t *mp_ping;
18103 M (ONE_STATS_DUMP, mp);
18107 /* Use a control ping for synchronization */
18108 MPING (CONTROL_PING, mp_ping);
18111 /* Wait for a reply... */
18117 api_show_one_status (vat_main_t * vam)
18119 vl_api_show_one_status_t *mp;
18122 if (!vam->json_output)
18124 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18127 M (SHOW_ONE_STATUS, mp);
18130 /* Wait for a reply... */
18135 #define api_show_lisp_status api_show_one_status
18138 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18140 vl_api_gpe_fwd_entry_path_dump_t *mp;
18141 vl_api_control_ping_t *mp_ping;
18142 unformat_input_t *i = vam->input;
18143 u32 fwd_entry_index = ~0;
18146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18148 if (unformat (i, "index %d", &fwd_entry_index))
18154 if (~0 == fwd_entry_index)
18156 errmsg ("no index specified!");
18160 if (!vam->json_output)
18162 print (vam->ofp, "first line");
18165 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18169 /* Use a control ping for synchronization */
18170 MPING (CONTROL_PING, mp_ping);
18173 /* Wait for a reply... */
18179 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18181 vl_api_one_get_map_request_itr_rlocs_t *mp;
18184 if (!vam->json_output)
18186 print (vam->ofp, "%=20s", "itr-rlocs:");
18189 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18192 /* Wait for a reply... */
18197 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18200 api_af_packet_create (vat_main_t * vam)
18202 unformat_input_t *i = vam->input;
18203 vl_api_af_packet_create_t *mp;
18204 u8 *host_if_name = 0;
18206 u8 random_hw_addr = 1;
18209 clib_memset (hw_addr, 0, sizeof (hw_addr));
18211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18213 if (unformat (i, "name %s", &host_if_name))
18214 vec_add1 (host_if_name, 0);
18215 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18216 random_hw_addr = 0;
18221 if (!vec_len (host_if_name))
18223 errmsg ("host-interface name must be specified");
18227 if (vec_len (host_if_name) > 64)
18229 errmsg ("host-interface name too long");
18233 M (AF_PACKET_CREATE, mp);
18235 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18236 clib_memcpy (mp->hw_addr, hw_addr, 6);
18237 mp->use_random_hw_addr = random_hw_addr;
18238 vec_free (host_if_name);
18246 fprintf (vam->ofp ? vam->ofp : stderr,
18247 " new sw_if_index = %d\n", vam->sw_if_index);
18254 api_af_packet_delete (vat_main_t * vam)
18256 unformat_input_t *i = vam->input;
18257 vl_api_af_packet_delete_t *mp;
18258 u8 *host_if_name = 0;
18261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18263 if (unformat (i, "name %s", &host_if_name))
18264 vec_add1 (host_if_name, 0);
18269 if (!vec_len (host_if_name))
18271 errmsg ("host-interface name must be specified");
18275 if (vec_len (host_if_name) > 64)
18277 errmsg ("host-interface name too long");
18281 M (AF_PACKET_DELETE, mp);
18283 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18284 vec_free (host_if_name);
18291 static void vl_api_af_packet_details_t_handler
18292 (vl_api_af_packet_details_t * mp)
18294 vat_main_t *vam = &vat_main;
18296 print (vam->ofp, "%-16s %d",
18297 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18300 static void vl_api_af_packet_details_t_handler_json
18301 (vl_api_af_packet_details_t * mp)
18303 vat_main_t *vam = &vat_main;
18304 vat_json_node_t *node = NULL;
18306 if (VAT_JSON_ARRAY != vam->json_tree.type)
18308 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18309 vat_json_init_array (&vam->json_tree);
18311 node = vat_json_array_add (&vam->json_tree);
18313 vat_json_init_object (node);
18314 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18315 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18319 api_af_packet_dump (vat_main_t * vam)
18321 vl_api_af_packet_dump_t *mp;
18322 vl_api_control_ping_t *mp_ping;
18325 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18326 /* Get list of tap interfaces */
18327 M (AF_PACKET_DUMP, mp);
18330 /* Use a control ping for synchronization */
18331 MPING (CONTROL_PING, mp_ping);
18339 api_policer_add_del (vat_main_t * vam)
18341 unformat_input_t *i = vam->input;
18342 vl_api_policer_add_del_t *mp;
18352 u8 color_aware = 0;
18353 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18356 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18357 conform_action.dscp = 0;
18358 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18359 exceed_action.dscp = 0;
18360 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18361 violate_action.dscp = 0;
18363 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18365 if (unformat (i, "del"))
18367 else if (unformat (i, "name %s", &name))
18368 vec_add1 (name, 0);
18369 else if (unformat (i, "cir %u", &cir))
18371 else if (unformat (i, "eir %u", &eir))
18373 else if (unformat (i, "cb %u", &cb))
18375 else if (unformat (i, "eb %u", &eb))
18377 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18380 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18383 else if (unformat (i, "type %U", unformat_policer_type, &type))
18385 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18388 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18391 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18394 else if (unformat (i, "color-aware"))
18400 if (!vec_len (name))
18402 errmsg ("policer name must be specified");
18406 if (vec_len (name) > 64)
18408 errmsg ("policer name too long");
18412 M (POLICER_ADD_DEL, mp);
18414 clib_memcpy (mp->name, name, vec_len (name));
18416 mp->is_add = is_add;
18417 mp->cir = ntohl (cir);
18418 mp->eir = ntohl (eir);
18419 mp->cb = clib_net_to_host_u64 (cb);
18420 mp->eb = clib_net_to_host_u64 (eb);
18421 mp->rate_type = rate_type;
18422 mp->round_type = round_type;
18424 mp->conform_action_type = conform_action.action_type;
18425 mp->conform_dscp = conform_action.dscp;
18426 mp->exceed_action_type = exceed_action.action_type;
18427 mp->exceed_dscp = exceed_action.dscp;
18428 mp->violate_action_type = violate_action.action_type;
18429 mp->violate_dscp = violate_action.dscp;
18430 mp->color_aware = color_aware;
18438 api_policer_dump (vat_main_t * vam)
18440 unformat_input_t *i = vam->input;
18441 vl_api_policer_dump_t *mp;
18442 vl_api_control_ping_t *mp_ping;
18443 u8 *match_name = 0;
18444 u8 match_name_valid = 0;
18447 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18449 if (unformat (i, "name %s", &match_name))
18451 vec_add1 (match_name, 0);
18452 match_name_valid = 1;
18458 M (POLICER_DUMP, mp);
18459 mp->match_name_valid = match_name_valid;
18460 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18461 vec_free (match_name);
18465 /* Use a control ping for synchronization */
18466 MPING (CONTROL_PING, mp_ping);
18469 /* Wait for a reply... */
18475 api_policer_classify_set_interface (vat_main_t * vam)
18477 unformat_input_t *i = vam->input;
18478 vl_api_policer_classify_set_interface_t *mp;
18480 int sw_if_index_set;
18481 u32 ip4_table_index = ~0;
18482 u32 ip6_table_index = ~0;
18483 u32 l2_table_index = ~0;
18487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18489 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18490 sw_if_index_set = 1;
18491 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18492 sw_if_index_set = 1;
18493 else if (unformat (i, "del"))
18495 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18497 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18499 else if (unformat (i, "l2-table %d", &l2_table_index))
18503 clib_warning ("parse error '%U'", format_unformat_error, i);
18508 if (sw_if_index_set == 0)
18510 errmsg ("missing interface name or sw_if_index");
18514 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18516 mp->sw_if_index = ntohl (sw_if_index);
18517 mp->ip4_table_index = ntohl (ip4_table_index);
18518 mp->ip6_table_index = ntohl (ip6_table_index);
18519 mp->l2_table_index = ntohl (l2_table_index);
18520 mp->is_add = is_add;
18528 api_policer_classify_dump (vat_main_t * vam)
18530 unformat_input_t *i = vam->input;
18531 vl_api_policer_classify_dump_t *mp;
18532 vl_api_control_ping_t *mp_ping;
18533 u8 type = POLICER_CLASSIFY_N_TABLES;
18536 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18540 errmsg ("classify table type must be specified");
18544 if (!vam->json_output)
18546 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18549 M (POLICER_CLASSIFY_DUMP, mp);
18554 /* Use a control ping for synchronization */
18555 MPING (CONTROL_PING, mp_ping);
18558 /* Wait for a reply... */
18564 api_netmap_create (vat_main_t * vam)
18566 unformat_input_t *i = vam->input;
18567 vl_api_netmap_create_t *mp;
18570 u8 random_hw_addr = 1;
18575 clib_memset (hw_addr, 0, sizeof (hw_addr));
18577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18579 if (unformat (i, "name %s", &if_name))
18580 vec_add1 (if_name, 0);
18581 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18582 random_hw_addr = 0;
18583 else if (unformat (i, "pipe"))
18585 else if (unformat (i, "master"))
18587 else if (unformat (i, "slave"))
18593 if (!vec_len (if_name))
18595 errmsg ("interface name must be specified");
18599 if (vec_len (if_name) > 64)
18601 errmsg ("interface name too long");
18605 M (NETMAP_CREATE, mp);
18607 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18608 clib_memcpy (mp->hw_addr, hw_addr, 6);
18609 mp->use_random_hw_addr = random_hw_addr;
18610 mp->is_pipe = is_pipe;
18611 mp->is_master = is_master;
18612 vec_free (if_name);
18620 api_netmap_delete (vat_main_t * vam)
18622 unformat_input_t *i = vam->input;
18623 vl_api_netmap_delete_t *mp;
18627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18629 if (unformat (i, "name %s", &if_name))
18630 vec_add1 (if_name, 0);
18635 if (!vec_len (if_name))
18637 errmsg ("interface name must be specified");
18641 if (vec_len (if_name) > 64)
18643 errmsg ("interface name too long");
18647 M (NETMAP_DELETE, mp);
18649 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18650 vec_free (if_name);
18658 format_fib_api_path_nh_proto (u8 * s, va_list * args)
18660 vl_api_fib_path_nh_proto_t proto =
18661 va_arg (*args, vl_api_fib_path_nh_proto_t);
18665 case FIB_API_PATH_NH_PROTO_IP4:
18666 s = format (s, "ip4");
18668 case FIB_API_PATH_NH_PROTO_IP6:
18669 s = format (s, "ip6");
18671 case FIB_API_PATH_NH_PROTO_MPLS:
18672 s = format (s, "mpls");
18674 case FIB_API_PATH_NH_PROTO_BIER:
18675 s = format (s, "bier");
18677 case FIB_API_PATH_NH_PROTO_ETHERNET:
18678 s = format (s, "ethernet");
18686 format_vl_api_ip_address_union (u8 * s, va_list * args)
18688 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
18689 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
18694 s = format (s, "%U", format_ip4_address, u->ip4);
18697 s = format (s, "%U", format_ip6_address, u->ip6);
18704 format_vl_api_fib_path_type (u8 * s, va_list * args)
18706 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
18710 case FIB_API_PATH_TYPE_NORMAL:
18711 s = format (s, "normal");
18713 case FIB_API_PATH_TYPE_LOCAL:
18714 s = format (s, "local");
18716 case FIB_API_PATH_TYPE_DROP:
18717 s = format (s, "drop");
18719 case FIB_API_PATH_TYPE_UDP_ENCAP:
18720 s = format (s, "udp-encap");
18722 case FIB_API_PATH_TYPE_BIER_IMP:
18723 s = format (s, "bier-imp");
18725 case FIB_API_PATH_TYPE_ICMP_UNREACH:
18726 s = format (s, "unreach");
18728 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
18729 s = format (s, "prohibit");
18731 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
18732 s = format (s, "src-lookup");
18734 case FIB_API_PATH_TYPE_DVR:
18735 s = format (s, "dvr");
18737 case FIB_API_PATH_TYPE_INTERFACE_RX:
18738 s = format (s, "interface-rx");
18740 case FIB_API_PATH_TYPE_CLASSIFY:
18741 s = format (s, "classify");
18749 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
18752 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
18753 ntohl (fp->weight), ntohl (fp->sw_if_index),
18754 format_vl_api_fib_path_type, fp->type,
18755 format_fib_api_path_nh_proto, fp->proto,
18756 format_vl_api_ip_address_union, &fp->nh.address);
18760 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18761 vl_api_fib_path_t * fp)
18763 struct in_addr ip4;
18764 struct in6_addr ip6;
18766 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18767 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18768 vat_json_object_add_uint (node, "type", fp->type);
18769 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
18770 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18772 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
18773 vat_json_object_add_ip4 (node, "next_hop", ip4);
18775 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18777 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
18778 vat_json_object_add_ip6 (node, "next_hop", ip6);
18783 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18785 vat_main_t *vam = &vat_main;
18786 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18787 vl_api_fib_path_t *fp;
18790 print (vam->ofp, "sw_if_index %d via:",
18791 ntohl (mp->mt_tunnel.mt_sw_if_index));
18792 fp = mp->mt_tunnel.mt_paths;
18793 for (i = 0; i < count; i++)
18795 vl_api_fib_path_print (vam, fp);
18799 print (vam->ofp, "");
18802 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18803 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18806 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18808 vat_main_t *vam = &vat_main;
18809 vat_json_node_t *node = NULL;
18810 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18811 vl_api_fib_path_t *fp;
18814 if (VAT_JSON_ARRAY != vam->json_tree.type)
18816 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18817 vat_json_init_array (&vam->json_tree);
18819 node = vat_json_array_add (&vam->json_tree);
18821 vat_json_init_object (node);
18822 vat_json_object_add_uint (node, "sw_if_index",
18823 ntohl (mp->mt_tunnel.mt_sw_if_index));
18825 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
18827 fp = mp->mt_tunnel.mt_paths;
18828 for (i = 0; i < count; i++)
18830 vl_api_mpls_fib_path_json_print (node, fp);
18836 api_mpls_tunnel_dump (vat_main_t * vam)
18838 vl_api_mpls_tunnel_dump_t *mp;
18839 vl_api_control_ping_t *mp_ping;
18842 M (MPLS_TUNNEL_DUMP, mp);
18846 /* Use a control ping for synchronization */
18847 MPING (CONTROL_PING, mp_ping);
18854 #define vl_api_mpls_table_details_t_endian vl_noop_handler
18855 #define vl_api_mpls_table_details_t_print vl_noop_handler
18859 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
18861 vat_main_t *vam = &vat_main;
18863 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
18866 static void vl_api_mpls_table_details_t_handler_json
18867 (vl_api_mpls_table_details_t * mp)
18869 vat_main_t *vam = &vat_main;
18870 vat_json_node_t *node = NULL;
18872 if (VAT_JSON_ARRAY != vam->json_tree.type)
18874 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18875 vat_json_init_array (&vam->json_tree);
18877 node = vat_json_array_add (&vam->json_tree);
18879 vat_json_init_object (node);
18880 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
18884 api_mpls_table_dump (vat_main_t * vam)
18886 vl_api_mpls_table_dump_t *mp;
18887 vl_api_control_ping_t *mp_ping;
18890 M (MPLS_TABLE_DUMP, mp);
18893 /* Use a control ping for synchronization */
18894 MPING (CONTROL_PING, mp_ping);
18901 #define vl_api_mpls_route_details_t_endian vl_noop_handler
18902 #define vl_api_mpls_route_details_t_print vl_noop_handler
18905 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
18907 vat_main_t *vam = &vat_main;
18908 int count = ntohl (mp->mr_route.mr_n_paths);
18909 vl_api_fib_path_t *fp;
18913 "table-id %d, label %u, ess_bit %u",
18914 ntohl (mp->mr_route.mr_table_id),
18915 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
18916 fp = mp->mr_route.mr_paths;
18917 for (i = 0; i < count; i++)
18919 vl_api_fib_path_print (vam, fp);
18924 static void vl_api_mpls_route_details_t_handler_json
18925 (vl_api_mpls_route_details_t * mp)
18927 vat_main_t *vam = &vat_main;
18928 int count = ntohl (mp->mr_route.mr_n_paths);
18929 vat_json_node_t *node = NULL;
18930 vl_api_fib_path_t *fp;
18933 if (VAT_JSON_ARRAY != vam->json_tree.type)
18935 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18936 vat_json_init_array (&vam->json_tree);
18938 node = vat_json_array_add (&vam->json_tree);
18940 vat_json_init_object (node);
18941 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
18942 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
18943 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
18944 vat_json_object_add_uint (node, "path_count", count);
18945 fp = mp->mr_route.mr_paths;
18946 for (i = 0; i < count; i++)
18948 vl_api_mpls_fib_path_json_print (node, fp);
18954 api_mpls_route_dump (vat_main_t * vam)
18956 unformat_input_t *input = vam->input;
18957 vl_api_mpls_route_dump_t *mp;
18958 vl_api_control_ping_t *mp_ping;
18962 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18964 if (unformat (input, "table_id %d", &table_id))
18969 if (table_id == ~0)
18971 errmsg ("missing table id");
18975 M (MPLS_ROUTE_DUMP, mp);
18977 mp->table.mt_table_id = ntohl (table_id);
18980 /* Use a control ping for synchronization */
18981 MPING (CONTROL_PING, mp_ping);
18988 #define vl_api_ip_table_details_t_endian vl_noop_handler
18989 #define vl_api_ip_table_details_t_print vl_noop_handler
18992 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
18994 vat_main_t *vam = &vat_main;
18997 "%s; table-id %d, prefix %U/%d",
18998 mp->table.name, ntohl (mp->table.table_id));
19002 static void vl_api_ip_table_details_t_handler_json
19003 (vl_api_ip_table_details_t * mp)
19005 vat_main_t *vam = &vat_main;
19006 vat_json_node_t *node = NULL;
19008 if (VAT_JSON_ARRAY != vam->json_tree.type)
19010 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19011 vat_json_init_array (&vam->json_tree);
19013 node = vat_json_array_add (&vam->json_tree);
19015 vat_json_init_object (node);
19016 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
19020 api_ip_table_dump (vat_main_t * vam)
19022 vl_api_ip_table_dump_t *mp;
19023 vl_api_control_ping_t *mp_ping;
19026 M (IP_TABLE_DUMP, mp);
19029 /* Use a control ping for synchronization */
19030 MPING (CONTROL_PING, mp_ping);
19038 api_ip_mtable_dump (vat_main_t * vam)
19040 vl_api_ip_mtable_dump_t *mp;
19041 vl_api_control_ping_t *mp_ping;
19044 M (IP_MTABLE_DUMP, mp);
19047 /* Use a control ping for synchronization */
19048 MPING (CONTROL_PING, mp_ping);
19056 api_ip_mroute_dump (vat_main_t * vam)
19058 unformat_input_t *input = vam->input;
19059 vl_api_control_ping_t *mp_ping;
19060 vl_api_ip_mroute_dump_t *mp;
19065 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19067 if (unformat (input, "table_id %d", &table_id))
19069 else if (unformat (input, "ip6"))
19071 else if (unformat (input, "ip4"))
19076 if (table_id == ~0)
19078 errmsg ("missing table id");
19082 M (IP_MROUTE_DUMP, mp);
19083 mp->table.table_id = table_id;
19084 mp->table.is_ip6 = is_ip6;
19087 /* Use a control ping for synchronization */
19088 MPING (CONTROL_PING, mp_ping);
19095 static void vl_api_ip_neighbor_details_t_handler
19096 (vl_api_ip_neighbor_details_t * mp)
19098 vat_main_t *vam = &vat_main;
19100 print (vam->ofp, "%c %U %U",
19101 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19102 format_vl_api_mac_address, &mp->neighbor.mac_address,
19103 format_vl_api_address, &mp->neighbor.ip_address);
19106 static void vl_api_ip_neighbor_details_t_handler_json
19107 (vl_api_ip_neighbor_details_t * mp)
19110 vat_main_t *vam = &vat_main;
19111 vat_json_node_t *node;
19113 if (VAT_JSON_ARRAY != vam->json_tree.type)
19115 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19116 vat_json_init_array (&vam->json_tree);
19118 node = vat_json_array_add (&vam->json_tree);
19120 vat_json_init_object (node);
19121 vat_json_object_add_string_copy
19123 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19124 (u8 *) "static" : (u8 *) "dynamic"));
19126 vat_json_object_add_string_copy (node, "link_layer",
19127 format (0, "%U", format_vl_api_mac_address,
19128 &mp->neighbor.mac_address));
19129 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19133 api_ip_neighbor_dump (vat_main_t * vam)
19135 unformat_input_t *i = vam->input;
19136 vl_api_ip_neighbor_dump_t *mp;
19137 vl_api_control_ping_t *mp_ping;
19139 u32 sw_if_index = ~0;
19142 /* Parse args required to build the message */
19143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19145 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19147 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19149 else if (unformat (i, "ip6"))
19155 if (sw_if_index == ~0)
19157 errmsg ("missing interface name or sw_if_index");
19161 M (IP_NEIGHBOR_DUMP, mp);
19162 mp->is_ipv6 = (u8) is_ipv6;
19163 mp->sw_if_index = ntohl (sw_if_index);
19166 /* Use a control ping for synchronization */
19167 MPING (CONTROL_PING, mp_ping);
19174 #define vl_api_ip_route_details_t_endian vl_noop_handler
19175 #define vl_api_ip_route_details_t_print vl_noop_handler
19178 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
19180 vat_main_t *vam = &vat_main;
19181 u8 count = mp->route.n_paths;
19182 vl_api_fib_path_t *fp;
19186 "table-id %d, prefix %U/%d",
19187 ntohl (mp->route.table_id),
19188 format_ip46_address,
19189 mp->route.prefix.address, mp->route.prefix.address_length);
19190 for (i = 0; i < count; i++)
19192 fp = &mp->route.paths[i];
19194 vl_api_fib_path_print (vam, fp);
19199 static void vl_api_ip_route_details_t_handler_json
19200 (vl_api_ip_route_details_t * mp)
19202 vat_main_t *vam = &vat_main;
19203 u8 count = mp->route.n_paths;
19204 vat_json_node_t *node = NULL;
19205 struct in_addr ip4;
19206 struct in6_addr ip6;
19207 vl_api_fib_path_t *fp;
19210 if (VAT_JSON_ARRAY != vam->json_tree.type)
19212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19213 vat_json_init_array (&vam->json_tree);
19215 node = vat_json_array_add (&vam->json_tree);
19217 vat_json_init_object (node);
19218 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
19219 if (ADDRESS_IP6 == mp->route.prefix.address.af)
19221 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
19222 vat_json_object_add_ip6 (node, "prefix", ip6);
19226 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
19227 vat_json_object_add_ip4 (node, "prefix", ip4);
19229 vat_json_object_add_uint (node, "mask_length",
19230 mp->route.prefix.address_length);
19231 vat_json_object_add_uint (node, "path_count", count);
19232 for (i = 0; i < count; i++)
19234 fp = &mp->route.paths[i];
19235 vl_api_mpls_fib_path_json_print (node, fp);
19240 api_ip_route_dump (vat_main_t * vam)
19242 unformat_input_t *input = vam->input;
19243 vl_api_ip_route_dump_t *mp;
19244 vl_api_control_ping_t *mp_ping;
19250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19252 if (unformat (input, "table_id %d", &table_id))
19254 else if (unformat (input, "ip6"))
19256 else if (unformat (input, "ip4"))
19261 if (table_id == ~0)
19263 errmsg ("missing table id");
19267 M (IP_ROUTE_DUMP, mp);
19269 mp->table.table_id = table_id;
19270 mp->table.is_ip6 = is_ip6;
19274 /* Use a control ping for synchronization */
19275 MPING (CONTROL_PING, mp_ping);
19283 api_classify_table_ids (vat_main_t * vam)
19285 vl_api_classify_table_ids_t *mp;
19288 /* Construct the API message */
19289 M (CLASSIFY_TABLE_IDS, mp);
19298 api_classify_table_by_interface (vat_main_t * vam)
19300 unformat_input_t *input = vam->input;
19301 vl_api_classify_table_by_interface_t *mp;
19303 u32 sw_if_index = ~0;
19305 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19307 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19309 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19314 if (sw_if_index == ~0)
19316 errmsg ("missing interface name or sw_if_index");
19320 /* Construct the API message */
19321 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19323 mp->sw_if_index = ntohl (sw_if_index);
19331 api_classify_table_info (vat_main_t * vam)
19333 unformat_input_t *input = vam->input;
19334 vl_api_classify_table_info_t *mp;
19338 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19340 if (unformat (input, "table_id %d", &table_id))
19345 if (table_id == ~0)
19347 errmsg ("missing table id");
19351 /* Construct the API message */
19352 M (CLASSIFY_TABLE_INFO, mp);
19354 mp->table_id = ntohl (table_id);
19362 api_classify_session_dump (vat_main_t * vam)
19364 unformat_input_t *input = vam->input;
19365 vl_api_classify_session_dump_t *mp;
19366 vl_api_control_ping_t *mp_ping;
19370 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19372 if (unformat (input, "table_id %d", &table_id))
19377 if (table_id == ~0)
19379 errmsg ("missing table id");
19383 /* Construct the API message */
19384 M (CLASSIFY_SESSION_DUMP, mp);
19386 mp->table_id = ntohl (table_id);
19389 /* Use a control ping for synchronization */
19390 MPING (CONTROL_PING, mp_ping);
19398 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19400 vat_main_t *vam = &vat_main;
19402 print (vam->ofp, "collector_address %U, collector_port %d, "
19403 "src_address %U, vrf_id %d, path_mtu %u, "
19404 "template_interval %u, udp_checksum %d",
19405 format_ip4_address, mp->collector_address,
19406 ntohs (mp->collector_port),
19407 format_ip4_address, mp->src_address,
19408 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19409 ntohl (mp->template_interval), mp->udp_checksum);
19412 vam->result_ready = 1;
19416 vl_api_ipfix_exporter_details_t_handler_json
19417 (vl_api_ipfix_exporter_details_t * mp)
19419 vat_main_t *vam = &vat_main;
19420 vat_json_node_t node;
19421 struct in_addr collector_address;
19422 struct in_addr src_address;
19424 vat_json_init_object (&node);
19425 clib_memcpy (&collector_address, &mp->collector_address,
19426 sizeof (collector_address));
19427 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19428 vat_json_object_add_uint (&node, "collector_port",
19429 ntohs (mp->collector_port));
19430 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19431 vat_json_object_add_ip4 (&node, "src_address", src_address);
19432 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19433 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19434 vat_json_object_add_uint (&node, "template_interval",
19435 ntohl (mp->template_interval));
19436 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19438 vat_json_print (vam->ofp, &node);
19439 vat_json_free (&node);
19441 vam->result_ready = 1;
19445 api_ipfix_exporter_dump (vat_main_t * vam)
19447 vl_api_ipfix_exporter_dump_t *mp;
19450 /* Construct the API message */
19451 M (IPFIX_EXPORTER_DUMP, mp);
19460 api_ipfix_classify_stream_dump (vat_main_t * vam)
19462 vl_api_ipfix_classify_stream_dump_t *mp;
19465 /* Construct the API message */
19466 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19477 vl_api_ipfix_classify_stream_details_t_handler
19478 (vl_api_ipfix_classify_stream_details_t * mp)
19480 vat_main_t *vam = &vat_main;
19481 print (vam->ofp, "domain_id %d, src_port %d",
19482 ntohl (mp->domain_id), ntohs (mp->src_port));
19484 vam->result_ready = 1;
19488 vl_api_ipfix_classify_stream_details_t_handler_json
19489 (vl_api_ipfix_classify_stream_details_t * mp)
19491 vat_main_t *vam = &vat_main;
19492 vat_json_node_t node;
19494 vat_json_init_object (&node);
19495 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19496 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19498 vat_json_print (vam->ofp, &node);
19499 vat_json_free (&node);
19501 vam->result_ready = 1;
19505 api_ipfix_classify_table_dump (vat_main_t * vam)
19507 vl_api_ipfix_classify_table_dump_t *mp;
19508 vl_api_control_ping_t *mp_ping;
19511 if (!vam->json_output)
19513 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19514 "transport_protocol");
19517 /* Construct the API message */
19518 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19523 /* Use a control ping for synchronization */
19524 MPING (CONTROL_PING, mp_ping);
19532 vl_api_ipfix_classify_table_details_t_handler
19533 (vl_api_ipfix_classify_table_details_t * mp)
19535 vat_main_t *vam = &vat_main;
19536 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19537 mp->transport_protocol);
19541 vl_api_ipfix_classify_table_details_t_handler_json
19542 (vl_api_ipfix_classify_table_details_t * mp)
19544 vat_json_node_t *node = NULL;
19545 vat_main_t *vam = &vat_main;
19547 if (VAT_JSON_ARRAY != vam->json_tree.type)
19549 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19550 vat_json_init_array (&vam->json_tree);
19553 node = vat_json_array_add (&vam->json_tree);
19554 vat_json_init_object (node);
19556 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19557 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19558 vat_json_object_add_uint (node, "transport_protocol",
19559 mp->transport_protocol);
19563 api_sw_interface_span_enable_disable (vat_main_t * vam)
19565 unformat_input_t *i = vam->input;
19566 vl_api_sw_interface_span_enable_disable_t *mp;
19567 u32 src_sw_if_index = ~0;
19568 u32 dst_sw_if_index = ~0;
19573 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19576 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19578 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19582 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19584 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19586 else if (unformat (i, "disable"))
19588 else if (unformat (i, "rx"))
19590 else if (unformat (i, "tx"))
19592 else if (unformat (i, "both"))
19594 else if (unformat (i, "l2"))
19600 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19602 mp->sw_if_index_from = htonl (src_sw_if_index);
19603 mp->sw_if_index_to = htonl (dst_sw_if_index);
19613 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19616 vat_main_t *vam = &vat_main;
19617 u8 *sw_if_from_name = 0;
19618 u8 *sw_if_to_name = 0;
19619 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19620 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19621 char *states[] = { "none", "rx", "tx", "both" };
19625 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19627 if ((u32) p->value[0] == sw_if_index_from)
19629 sw_if_from_name = (u8 *)(p->key);
19633 if ((u32) p->value[0] == sw_if_index_to)
19635 sw_if_to_name = (u8 *)(p->key);
19636 if (sw_if_from_name)
19641 print (vam->ofp, "%20s => %20s (%s) %s",
19642 sw_if_from_name, sw_if_to_name, states[mp->state],
19643 mp->is_l2 ? "l2" : "device");
19647 vl_api_sw_interface_span_details_t_handler_json
19648 (vl_api_sw_interface_span_details_t * mp)
19650 vat_main_t *vam = &vat_main;
19651 vat_json_node_t *node = NULL;
19652 u8 *sw_if_from_name = 0;
19653 u8 *sw_if_to_name = 0;
19654 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19655 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19659 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19661 if ((u32) p->value[0] == sw_if_index_from)
19663 sw_if_from_name = (u8 *)(p->key);
19667 if ((u32) p->value[0] == sw_if_index_to)
19669 sw_if_to_name = (u8 *)(p->key);
19670 if (sw_if_from_name)
19676 if (VAT_JSON_ARRAY != vam->json_tree.type)
19678 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19679 vat_json_init_array (&vam->json_tree);
19681 node = vat_json_array_add (&vam->json_tree);
19683 vat_json_init_object (node);
19684 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19685 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19686 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19687 if (0 != sw_if_to_name)
19689 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19691 vat_json_object_add_uint (node, "state", mp->state);
19692 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19696 api_sw_interface_span_dump (vat_main_t * vam)
19698 unformat_input_t *input = vam->input;
19699 vl_api_sw_interface_span_dump_t *mp;
19700 vl_api_control_ping_t *mp_ping;
19704 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19706 if (unformat (input, "l2"))
19712 M (SW_INTERFACE_SPAN_DUMP, mp);
19716 /* Use a control ping for synchronization */
19717 MPING (CONTROL_PING, mp_ping);
19725 api_pg_create_interface (vat_main_t * vam)
19727 unformat_input_t *input = vam->input;
19728 vl_api_pg_create_interface_t *mp;
19732 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19734 if (unformat (input, "if_id %d", &if_id))
19741 errmsg ("missing pg interface index");
19745 /* Construct the API message */
19746 M (PG_CREATE_INTERFACE, mp);
19748 mp->interface_id = ntohl (if_id);
19756 api_pg_capture (vat_main_t * vam)
19758 unformat_input_t *input = vam->input;
19759 vl_api_pg_capture_t *mp;
19764 u8 pcap_file_set = 0;
19767 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19769 if (unformat (input, "if_id %d", &if_id))
19771 else if (unformat (input, "pcap %s", &pcap_file))
19773 else if (unformat (input, "count %d", &count))
19775 else if (unformat (input, "disable"))
19782 errmsg ("missing pg interface index");
19785 if (pcap_file_set > 0)
19787 if (vec_len (pcap_file) > 255)
19789 errmsg ("pcap file name is too long");
19794 u32 name_len = vec_len (pcap_file);
19795 /* Construct the API message */
19796 M (PG_CAPTURE, mp);
19798 mp->interface_id = ntohl (if_id);
19799 mp->is_enabled = enable;
19800 mp->count = ntohl (count);
19801 mp->pcap_name_length = ntohl (name_len);
19802 if (pcap_file_set != 0)
19804 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19806 vec_free (pcap_file);
19814 api_pg_enable_disable (vat_main_t * vam)
19816 unformat_input_t *input = vam->input;
19817 vl_api_pg_enable_disable_t *mp;
19820 u8 stream_name_set = 0;
19821 u8 *stream_name = 0;
19823 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19825 if (unformat (input, "stream %s", &stream_name))
19826 stream_name_set = 1;
19827 else if (unformat (input, "disable"))
19833 if (stream_name_set > 0)
19835 if (vec_len (stream_name) > 255)
19837 errmsg ("stream name too long");
19842 u32 name_len = vec_len (stream_name);
19843 /* Construct the API message */
19844 M (PG_ENABLE_DISABLE, mp);
19846 mp->is_enabled = enable;
19847 if (stream_name_set != 0)
19849 mp->stream_name_length = ntohl (name_len);
19850 clib_memcpy (mp->stream_name, stream_name, name_len);
19852 vec_free (stream_name);
19860 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19862 unformat_input_t *input = vam->input;
19863 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19865 u16 *low_ports = 0;
19866 u16 *high_ports = 0;
19869 vl_api_prefix_t prefix;
19876 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19878 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
19880 else if (unformat (input, "vrf %d", &vrf_id))
19882 else if (unformat (input, "del"))
19884 else if (unformat (input, "port %d", &tmp))
19886 if (tmp == 0 || tmp > 65535)
19888 errmsg ("port %d out of range", tmp);
19892 this_hi = this_low + 1;
19893 vec_add1 (low_ports, this_low);
19894 vec_add1 (high_ports, this_hi);
19896 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19898 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19900 errmsg ("incorrect range parameters");
19904 /* Note: in debug CLI +1 is added to high before
19905 passing to real fn that does "the work"
19906 (ip_source_and_port_range_check_add_del).
19907 This fn is a wrapper around the binary API fn a
19908 control plane will call, which expects this increment
19909 to have occurred. Hence letting the binary API control
19910 plane fn do the increment for consistency between VAT
19911 and other control planes.
19914 vec_add1 (low_ports, this_low);
19915 vec_add1 (high_ports, this_hi);
19921 if (prefix_set == 0)
19923 errmsg ("<address>/<mask> not specified");
19929 errmsg ("VRF ID required, not specified");
19936 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19940 if (vec_len (low_ports) == 0)
19942 errmsg ("At least one port or port range required");
19946 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
19948 mp->is_add = is_add;
19950 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
19952 mp->number_of_ranges = vec_len (low_ports);
19954 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
19955 vec_free (low_ports);
19957 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
19958 vec_free (high_ports);
19960 mp->vrf_id = ntohl (vrf_id);
19968 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
19970 unformat_input_t *input = vam->input;
19971 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
19972 u32 sw_if_index = ~0;
19974 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
19975 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
19979 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19981 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19983 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19985 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
19987 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
19989 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
19991 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
19993 else if (unformat (input, "del"))
19999 if (sw_if_index == ~0)
20001 errmsg ("Interface required but not specified");
20007 errmsg ("VRF ID required but not specified");
20011 if (tcp_out_vrf_id == 0
20012 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20015 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20019 /* Construct the API message */
20020 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20022 mp->sw_if_index = ntohl (sw_if_index);
20023 mp->is_add = is_add;
20024 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20025 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20026 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20027 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20032 /* Wait for a reply... */
20038 api_set_punt (vat_main_t * vam)
20040 unformat_input_t *i = vam->input;
20041 vl_api_address_family_t af;
20042 vl_api_set_punt_t *mp;
20048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20050 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
20052 else if (unformat (i, "protocol %d", &protocol))
20054 else if (unformat (i, "port %d", &port))
20056 else if (unformat (i, "del"))
20060 clib_warning ("parse error '%U'", format_unformat_error, i);
20067 mp->is_add = (u8) is_add;
20068 mp->punt.type = PUNT_API_TYPE_L4;
20069 mp->punt.punt.l4.af = af;
20070 mp->punt.punt.l4.protocol = (u8) protocol;
20071 mp->punt.punt.l4.port = htons ((u16) port);
20079 api_delete_subif (vat_main_t * vam)
20081 unformat_input_t *i = vam->input;
20082 vl_api_delete_subif_t *mp;
20083 u32 sw_if_index = ~0;
20086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20090 if (unformat (i, "sw_if_index %d", &sw_if_index))
20096 if (sw_if_index == ~0)
20098 errmsg ("missing sw_if_index");
20102 /* Construct the API message */
20103 M (DELETE_SUBIF, mp);
20104 mp->sw_if_index = ntohl (sw_if_index);
20111 #define foreach_pbb_vtr_op \
20112 _("disable", L2_VTR_DISABLED) \
20113 _("pop", L2_VTR_POP_2) \
20114 _("push", L2_VTR_PUSH_2)
20117 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20119 unformat_input_t *i = vam->input;
20120 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20121 u32 sw_if_index = ~0, vtr_op = ~0;
20122 u16 outer_tag = ~0;
20123 u8 dmac[6], smac[6];
20124 u8 dmac_set = 0, smac_set = 0;
20130 /* Shut up coverity */
20131 clib_memset (dmac, 0, sizeof (dmac));
20132 clib_memset (smac, 0, sizeof (smac));
20134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20140 else if (unformat (i, "vtr_op %d", &vtr_op))
20142 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20145 else if (unformat (i, "translate_pbb_stag"))
20147 if (unformat (i, "%d", &tmp))
20149 vtr_op = L2_VTR_TRANSLATE_2_1;
20155 ("translate_pbb_stag operation requires outer tag definition");
20159 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20161 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20163 else if (unformat (i, "sid %d", &sid))
20165 else if (unformat (i, "vlanid %d", &tmp))
20169 clib_warning ("parse error '%U'", format_unformat_error, i);
20174 if ((sw_if_index == ~0) || (vtr_op == ~0))
20176 errmsg ("missing sw_if_index or vtr operation");
20179 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20180 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20183 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20187 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20188 mp->sw_if_index = ntohl (sw_if_index);
20189 mp->vtr_op = ntohl (vtr_op);
20190 mp->outer_tag = ntohs (outer_tag);
20191 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20192 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20193 mp->b_vlanid = ntohs (vlanid);
20194 mp->i_sid = ntohl (sid);
20202 api_flow_classify_set_interface (vat_main_t * vam)
20204 unformat_input_t *i = vam->input;
20205 vl_api_flow_classify_set_interface_t *mp;
20207 int sw_if_index_set;
20208 u32 ip4_table_index = ~0;
20209 u32 ip6_table_index = ~0;
20213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20215 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20216 sw_if_index_set = 1;
20217 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20218 sw_if_index_set = 1;
20219 else if (unformat (i, "del"))
20221 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20223 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20227 clib_warning ("parse error '%U'", format_unformat_error, i);
20232 if (sw_if_index_set == 0)
20234 errmsg ("missing interface name or sw_if_index");
20238 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20240 mp->sw_if_index = ntohl (sw_if_index);
20241 mp->ip4_table_index = ntohl (ip4_table_index);
20242 mp->ip6_table_index = ntohl (ip6_table_index);
20243 mp->is_add = is_add;
20251 api_flow_classify_dump (vat_main_t * vam)
20253 unformat_input_t *i = vam->input;
20254 vl_api_flow_classify_dump_t *mp;
20255 vl_api_control_ping_t *mp_ping;
20256 u8 type = FLOW_CLASSIFY_N_TABLES;
20259 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20263 errmsg ("classify table type must be specified");
20267 if (!vam->json_output)
20269 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20272 M (FLOW_CLASSIFY_DUMP, mp);
20277 /* Use a control ping for synchronization */
20278 MPING (CONTROL_PING, mp_ping);
20281 /* Wait for a reply... */
20287 api_feature_enable_disable (vat_main_t * vam)
20289 unformat_input_t *i = vam->input;
20290 vl_api_feature_enable_disable_t *mp;
20292 u8 *feature_name = 0;
20293 u32 sw_if_index = ~0;
20297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20299 if (unformat (i, "arc_name %s", &arc_name))
20301 else if (unformat (i, "feature_name %s", &feature_name))
20304 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20306 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20308 else if (unformat (i, "disable"))
20316 errmsg ("missing arc name");
20319 if (vec_len (arc_name) > 63)
20321 errmsg ("arc name too long");
20324 if (feature_name == 0)
20326 errmsg ("missing feature name");
20329 if (vec_len (feature_name) > 63)
20331 errmsg ("feature name too long");
20334 if (sw_if_index == ~0)
20336 errmsg ("missing interface name or sw_if_index");
20340 /* Construct the API message */
20341 M (FEATURE_ENABLE_DISABLE, mp);
20342 mp->sw_if_index = ntohl (sw_if_index);
20343 mp->enable = enable;
20344 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20345 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20346 vec_free (arc_name);
20347 vec_free (feature_name);
20355 api_sw_interface_tag_add_del (vat_main_t * vam)
20357 unformat_input_t *i = vam->input;
20358 vl_api_sw_interface_tag_add_del_t *mp;
20359 u32 sw_if_index = ~0;
20364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20366 if (unformat (i, "tag %s", &tag))
20368 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20370 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20372 else if (unformat (i, "del"))
20378 if (sw_if_index == ~0)
20380 errmsg ("missing interface name or sw_if_index");
20384 if (enable && (tag == 0))
20386 errmsg ("no tag specified");
20390 /* Construct the API message */
20391 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20392 mp->sw_if_index = ntohl (sw_if_index);
20393 mp->is_add = enable;
20395 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20403 static void vl_api_l2_xconnect_details_t_handler
20404 (vl_api_l2_xconnect_details_t * mp)
20406 vat_main_t *vam = &vat_main;
20408 print (vam->ofp, "%15d%15d",
20409 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20412 static void vl_api_l2_xconnect_details_t_handler_json
20413 (vl_api_l2_xconnect_details_t * mp)
20415 vat_main_t *vam = &vat_main;
20416 vat_json_node_t *node = NULL;
20418 if (VAT_JSON_ARRAY != vam->json_tree.type)
20420 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20421 vat_json_init_array (&vam->json_tree);
20423 node = vat_json_array_add (&vam->json_tree);
20425 vat_json_init_object (node);
20426 vat_json_object_add_uint (node, "rx_sw_if_index",
20427 ntohl (mp->rx_sw_if_index));
20428 vat_json_object_add_uint (node, "tx_sw_if_index",
20429 ntohl (mp->tx_sw_if_index));
20433 api_l2_xconnect_dump (vat_main_t * vam)
20435 vl_api_l2_xconnect_dump_t *mp;
20436 vl_api_control_ping_t *mp_ping;
20439 if (!vam->json_output)
20441 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20444 M (L2_XCONNECT_DUMP, mp);
20448 /* Use a control ping for synchronization */
20449 MPING (CONTROL_PING, mp_ping);
20457 api_hw_interface_set_mtu (vat_main_t * vam)
20459 unformat_input_t *i = vam->input;
20460 vl_api_hw_interface_set_mtu_t *mp;
20461 u32 sw_if_index = ~0;
20465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20467 if (unformat (i, "mtu %d", &mtu))
20469 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20471 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20477 if (sw_if_index == ~0)
20479 errmsg ("missing interface name or sw_if_index");
20485 errmsg ("no mtu specified");
20489 /* Construct the API message */
20490 M (HW_INTERFACE_SET_MTU, mp);
20491 mp->sw_if_index = ntohl (sw_if_index);
20492 mp->mtu = ntohs ((u16) mtu);
20500 api_p2p_ethernet_add (vat_main_t * vam)
20502 unformat_input_t *i = vam->input;
20503 vl_api_p2p_ethernet_add_t *mp;
20504 u32 parent_if_index = ~0;
20510 clib_memset (remote_mac, 0, sizeof (remote_mac));
20511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20515 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20519 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20521 else if (unformat (i, "sub_id %d", &sub_id))
20525 clib_warning ("parse error '%U'", format_unformat_error, i);
20530 if (parent_if_index == ~0)
20532 errmsg ("missing interface name or sw_if_index");
20537 errmsg ("missing remote mac address");
20542 errmsg ("missing sub-interface id");
20546 M (P2P_ETHERNET_ADD, mp);
20547 mp->parent_if_index = ntohl (parent_if_index);
20548 mp->subif_id = ntohl (sub_id);
20549 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20557 api_p2p_ethernet_del (vat_main_t * vam)
20559 unformat_input_t *i = vam->input;
20560 vl_api_p2p_ethernet_del_t *mp;
20561 u32 parent_if_index = ~0;
20566 clib_memset (remote_mac, 0, sizeof (remote_mac));
20567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20569 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20571 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20575 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20579 clib_warning ("parse error '%U'", format_unformat_error, i);
20584 if (parent_if_index == ~0)
20586 errmsg ("missing interface name or sw_if_index");
20591 errmsg ("missing remote mac address");
20595 M (P2P_ETHERNET_DEL, mp);
20596 mp->parent_if_index = ntohl (parent_if_index);
20597 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20605 api_lldp_config (vat_main_t * vam)
20607 unformat_input_t *i = vam->input;
20608 vl_api_lldp_config_t *mp;
20610 int tx_interval = 0;
20611 u8 *sys_name = NULL;
20614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20616 if (unformat (i, "system-name %s", &sys_name))
20618 else if (unformat (i, "tx-hold %d", &tx_hold))
20620 else if (unformat (i, "tx-interval %d", &tx_interval))
20624 clib_warning ("parse error '%U'", format_unformat_error, i);
20629 vec_add1 (sys_name, 0);
20631 M (LLDP_CONFIG, mp);
20632 mp->tx_hold = htonl (tx_hold);
20633 mp->tx_interval = htonl (tx_interval);
20634 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20635 vec_free (sys_name);
20643 api_sw_interface_set_lldp (vat_main_t * vam)
20645 unformat_input_t *i = vam->input;
20646 vl_api_sw_interface_set_lldp_t *mp;
20647 u32 sw_if_index = ~0;
20649 u8 *port_desc = NULL, *mgmt_oid = NULL;
20650 ip4_address_t ip4_addr;
20651 ip6_address_t ip6_addr;
20654 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
20655 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
20657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20659 if (unformat (i, "disable"))
20662 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20664 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20666 else if (unformat (i, "port-desc %s", &port_desc))
20668 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20670 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20672 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20678 if (sw_if_index == ~0)
20680 errmsg ("missing interface name or sw_if_index");
20684 /* Construct the API message */
20685 vec_add1 (port_desc, 0);
20686 vec_add1 (mgmt_oid, 0);
20687 M (SW_INTERFACE_SET_LLDP, mp);
20688 mp->sw_if_index = ntohl (sw_if_index);
20689 mp->enable = enable;
20690 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20691 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20692 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20693 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20694 vec_free (port_desc);
20695 vec_free (mgmt_oid);
20703 api_tcp_configure_src_addresses (vat_main_t * vam)
20705 vl_api_tcp_configure_src_addresses_t *mp;
20706 unformat_input_t *i = vam->input;
20707 ip4_address_t v4first, v4last;
20708 ip6_address_t v6first, v6last;
20713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20715 if (unformat (i, "%U - %U",
20716 unformat_ip4_address, &v4first,
20717 unformat_ip4_address, &v4last))
20721 errmsg ("one range per message (range already set)");
20726 else if (unformat (i, "%U - %U",
20727 unformat_ip6_address, &v6first,
20728 unformat_ip6_address, &v6last))
20732 errmsg ("one range per message (range already set)");
20737 else if (unformat (i, "vrf %d", &vrf_id))
20743 if (range_set == 0)
20745 errmsg ("address range not set");
20749 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20750 mp->vrf_id = ntohl (vrf_id);
20752 if (range_set == 2)
20755 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20756 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20761 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20762 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20769 static void vl_api_app_namespace_add_del_reply_t_handler
20770 (vl_api_app_namespace_add_del_reply_t * mp)
20772 vat_main_t *vam = &vat_main;
20773 i32 retval = ntohl (mp->retval);
20774 if (vam->async_mode)
20776 vam->async_errors += (retval < 0);
20780 vam->retval = retval;
20782 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
20783 vam->result_ready = 1;
20787 static void vl_api_app_namespace_add_del_reply_t_handler_json
20788 (vl_api_app_namespace_add_del_reply_t * mp)
20790 vat_main_t *vam = &vat_main;
20791 vat_json_node_t node;
20793 vat_json_init_object (&node);
20794 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
20795 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
20797 vat_json_print (vam->ofp, &node);
20798 vat_json_free (&node);
20800 vam->retval = ntohl (mp->retval);
20801 vam->result_ready = 1;
20805 api_app_namespace_add_del (vat_main_t * vam)
20807 vl_api_app_namespace_add_del_t *mp;
20808 unformat_input_t *i = vam->input;
20809 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
20810 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
20814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20816 if (unformat (i, "id %_%v%_", &ns_id))
20818 else if (unformat (i, "secret %lu", &secret))
20820 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20821 sw_if_index_set = 1;
20822 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
20824 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
20829 if (!ns_id || !secret_set || !sw_if_index_set)
20831 errmsg ("namespace id, secret and sw_if_index must be set");
20834 if (vec_len (ns_id) > 64)
20836 errmsg ("namespace id too long");
20839 M (APP_NAMESPACE_ADD_DEL, mp);
20841 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
20842 mp->namespace_id_len = vec_len (ns_id);
20843 mp->secret = clib_host_to_net_u64 (secret);
20844 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20845 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
20846 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
20854 api_sock_init_shm (vat_main_t * vam)
20856 #if VPP_API_TEST_BUILTIN == 0
20857 unformat_input_t *i = vam->input;
20858 vl_api_shm_elem_config_t *config = 0;
20859 u64 size = 64 << 20;
20862 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20864 if (unformat (i, "size %U", unformat_memory_size, &size))
20871 * Canned custom ring allocator config.
20872 * Should probably parse all of this
20874 vec_validate (config, 6);
20875 config[0].type = VL_API_VLIB_RING;
20876 config[0].size = 256;
20877 config[0].count = 32;
20879 config[1].type = VL_API_VLIB_RING;
20880 config[1].size = 1024;
20881 config[1].count = 16;
20883 config[2].type = VL_API_VLIB_RING;
20884 config[2].size = 4096;
20885 config[2].count = 2;
20887 config[3].type = VL_API_CLIENT_RING;
20888 config[3].size = 256;
20889 config[3].count = 32;
20891 config[4].type = VL_API_CLIENT_RING;
20892 config[4].size = 1024;
20893 config[4].count = 16;
20895 config[5].type = VL_API_CLIENT_RING;
20896 config[5].size = 4096;
20897 config[5].count = 2;
20899 config[6].type = VL_API_QUEUE;
20900 config[6].count = 128;
20901 config[6].size = sizeof (uword);
20903 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
20905 vam->client_index_invalid = 1;
20913 api_dns_enable_disable (vat_main_t * vam)
20915 unformat_input_t *line_input = vam->input;
20916 vl_api_dns_enable_disable_t *mp;
20917 u8 enable_disable = 1;
20920 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20922 if (unformat (line_input, "disable"))
20923 enable_disable = 0;
20924 if (unformat (line_input, "enable"))
20925 enable_disable = 1;
20930 /* Construct the API message */
20931 M (DNS_ENABLE_DISABLE, mp);
20932 mp->enable = enable_disable;
20936 /* Wait for the reply */
20942 api_dns_resolve_name (vat_main_t * vam)
20944 unformat_input_t *line_input = vam->input;
20945 vl_api_dns_resolve_name_t *mp;
20949 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20951 if (unformat (line_input, "%s", &name))
20957 if (vec_len (name) > 127)
20959 errmsg ("name too long");
20963 /* Construct the API message */
20964 M (DNS_RESOLVE_NAME, mp);
20965 memcpy (mp->name, name, vec_len (name));
20970 /* Wait for the reply */
20976 api_dns_resolve_ip (vat_main_t * vam)
20978 unformat_input_t *line_input = vam->input;
20979 vl_api_dns_resolve_ip_t *mp;
20981 ip4_address_t addr4;
20982 ip6_address_t addr6;
20985 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20987 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
20989 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
20997 errmsg ("missing address");
21001 /* Construct the API message */
21002 M (DNS_RESOLVE_IP, mp);
21003 mp->is_ip6 = is_ip6;
21005 memcpy (mp->address, &addr6, sizeof (addr6));
21007 memcpy (mp->address, &addr4, sizeof (addr4));
21011 /* Wait for the reply */
21017 api_dns_name_server_add_del (vat_main_t * vam)
21019 unformat_input_t *i = vam->input;
21020 vl_api_dns_name_server_add_del_t *mp;
21022 ip6_address_t ip6_server;
21023 ip4_address_t ip4_server;
21028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21030 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21032 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21034 else if (unformat (i, "del"))
21038 clib_warning ("parse error '%U'", format_unformat_error, i);
21043 if (ip4_set && ip6_set)
21045 errmsg ("Only one server address allowed per message");
21048 if ((ip4_set + ip6_set) == 0)
21050 errmsg ("Server address required");
21054 /* Construct the API message */
21055 M (DNS_NAME_SERVER_ADD_DEL, mp);
21059 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21064 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21068 mp->is_add = is_add;
21073 /* Wait for a reply, return good/bad news */
21079 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21081 vat_main_t *vam = &vat_main;
21086 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21087 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21088 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21089 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21090 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21091 clib_net_to_host_u32 (mp->action_index), mp->tag);
21096 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21097 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21098 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21099 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21100 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21101 clib_net_to_host_u32 (mp->action_index), mp->tag);
21106 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21109 vat_main_t *vam = &vat_main;
21110 vat_json_node_t *node = NULL;
21111 struct in6_addr ip6;
21112 struct in_addr ip4;
21114 if (VAT_JSON_ARRAY != vam->json_tree.type)
21116 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21117 vat_json_init_array (&vam->json_tree);
21119 node = vat_json_array_add (&vam->json_tree);
21120 vat_json_init_object (node);
21122 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21123 vat_json_object_add_uint (node, "appns_index",
21124 clib_net_to_host_u32 (mp->appns_index));
21125 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21126 vat_json_object_add_uint (node, "scope", mp->scope);
21127 vat_json_object_add_uint (node, "action_index",
21128 clib_net_to_host_u32 (mp->action_index));
21129 vat_json_object_add_uint (node, "lcl_port",
21130 clib_net_to_host_u16 (mp->lcl_port));
21131 vat_json_object_add_uint (node, "rmt_port",
21132 clib_net_to_host_u16 (mp->rmt_port));
21133 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21134 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21135 vat_json_object_add_string_copy (node, "tag", mp->tag);
21138 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21139 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21140 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21141 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21145 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21146 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21147 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21148 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21153 api_session_rule_add_del (vat_main_t * vam)
21155 vl_api_session_rule_add_del_t *mp;
21156 unformat_input_t *i = vam->input;
21157 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21158 u32 appns_index = 0, scope = 0;
21159 ip4_address_t lcl_ip4, rmt_ip4;
21160 ip6_address_t lcl_ip6, rmt_ip6;
21161 u8 is_ip4 = 1, conn_set = 0;
21162 u8 is_add = 1, *tag = 0;
21165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21167 if (unformat (i, "del"))
21169 else if (unformat (i, "add"))
21171 else if (unformat (i, "proto tcp"))
21173 else if (unformat (i, "proto udp"))
21175 else if (unformat (i, "appns %d", &appns_index))
21177 else if (unformat (i, "scope %d", &scope))
21179 else if (unformat (i, "tag %_%v%_", &tag))
21183 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21184 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21192 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21193 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21199 else if (unformat (i, "action %d", &action))
21204 if (proto == ~0 || !conn_set || action == ~0)
21206 errmsg ("transport proto, connection and action must be set");
21212 errmsg ("scope should be 0-3");
21216 M (SESSION_RULE_ADD_DEL, mp);
21218 mp->is_ip4 = is_ip4;
21219 mp->transport_proto = proto;
21220 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21221 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21222 mp->lcl_plen = lcl_plen;
21223 mp->rmt_plen = rmt_plen;
21224 mp->action_index = clib_host_to_net_u32 (action);
21225 mp->appns_index = clib_host_to_net_u32 (appns_index);
21227 mp->is_add = is_add;
21230 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21231 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21235 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21236 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21240 clib_memcpy (mp->tag, tag, vec_len (tag));
21250 api_session_rules_dump (vat_main_t * vam)
21252 vl_api_session_rules_dump_t *mp;
21253 vl_api_control_ping_t *mp_ping;
21256 if (!vam->json_output)
21258 print (vam->ofp, "%=20s", "Session Rules");
21261 M (SESSION_RULES_DUMP, mp);
21265 /* Use a control ping for synchronization */
21266 MPING (CONTROL_PING, mp_ping);
21269 /* Wait for a reply... */
21275 api_ip_container_proxy_add_del (vat_main_t * vam)
21277 vl_api_ip_container_proxy_add_del_t *mp;
21278 unformat_input_t *i = vam->input;
21279 u32 sw_if_index = ~0;
21280 vl_api_prefix_t pfx = { };
21284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21286 if (unformat (i, "del"))
21288 else if (unformat (i, "add"))
21290 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21292 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21297 if (sw_if_index == ~0 || pfx.address_length == 0)
21299 errmsg ("address and sw_if_index must be set");
21303 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21305 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21306 mp->is_add = is_add;
21307 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21315 api_qos_record_enable_disable (vat_main_t * vam)
21317 unformat_input_t *i = vam->input;
21318 vl_api_qos_record_enable_disable_t *mp;
21319 u32 sw_if_index, qs = 0xff;
21320 u8 sw_if_index_set = 0;
21324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21326 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21327 sw_if_index_set = 1;
21328 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21329 sw_if_index_set = 1;
21330 else if (unformat (i, "%U", unformat_qos_source, &qs))
21332 else if (unformat (i, "disable"))
21336 clib_warning ("parse error '%U'", format_unformat_error, i);
21341 if (sw_if_index_set == 0)
21343 errmsg ("missing interface name or sw_if_index");
21348 errmsg ("input location must be specified");
21352 M (QOS_RECORD_ENABLE_DISABLE, mp);
21354 mp->sw_if_index = ntohl (sw_if_index);
21355 mp->input_source = qs;
21356 mp->enable = enable;
21365 q_or_quit (vat_main_t * vam)
21367 #if VPP_API_TEST_BUILTIN == 0
21368 longjmp (vam->jump_buf, 1);
21370 return 0; /* not so much */
21374 q (vat_main_t * vam)
21376 return q_or_quit (vam);
21380 quit (vat_main_t * vam)
21382 return q_or_quit (vam);
21386 comment (vat_main_t * vam)
21392 statseg (vat_main_t * vam)
21394 ssvm_private_t *ssvmp = &vam->stat_segment;
21395 ssvm_shared_header_t *shared_header = ssvmp->sh;
21396 vlib_counter_t **counters;
21397 u64 thread0_index1_packets;
21398 u64 thread0_index1_bytes;
21399 f64 vector_rate, input_rate;
21402 uword *counter_vector_by_name;
21403 if (vam->stat_segment_lockp == 0)
21405 errmsg ("Stat segment not mapped...");
21409 /* look up "/if/rx for sw_if_index 1 as a test */
21411 clib_spinlock_lock (vam->stat_segment_lockp);
21413 counter_vector_by_name = (uword *) shared_header->opaque[1];
21415 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21418 clib_spinlock_unlock (vam->stat_segment_lockp);
21419 errmsg ("/if/tx not found?");
21423 /* Fish per-thread vector of combined counters from shared memory */
21424 counters = (vlib_counter_t **) p[0];
21426 if (vec_len (counters[0]) < 2)
21428 clib_spinlock_unlock (vam->stat_segment_lockp);
21429 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21433 /* Read thread 0 sw_if_index 1 counter */
21434 thread0_index1_packets = counters[0][1].packets;
21435 thread0_index1_bytes = counters[0][1].bytes;
21437 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21440 clib_spinlock_unlock (vam->stat_segment_lockp);
21441 errmsg ("vector_rate not found?");
21445 vector_rate = *(f64 *) (p[0]);
21446 p = hash_get_mem (counter_vector_by_name, "input_rate");
21449 clib_spinlock_unlock (vam->stat_segment_lockp);
21450 errmsg ("input_rate not found?");
21453 input_rate = *(f64 *) (p[0]);
21455 clib_spinlock_unlock (vam->stat_segment_lockp);
21457 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21458 vector_rate, input_rate);
21459 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21460 thread0_index1_packets, thread0_index1_bytes);
21466 cmd_cmp (void *a1, void *a2)
21471 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21475 help (vat_main_t * vam)
21480 unformat_input_t *i = vam->input;
21483 if (unformat (i, "%s", &name))
21487 vec_add1 (name, 0);
21489 hs = hash_get_mem (vam->help_by_name, name);
21491 print (vam->ofp, "usage: %s %s", name, hs[0]);
21493 print (vam->ofp, "No such msg / command '%s'", name);
21498 print (vam->ofp, "Help is available for the following:");
21501 hash_foreach_pair (p, vam->function_by_name,
21503 vec_add1 (cmds, (u8 *)(p->key));
21507 vec_sort_with_function (cmds, cmd_cmp);
21509 for (j = 0; j < vec_len (cmds); j++)
21510 print (vam->ofp, "%s", cmds[j]);
21517 set (vat_main_t * vam)
21519 u8 *name = 0, *value = 0;
21520 unformat_input_t *i = vam->input;
21522 if (unformat (i, "%s", &name))
21524 /* The input buffer is a vector, not a string. */
21525 value = vec_dup (i->buffer);
21526 vec_delete (value, i->index, 0);
21527 /* Almost certainly has a trailing newline */
21528 if (value[vec_len (value) - 1] == '\n')
21529 value[vec_len (value) - 1] = 0;
21530 /* Make sure it's a proper string, one way or the other */
21531 vec_add1 (value, 0);
21532 (void) clib_macro_set_value (&vam->macro_main,
21533 (char *) name, (char *) value);
21536 errmsg ("usage: set <name> <value>");
21544 unset (vat_main_t * vam)
21548 if (unformat (vam->input, "%s", &name))
21549 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21550 errmsg ("unset: %s wasn't set", name);
21563 macro_sort_cmp (void *a1, void *a2)
21565 macro_sort_t *s1 = a1;
21566 macro_sort_t *s2 = a2;
21568 return strcmp ((char *) (s1->name), (char *) (s2->name));
21572 dump_macro_table (vat_main_t * vam)
21574 macro_sort_t *sort_me = 0, *sm;
21579 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21581 vec_add2 (sort_me, sm, 1);
21582 sm->name = (u8 *)(p->key);
21583 sm->value = (u8 *) (p->value[0]);
21587 vec_sort_with_function (sort_me, macro_sort_cmp);
21589 if (vec_len (sort_me))
21590 print (vam->ofp, "%-15s%s", "Name", "Value");
21592 print (vam->ofp, "The macro table is empty...");
21594 for (i = 0; i < vec_len (sort_me); i++)
21595 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21600 dump_node_table (vat_main_t * vam)
21603 vlib_node_t *node, *next_node;
21605 if (vec_len (vam->graph_nodes) == 0)
21607 print (vam->ofp, "Node table empty, issue get_node_graph...");
21611 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
21613 node = vam->graph_nodes[0][i];
21614 print (vam->ofp, "[%d] %s", i, node->name);
21615 for (j = 0; j < vec_len (node->next_nodes); j++)
21617 if (node->next_nodes[j] != ~0)
21619 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21620 print (vam->ofp, " [%d] %s", j, next_node->name);
21628 value_sort_cmp (void *a1, void *a2)
21630 name_sort_t *n1 = a1;
21631 name_sort_t *n2 = a2;
21633 if (n1->value < n2->value)
21635 if (n1->value > n2->value)
21642 dump_msg_api_table (vat_main_t * vam)
21644 api_main_t *am = &api_main;
21645 name_sort_t *nses = 0, *ns;
21650 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21652 vec_add2 (nses, ns, 1);
21653 ns->name = (u8 *)(hp->key);
21654 ns->value = (u32) hp->value[0];
21658 vec_sort_with_function (nses, value_sort_cmp);
21660 for (i = 0; i < vec_len (nses); i++)
21661 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21667 get_msg_id (vat_main_t * vam)
21672 if (unformat (vam->input, "%s", &name_and_crc))
21674 message_index = vl_msg_api_get_msg_index (name_and_crc);
21675 if (message_index == ~0)
21677 print (vam->ofp, " '%s' not found", name_and_crc);
21680 print (vam->ofp, " '%s' has message index %d",
21681 name_and_crc, message_index);
21684 errmsg ("name_and_crc required...");
21689 search_node_table (vat_main_t * vam)
21691 unformat_input_t *line_input = vam->input;
21694 vlib_node_t *node, *next_node;
21697 if (vam->graph_node_index_by_name == 0)
21699 print (vam->ofp, "Node table empty, issue get_node_graph...");
21703 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21705 if (unformat (line_input, "%s", &node_to_find))
21707 vec_add1 (node_to_find, 0);
21708 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21711 print (vam->ofp, "%s not found...", node_to_find);
21714 node = vam->graph_nodes[0][p[0]];
21715 print (vam->ofp, "[%d] %s", p[0], node->name);
21716 for (j = 0; j < vec_len (node->next_nodes); j++)
21718 if (node->next_nodes[j] != ~0)
21720 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21721 print (vam->ofp, " [%d] %s", j, next_node->name);
21728 clib_warning ("parse error '%U'", format_unformat_error,
21734 vec_free (node_to_find);
21743 script (vat_main_t * vam)
21745 #if (VPP_API_TEST_BUILTIN==0)
21747 char *save_current_file;
21748 unformat_input_t save_input;
21749 jmp_buf save_jump_buf;
21750 u32 save_line_number;
21752 FILE *new_fp, *save_ifp;
21754 if (unformat (vam->input, "%s", &s))
21756 new_fp = fopen ((char *) s, "r");
21759 errmsg ("Couldn't open script file %s", s);
21766 errmsg ("Missing script name");
21770 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21771 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21772 save_ifp = vam->ifp;
21773 save_line_number = vam->input_line_number;
21774 save_current_file = (char *) vam->current_file;
21776 vam->input_line_number = 0;
21778 vam->current_file = s;
21781 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
21782 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21783 vam->ifp = save_ifp;
21784 vam->input_line_number = save_line_number;
21785 vam->current_file = (u8 *) save_current_file;
21790 clib_warning ("use the exec command...");
21796 echo (vat_main_t * vam)
21798 print (vam->ofp, "%v", vam->input->buffer);
21802 /* List of API message constructors, CLI names map to api_xxx */
21803 #define foreach_vpe_api_msg \
21804 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21805 _(sw_interface_dump,"") \
21806 _(sw_interface_set_flags, \
21807 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21808 _(sw_interface_add_del_address, \
21809 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
21810 _(sw_interface_set_rx_mode, \
21811 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
21812 _(sw_interface_set_rx_placement, \
21813 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
21814 _(sw_interface_rx_placement_dump, \
21815 "[<intfc> | sw_if_index <id>]") \
21816 _(sw_interface_set_table, \
21817 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
21818 _(sw_interface_set_mpls_enable, \
21819 "<intfc> | sw_if_index [disable | dis]") \
21820 _(sw_interface_set_vpath, \
21821 "<intfc> | sw_if_index <id> enable | disable") \
21822 _(sw_interface_set_vxlan_bypass, \
21823 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21824 _(sw_interface_set_geneve_bypass, \
21825 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21826 _(sw_interface_set_l2_xconnect, \
21827 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21828 "enable | disable") \
21829 _(sw_interface_set_l2_bridge, \
21830 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
21831 "[shg <split-horizon-group>] [bvi]\n" \
21832 "enable | disable") \
21833 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
21834 _(bridge_domain_add_del, \
21835 "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") \
21836 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
21838 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
21839 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
21840 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
21842 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21844 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21846 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
21848 "<vpp-if-name> | sw_if_index <id>") \
21849 _(sw_interface_tap_v2_dump, "") \
21850 _(virtio_pci_create, \
21851 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
21852 _(virtio_pci_delete, \
21853 "<vpp-if-name> | sw_if_index <id>") \
21854 _(sw_interface_virtio_pci_dump, "") \
21856 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
21857 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
21860 "<vpp-if-name> | sw_if_index <id>") \
21862 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
21863 _(bond_detach_slave, \
21864 "sw_if_index <n>") \
21865 _(sw_interface_bond_dump, "") \
21866 _(sw_interface_slave_dump, \
21867 "<vpp-if-name> | sw_if_index <id>") \
21868 _(ip_table_add_del, \
21869 "table <n> [ipv6] [add | del]\n") \
21870 _(ip_route_add_del, \
21871 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
21872 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
21873 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
21874 "[multipath] [count <n>] [del]") \
21875 _(ip_mroute_add_del, \
21876 "<src> <grp>/<mask> [table-id <n>]\n" \
21877 "[<intfc> | sw_if_index <id>] [local] [del]") \
21878 _(mpls_table_add_del, \
21879 "table <n> [add | del]\n") \
21880 _(mpls_route_add_del, \
21881 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
21882 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
21883 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
21884 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
21885 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
21886 "[count <n>] [del]") \
21887 _(mpls_ip_bind_unbind, \
21888 "<label> <addr/len>") \
21889 _(mpls_tunnel_add_del, \
21890 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
21891 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
21892 "[l2-only] [out-label <n>]") \
21893 _(sr_mpls_policy_add, \
21894 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
21895 _(sr_mpls_policy_del, \
21897 _(bier_table_add_del, \
21898 "<label> <sub-domain> <set> <bsl> [del]") \
21899 _(bier_route_add_del, \
21900 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
21901 "[<intfc> | sw_if_index <id>]" \
21902 "[weight <n>] [del] [multipath]") \
21903 _(proxy_arp_add_del, \
21904 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
21905 _(proxy_arp_intfc_enable_disable, \
21906 "<intfc> | sw_if_index <id> enable | disable") \
21907 _(sw_interface_set_unnumbered, \
21908 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
21909 _(ip_neighbor_add_del, \
21910 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
21911 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
21912 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
21913 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
21914 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
21915 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
21916 "[outer_vlan_id_any][inner_vlan_id_any]") \
21917 _(reset_fib, "vrf <n> [ipv6]") \
21918 _(dhcp_proxy_config, \
21919 "svr <v46-address> src <v46-address>\n" \
21920 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
21921 _(dhcp_proxy_set_vss, \
21922 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
21923 _(dhcp_proxy_dump, "ip6") \
21924 _(dhcp_client_config, \
21925 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
21926 _(set_ip_flow_hash, \
21927 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
21928 _(sw_interface_ip6_enable_disable, \
21929 "<intfc> | sw_if_index <id> enable | disable") \
21930 _(ip6nd_proxy_add_del, \
21931 "<intfc> | sw_if_index <id> <ip6-address>") \
21932 _(ip6nd_proxy_dump, "") \
21933 _(sw_interface_ip6nd_ra_prefix, \
21934 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
21935 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
21936 "[nolink] [isno]") \
21937 _(sw_interface_ip6nd_ra_config, \
21938 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
21939 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
21940 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
21941 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
21942 _(l2_patch_add_del, \
21943 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21944 "enable | disable") \
21945 _(sr_localsid_add_del, \
21946 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
21947 "fib-table <num> (end.psp) sw_if_index <num>") \
21948 _(classify_add_del_table, \
21949 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
21950 " [del] [del-chain] mask <mask-value>\n" \
21951 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
21952 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
21953 _(classify_add_del_session, \
21954 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
21955 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
21956 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
21957 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
21958 _(classify_set_interface_ip_table, \
21959 "<intfc> | sw_if_index <nn> table <nn>") \
21960 _(classify_set_interface_l2_tables, \
21961 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21962 " [other-table <nn>]") \
21963 _(get_node_index, "node <node-name") \
21964 _(add_node_next, "node <node-name> next <next-node-name>") \
21965 _(l2tpv3_create_tunnel, \
21966 "client_address <ip6-addr> our_address <ip6-addr>\n" \
21967 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
21968 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
21969 _(l2tpv3_set_tunnel_cookies, \
21970 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
21971 "[new_remote_cookie <nn>]\n") \
21972 _(l2tpv3_interface_enable_disable, \
21973 "<intfc> | sw_if_index <nn> enable | disable") \
21974 _(l2tpv3_set_lookup_key, \
21975 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
21976 _(sw_if_l2tpv3_tunnel_dump, "") \
21977 _(vxlan_offload_rx, \
21978 "hw { <interface name> | hw_if_index <nn>} " \
21979 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
21980 _(vxlan_add_del_tunnel, \
21981 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21982 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
21983 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21984 _(geneve_add_del_tunnel, \
21985 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21986 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21987 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21988 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21989 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21990 _(gre_tunnel_add_del, \
21991 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
21992 "[teb | erspan <session-id>] [del]") \
21993 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21994 _(l2_fib_clear_table, "") \
21995 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
21996 _(l2_interface_vlan_tag_rewrite, \
21997 "<intfc> | sw_if_index <nn> \n" \
21998 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
21999 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22000 _(create_vhost_user_if, \
22001 "socket <filename> [server] [renumber <dev_instance>] " \
22002 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
22003 "[mac <mac_address>]") \
22004 _(modify_vhost_user_if, \
22005 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22006 "[server] [renumber <dev_instance>]") \
22007 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22008 _(sw_interface_vhost_user_dump, "") \
22009 _(show_version, "") \
22010 _(show_threads, "") \
22011 _(vxlan_gpe_add_del_tunnel, \
22012 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22013 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22014 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22015 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22016 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22017 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22018 _(interface_name_renumber, \
22019 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22020 _(input_acl_set_interface, \
22021 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22022 " [l2-table <nn>] [del]") \
22023 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22024 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22025 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22026 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22027 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22028 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22029 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22030 _(ip_dump, "ipv4 | ipv6") \
22031 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22032 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22034 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22035 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22036 " integ_alg <alg> integ_key <hex>") \
22037 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22038 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22039 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22040 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22041 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22042 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22043 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22044 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22045 " [instance <n>]") \
22046 _(ipsec_sa_dump, "[sa_id <n>]") \
22047 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22048 _(delete_loopback,"sw_if_index <nn>") \
22049 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22050 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22051 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22052 _(want_interface_events, "enable|disable") \
22053 _(get_first_msg_id, "client <name>") \
22054 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22055 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22056 "fib-id <nn> [ip4][ip6][default]") \
22057 _(get_node_graph, " ") \
22058 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22059 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22060 _(ioam_disable, "") \
22061 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22062 " sw_if_index <sw_if_index> p <priority> " \
22063 "w <weight>] [del]") \
22064 _(one_add_del_locator, "locator-set <locator_name> " \
22065 "iface <intf> | sw_if_index <sw_if_index> " \
22066 "p <priority> w <weight> [del]") \
22067 _(one_add_del_local_eid,"vni <vni> eid " \
22068 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22069 "locator-set <locator_name> [del]" \
22070 "[key-id sha1|sha256 secret-key <secret-key>]")\
22071 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22072 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22073 _(one_enable_disable, "enable|disable") \
22074 _(one_map_register_enable_disable, "enable|disable") \
22075 _(one_map_register_fallback_threshold, "<value>") \
22076 _(one_rloc_probe_enable_disable, "enable|disable") \
22077 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22079 "rloc <locator> p <prio> " \
22080 "w <weight> [rloc <loc> ... ] " \
22081 "action <action> [del-all]") \
22082 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22084 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22085 _(one_use_petr, "ip-address> | disable") \
22086 _(one_map_request_mode, "src-dst|dst-only") \
22087 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22088 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22089 _(one_locator_set_dump, "[local | remote]") \
22090 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22091 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22092 "[local] | [remote]") \
22093 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22094 _(one_ndp_bd_get, "") \
22095 _(one_ndp_entries_get, "bd <bridge-domain>") \
22096 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22097 _(one_l2_arp_bd_get, "") \
22098 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22099 _(one_stats_enable_disable, "enable|disable") \
22100 _(show_one_stats_enable_disable, "") \
22101 _(one_eid_table_vni_dump, "") \
22102 _(one_eid_table_map_dump, "l2|l3") \
22103 _(one_map_resolver_dump, "") \
22104 _(one_map_server_dump, "") \
22105 _(one_adjacencies_get, "vni <vni>") \
22106 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22107 _(show_one_rloc_probe_state, "") \
22108 _(show_one_map_register_state, "") \
22109 _(show_one_status, "") \
22110 _(one_stats_dump, "") \
22111 _(one_stats_flush, "") \
22112 _(one_get_map_request_itr_rlocs, "") \
22113 _(one_map_register_set_ttl, "<ttl>") \
22114 _(one_set_transport_protocol, "udp|api") \
22115 _(one_get_transport_protocol, "") \
22116 _(one_enable_disable_xtr_mode, "enable|disable") \
22117 _(one_show_xtr_mode, "") \
22118 _(one_enable_disable_pitr_mode, "enable|disable") \
22119 _(one_show_pitr_mode, "") \
22120 _(one_enable_disable_petr_mode, "enable|disable") \
22121 _(one_show_petr_mode, "") \
22122 _(show_one_nsh_mapping, "") \
22123 _(show_one_pitr, "") \
22124 _(show_one_use_petr, "") \
22125 _(show_one_map_request_mode, "") \
22126 _(show_one_map_register_ttl, "") \
22127 _(show_one_map_register_fallback_threshold, "") \
22128 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22129 " sw_if_index <sw_if_index> p <priority> " \
22130 "w <weight>] [del]") \
22131 _(lisp_add_del_locator, "locator-set <locator_name> " \
22132 "iface <intf> | sw_if_index <sw_if_index> " \
22133 "p <priority> w <weight> [del]") \
22134 _(lisp_add_del_local_eid,"vni <vni> eid " \
22135 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22136 "locator-set <locator_name> [del]" \
22137 "[key-id sha1|sha256 secret-key <secret-key>]") \
22138 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22139 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22140 _(lisp_enable_disable, "enable|disable") \
22141 _(lisp_map_register_enable_disable, "enable|disable") \
22142 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22143 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22145 "rloc <locator> p <prio> " \
22146 "w <weight> [rloc <loc> ... ] " \
22147 "action <action> [del-all]") \
22148 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22150 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22151 _(lisp_use_petr, "<ip-address> | disable") \
22152 _(lisp_map_request_mode, "src-dst|dst-only") \
22153 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22154 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22155 _(lisp_locator_set_dump, "[local | remote]") \
22156 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22157 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22158 "[local] | [remote]") \
22159 _(lisp_eid_table_vni_dump, "") \
22160 _(lisp_eid_table_map_dump, "l2|l3") \
22161 _(lisp_map_resolver_dump, "") \
22162 _(lisp_map_server_dump, "") \
22163 _(lisp_adjacencies_get, "vni <vni>") \
22164 _(gpe_fwd_entry_vnis_get, "") \
22165 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22166 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22167 "[table <table-id>]") \
22168 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22169 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22170 _(gpe_set_encap_mode, "lisp|vxlan") \
22171 _(gpe_get_encap_mode, "") \
22172 _(lisp_gpe_add_del_iface, "up|down") \
22173 _(lisp_gpe_enable_disable, "enable|disable") \
22174 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22175 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22176 _(show_lisp_rloc_probe_state, "") \
22177 _(show_lisp_map_register_state, "") \
22178 _(show_lisp_status, "") \
22179 _(lisp_get_map_request_itr_rlocs, "") \
22180 _(show_lisp_pitr, "") \
22181 _(show_lisp_use_petr, "") \
22182 _(show_lisp_map_request_mode, "") \
22183 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22184 _(af_packet_delete, "name <host interface name>") \
22185 _(af_packet_dump, "") \
22186 _(policer_add_del, "name <policer name> <params> [del]") \
22187 _(policer_dump, "[name <policer name>]") \
22188 _(policer_classify_set_interface, \
22189 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22190 " [l2-table <nn>] [del]") \
22191 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22192 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22193 "[master|slave]") \
22194 _(netmap_delete, "name <interface name>") \
22195 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22196 _(mpls_table_dump, "") \
22197 _(mpls_route_dump, "table-id <ID>") \
22198 _(classify_table_ids, "") \
22199 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22200 _(classify_table_info, "table_id <nn>") \
22201 _(classify_session_dump, "table_id <nn>") \
22202 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22203 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22204 "[template_interval <nn>] [udp_checksum]") \
22205 _(ipfix_exporter_dump, "") \
22206 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22207 _(ipfix_classify_stream_dump, "") \
22208 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22209 _(ipfix_classify_table_dump, "") \
22210 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22211 _(sw_interface_span_dump, "[l2]") \
22212 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22213 _(pg_create_interface, "if_id <nn>") \
22214 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22215 _(pg_enable_disable, "[stream <id>] disable") \
22216 _(ip_source_and_port_range_check_add_del, \
22217 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22218 _(ip_source_and_port_range_check_interface_add_del, \
22219 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22220 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22221 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22222 _(l2_interface_pbb_tag_rewrite, \
22223 "<intfc> | sw_if_index <nn> \n" \
22224 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22225 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22226 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22227 _(flow_classify_set_interface, \
22228 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22229 _(flow_classify_dump, "type [ip4|ip6]") \
22230 _(ip_table_dump, "") \
22231 _(ip_route_dump, "table-id [ip4|ip6]") \
22232 _(ip_mtable_dump, "") \
22233 _(ip_mroute_dump, "table-id [ip4|ip6]") \
22234 _(feature_enable_disable, "arc_name <arc_name> " \
22235 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22236 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22238 _(l2_xconnect_dump, "") \
22239 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22240 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22241 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22242 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22243 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22244 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22245 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22246 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22247 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22248 _(sock_init_shm, "size <nnn>") \
22249 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22250 _(dns_enable_disable, "[enable][disable]") \
22251 _(dns_name_server_add_del, "<ip-address> [del]") \
22252 _(dns_resolve_name, "<hostname>") \
22253 _(dns_resolve_ip, "<ip4|ip6>") \
22254 _(dns_name_server_add_del, "<ip-address> [del]") \
22255 _(dns_resolve_name, "<hostname>") \
22256 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22257 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22258 _(session_rules_dump, "") \
22259 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22260 _(output_acl_set_interface, \
22261 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22262 " [l2-table <nn>] [del]") \
22263 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22265 /* List of command functions, CLI names map directly to functions */
22266 #define foreach_cli_function \
22267 _(comment, "usage: comment <ignore-rest-of-line>") \
22268 _(dump_interface_table, "usage: dump_interface_table") \
22269 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22270 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22271 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22272 _(dump_macro_table, "usage: dump_macro_table ") \
22273 _(dump_node_table, "usage: dump_node_table") \
22274 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22275 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22276 _(echo, "usage: echo <message>") \
22277 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22278 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22279 _(help, "usage: help") \
22280 _(q, "usage: quit") \
22281 _(quit, "usage: quit") \
22282 _(search_node_table, "usage: search_node_table <name>...") \
22283 _(set, "usage: set <variable-name> <value>") \
22284 _(script, "usage: script <file-name>") \
22285 _(statseg, "usage: statseg") \
22286 _(unset, "usage: unset <variable-name>")
22289 static void vl_api_##n##_t_handler_uni \
22290 (vl_api_##n##_t * mp) \
22292 vat_main_t * vam = &vat_main; \
22293 if (vam->json_output) { \
22294 vl_api_##n##_t_handler_json(mp); \
22296 vl_api_##n##_t_handler(mp); \
22299 foreach_vpe_api_reply_msg;
22300 #if VPP_API_TEST_BUILTIN == 0
22301 foreach_standalone_reply_msg;
22306 vat_api_hookup (vat_main_t * vam)
22309 vl_msg_api_set_handlers(VL_API_##N, #n, \
22310 vl_api_##n##_t_handler_uni, \
22312 vl_api_##n##_t_endian, \
22313 vl_api_##n##_t_print, \
22314 sizeof(vl_api_##n##_t), 1);
22315 foreach_vpe_api_reply_msg;
22316 #if VPP_API_TEST_BUILTIN == 0
22317 foreach_standalone_reply_msg;
22321 #if (VPP_API_TEST_BUILTIN==0)
22322 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22324 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22326 vam->function_by_name = hash_create_string (0, sizeof (uword));
22328 vam->help_by_name = hash_create_string (0, sizeof (uword));
22331 /* API messages we can send */
22332 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22333 foreach_vpe_api_msg;
22337 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22338 foreach_vpe_api_msg;
22341 /* CLI functions */
22342 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22343 foreach_cli_function;
22347 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22348 foreach_cli_function;
22352 #if VPP_API_TEST_BUILTIN
22353 static clib_error_t *
22354 vat_api_hookup_shim (vlib_main_t * vm)
22356 vat_api_hookup (&vat_main);
22360 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22364 * fd.io coding-style-patch-verification: ON
22367 * eval: (c-set-style "gnu")